public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member)
{
//Type
var type = ((IMemberTreeNode)node).Member as TypeDefinition;
//Creates the method definition
var method = new MethodDefinition(
name,
MethodAttributes.Public,
type.Module.TypeSystem.Void
)
{
MetadataToken = new MetadataToken(TokenType.Method, ILEdit.GlobalContainer.GetFreeRID(type.Module))
};
//Checks if the destination type is an interface
if (type.IsInterface)
method.Attributes |= MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride | MethodAttributes.Abstract | MethodAttributes.Virtual;
//Adds the method to the type
type.Methods.Add(method);
method.Overrides.Clear();
if (node is TypeTreeNode)
{
node.Children.Add(new ILEditTreeNode(method, false));
Helpers.Tree.SortChildren((TypeTreeNode)node);
}
else if (node is ILEditTreeNode)
{
((ILEditTreeNode)node).RefreshChildren();
}
}
/// <summary>
/// Compare IMetadataTokenProvider instances based on their metadata token and their
/// assembly.
/// </summary>
/// <param name="self">The IMetadataTokenProvider instance where the method is applied.</param>
/// <param name="other">The IMetadataTokenProvider instance to compare to</param>
/// <returns>True if the metadata tokens and assembly are identical, False otherwise</returns>
public static bool Equals(this IMetadataTokenProvider self, IMetadataTokenProvider other)
{
if (self == other)
return true;
if (other == null)
return (self == null);
MetadataToken token = self.MetadataToken;
if (!token.Equals(other.MetadataToken))
return false;
// metadata token is unique per assembly
AssemblyDefinition self_assembly = GetAssembly(self);
if (self_assembly == null)
{
// special case for Namespace (where GetAssembly would return null)
if (token.TokenType == NamespaceDefinition.NamespaceTokenType)
return (self as NamespaceDefinition).Name == (other as NamespaceDefinition).Name;
else
return false;
}
AssemblyDefinition other_assembly = GetAssembly(other);
// compare assemblies tokens (but do not recurse)
return other == null ? false : self_assembly.MetadataToken.Equals(other_assembly.MetadataToken);
}
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member)
{
//Name and namespace
var typeName = node is ModuleTreeNode ? (name.Substring(name.Contains(".") ? name.LastIndexOf('.') + 1 : 0)) : name;
var typeNamespace = node is ModuleTreeNode ? (name.Substring(0, name.Contains(".") ? name.LastIndexOf('.') : 0)) : string.Empty;
//Checks that the typename isn't empty
if (string.IsNullOrEmpty(typeName))
{
MessageBox.Show("Please, specify the name of the type", "Type name required", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
//Creates a new class definition
var c = new TypeDefinition(
typeNamespace,
typeName,
TypeAttributes.Class | TypeAttributes.Interface | TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Abstract
)
{
IsAnsiClass = true,
};
//Adds to the node
Helpers.Tree.AddTreeNode(node, c, null, null);
}
void CheckParametersAndValues (IMetadataTokenProvider provider, IMethodSignature constructor, IList<CustomAttributeArgument> arguments)
{
for (int index = 0; index < arguments.Count; index++) {
ParameterDefinition parameter = constructor.Parameters[index];
if (parameter.ParameterType.IsNamed ("System", "String")) {
string value = (string) arguments [index].Value;
if (Contains (parameter.Name, "version")) {
Version v = null;
if (!Version.TryParse (value, out v)) {
string msg = String.Format (CultureInfo.InvariantCulture, "The value passed: {0} can't be parsed to a valid Version.", value);
Runner.Report (provider, Severity.High, Confidence.High, msg);
}
continue;
}
if (Contains (parameter.Name, "url") ||
Contains (parameter.Name, "uri") ||
Contains (parameter.Name, "urn")) {
Uri parsed = null;
if (!Uri.TryCreate (value, UriKind.Absolute, out parsed)) {
string msg = String.Format (CultureInfo.InvariantCulture, "The valued passed {0} can't be parsed to a valid Uri.", value);
Runner.Report (provider, Severity.High, Confidence.High, msg);
}
continue;
}
if (Contains (parameter.Name, "guid")) {
Guid g;
if (!Guid.TryParse (value, out g)) {
string msg = String.Format (CultureInfo.InvariantCulture, "The valued passed {0} can't be parsed to a valid Guid.", value);
Runner.Report (provider, Severity.High, Confidence.High, msg);
}
continue;
}
}
}
}
void ProcessProvider (IMetadataTokenProvider provider)
{
if (!TunerAnnotations.IsInternalized (Context, provider))
return;
Console.WriteLine ("[internalized] {0}", provider);
}
static TypeReference GetReference(Type type, IMetadataTokenProvider metadata)
{
ModuleDefinition module = metadata.GetAssembly().MainModule;
TypeReference tr;
if (!module.TryGetTypeReference(type.FullName, out tr))
tr = module.Import(type);
return tr;
}
public void Add (string rule, IMetadataTokenProvider metadata)
{
HashSet<IMetadataTokenProvider> list;
if (!ignore.TryGetValue (rule, out list)) {
list = new HashSet<IMetadataTokenProvider> ();
ignore.Add (rule, list);
}
list.Add (metadata);
}
void Mark (IMetadataTokenProvider provider, CustomAttribute preserve_attribute)
{
if (IsConditionalAttribute (preserve_attribute)) {
PreserveConditional (provider);
return;
}
PreserveUnconditional (provider);
}
private bool CheckReturnVoid (IMetadataTokenProvider eventType, IMethodSignature invoke)
{
string full_name = invoke.ReturnType.FullName;
if (String.Compare (full_name, "System.Void") == 0)
return true;
string msg = String.Format ("The delegate should return void, not {0}", full_name);
Runner.Report (eventType, Severity.Medium, Confidence.High, msg);
return false;
}
/// <summary>
/// Creates a new instance of this MemberImporter
/// </summary>
/// <param name="member">Member to import</param>
/// <param name="destination">Destination of the importing</param>
/// <param name="session">Importing session</param>
public MemberImporter(IMetadataTokenProvider member, IMetadataTokenProvider destination, MemberImportingSession session)
{
//Checks if the member can be imported (and that member and destination aren't null)
if (!CanImport(member, destination))
throw new ArgumentException(string.Format("{0} cannot import '{1}' into '{2}'", this.GetType().Name, member, destination));
//Stores member and destination
_member = member;
_destination = destination;
_Session = session;
}
/// <summary>
/// Creates a new instance of the class ILEditTreeNode
/// </summary>
/// <param name="tokenProvider"></param>
public ILEditTreeNode(IMetadataTokenProvider tokenProvider, bool manuallyFilledChildren)
{
//Stores the parameters
language = MainWindow.Instance.CurrentLanguage;
_tokenProvider = tokenProvider;
this.LazyLoading = !manuallyFilledChildren;
_manuallyFilledChildren = manuallyFilledChildren;
//Sets the foreground
this.Foreground = GlobalContainer.NewNodesBrush;
}
private static MethodDefinition FindMethodFromLocation (IMetadataTokenProvider location)
{
ParameterDefinition parameter = (location as ParameterDefinition);
if (parameter != null)
return (parameter.Method as MethodDefinition);
MethodReturnType return_type = (location as MethodReturnType);
if (return_type != null)
return (return_type.Method as MethodDefinition);
return (location as MethodDefinition);
}
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member)
{
//Gets the parent module
var moduleNode = Helpers.Tree.GetModuleNode(node);
//Injects the assembly reference
moduleNode.Module.AssemblyReferences.Add(AssemblyNameReference.Parse(name));
//Adds the node
node.Children.Add(new AssemblyReferenceTreeNode(AssemblyNameReference.Parse(name), Helpers.Tree.GetAssemblyNode(moduleNode)) { Foreground = GlobalContainer.NewNodesBrush });
Helpers.Tree.SortChildren((ReferenceFolderTreeNode)node);
}
// AssemblyDefinition AttributeTargets.Assembly
// ModuleDefinition AttributeTargets.Module
// TypeDefinition AttributeTargets.Class | Delegate | Enum | Interface | Struct
// EventDefinition AttributeTargets.Event
// FieldDefinition AttributeTargets.Field
// GenericParameterDefinition AttributeTargets.GenericParameter
// PropertyDefinition AttributeTargets.Property
// MethodDefinition AttributeTargets.Constructor | Method
// GenericParameterDefinition AttributeTargets.GenericParameter
// ParameterDefinition AttributeTargets.Parameter
// MethodReturnType AttributeTargets.ReturnValue
// NamespaceDefinition special case
public bool IsIgnored (IRule rule, IMetadataTokenProvider metadata)
{
// Note that the Runner tearing_down code may call us with nulls.
if (metadata == null)
return false;
if ((rule == null) || !rule.Active)
return true;
HashSet<IMetadataTokenProvider> list;
if (!ignore.TryGetValue (rule.FullName, out list))
return false; // nothing is ignored for this rule
return IsIgnored (list, metadata);
}
private static TypeDefinition FindTypeFromLocation (IMetadataTokenProvider location)
{
MethodDefinition method = (location as MethodDefinition);
if (method != null)
return (method.DeclaringType as TypeDefinition);
FieldDefinition field = (location as FieldDefinition);
if (field != null)
return (field.DeclaringType as TypeDefinition);
ParameterDefinition parameter = (location as ParameterDefinition);
if (parameter != null)
return FindTypeFromLocation (parameter.Method);
return (location as TypeDefinition);
}
public Defect (IRule rule, IMetadataTokenProvider target, IMetadataTokenProvider location, Severity severity, Confidence confidence, string text)
{
if (rule == null)
throw new ArgumentNullException ("rule");
if (target == null)
throw new ArgumentNullException ("target");
if (location == null)
throw new ArgumentNullException ("location");
Rule = rule;
Target = target;
Location = location;
Confidence = confidence;
Severity = severity;
Text = text;
}
protected override void OnSelectionChanged(System.Windows.Controls.SelectionChangedEventArgs e)
{
//Selected item
var selected = (e.AddedItems == null || e.AddedItems.Count == 0 || e.AddedItems[0] == null || !(e.AddedItems[0] is ILEditTreeNode)) ? null : ((ILEditTreeNode)e.AddedItems[0]).TokenProvider;
//Checks the token
if (selected == null || !SelectableMembers.Any(x => x == selected.MetadataToken.TokenType))
{
SelectedMember = null;
}
else
{
SelectedMember = selected;
}
//Call to base method
base.OnSelectionChanged(e);
}
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member)
{
//Name and namespace
var typeName = node is ModuleTreeNode ? (name.Substring(name.Contains(".") ? name.LastIndexOf('.') + 1 : 0)) : name;
var typeNamespace = node is ModuleTreeNode ? (name.Substring(0, name.Contains(".") ? name.LastIndexOf('.') : 0)) : string.Empty;
//Checks that the typename isn't empty
if (string.IsNullOrEmpty(typeName))
{
MessageBox.Show("Please, specify the name of the type", "Type name required", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
//Creates a new class definition
var c = new TypeDefinition(
typeNamespace,
typeName,
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Sealed
)
{
IsAnsiClass = true,
};
//Destination module
ModuleDefinition module = null;
//Adds to the node and specifies the base class
Helpers.Tree.AddTreeNode(node, c,
m => { module = m; c.BaseType = new TypeReference("System", "Enum", m, m.TypeSystem.Corlib, true); },
t => { module = t.Module; c.BaseType = new TypeReference("System", "Enum", t.Module, t.Module.TypeSystem.Corlib, true); }
);
//Injects the field value___
c.Fields.Add(new FieldDefinition(
"value__",
FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName,
module.TypeSystem.Int32
));
}
public bool IsPublic (IMetadataTokenProvider provider)
{
return public_api.Contains (provider);
}
public void Processed(IMetadataTokenProvider provider)
{
processed.Add(provider);
}
public bool IsProcessed (IMetadataTokenProvider provider)
{
return processed.Contains (provider);
}
public bool IsProcessed(IMetadataTokenProvider provider)
{
return(processed.Contains(provider));
}
public AnnotatedStringValue(IMetadataTokenProvider sourceContext, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes)
{
Kind = ValueNodeKind.AnnotatedString;
DynamicallyAccessedMemberTypes = dynamicallyAccessedMemberTypes;
SourceContext = sourceContext;
}
public void Mark(IMetadataTokenProvider provider)
{
throw null;
}
public void SetCustomAnnotation(object key, IMetadataTokenProvider item, object value)
{
throw null;
}
public bool IsPublic(IMetadataTokenProvider provider)
{
return(public_api.Contains(provider));
}
protected abstract bool CanImportCore(IMetadataTokenProvider member, IMetadataTokenProvider destination);
public void UnrecognizedReflectionAccessPattern(IMemberDefinition source, Instruction sourceInstruction, IMetadataTokenProvider accessedItem, string message)
{
var origin = new MessageOrigin(source, sourceInstruction?.Offset);
_context.LogWarning(message, 2006, origin, MessageSubCategory.TrimAnalysis);
}
// let product filters what get's included to help preserve extraneous serialization members
// e.g. ensure we don't keep stuff that triggers DRM checks
protected virtual IMetadataTokenProvider FilterExtraSerializationMembers(IMetadataTokenProvider provider)
{
return(provider);
}
public void RecognizedReflectionAccessPattern(IMemberDefinition source, Instruction sourceInstruction, IMetadataTokenProvider accessedItem)
{
// Do nothing - there's no logging for successfully recognized patterns
}
public AssemblyReferenceImporter(IMetadataTokenProvider member, MemberImportingSession session)
: base(member, session.DestinationModule, session)
{
}
void InternalMark(IMetadataTokenProvider provider)
{
Annotations.Mark(provider);
Annotations.SetPublic(provider);
}
private bool CheckParameterName (IMetadataTokenProvider eventType, ParameterReference invokeParameter, string expectedName)
{
if (String.Compare (invokeParameter.Name, expectedName) == 0)
return true;
Runner.Report (eventType, Severity.Low, Confidence.High, String.Format ("The expected name is {0}, not {1}", expectedName, invokeParameter.Name));
return false;
}
protected override bool CanImportCore(IMetadataTokenProvider member, IMetadataTokenProvider destination)
{
return(true);
}
public EventImporter(IMetadataTokenProvider member, IMetadataTokenProvider destination, MemberImportingSession session, bool createNode)
: base(member, destination, session)
{
_createNode = createNode;
}
/// <summary>
/// Creates a new instance of this MemberImporter
/// </summary>
/// <param name="member">Member to import</param>
/// <param name="session">Importing session</param>
public MemberImporter(IMetadataTokenProvider member, MemberImportingSession session)
: this(member, session.Destination, session)
{
}
public object GetCustomAnnotation(object key, IMetadataTokenProvider item)
{
throw null;
}
private RuleResult ReportResults(IMetadataTokenProvider method)
{
foreach (KeyValuePair<string, KeyValuePair<MethodDefinition, int>> kvp in calls) {
// look which getter we're calling more than once
int count = kvp.Value.Value;
if (count == 1)
continue;
MethodDefinition md = kvp.Value.Key;
if (md.IsVirtual && !md.IsFinal) {
// virtual calls are expensive, so the code better cache the value
string msg = String.Format (CultureInfo.InvariantCulture,
"Multiple ({0}) calls to virtual property '{1}'.", count, md.ToString ());
Runner.Report (method, GetSeverity (count, true), Confidence.Normal, msg);
} else if (!IsInliningCandidate (md)) {
// non-virtual calls might be inlined
// otherwise caching the value is again a good idea
int size = md.HasBody ? md.Body.CodeSize : 0;
string msg = String.Format (CultureInfo.InvariantCulture,
"Multiple ({0}) calls to non-virtual property '{1}', likely non-inlined due to size ({2} >= {3}).",
count, md.ToString (), size, InlineLimit);
Runner.Report (method, GetSeverity (count, false), Confidence.Normal, msg);
}
}
return Runner.CurrentRuleResult;
}
private void CheckSatelliteResource(EmbeddedResource mainResource, EmbeddedResource satelliteResource, IMetadataTokenProvider satelliteAssembly)
{
using (Stream resourceStream = satelliteResource.GetResourceStream())
using (ResourceSet resourceSet = new ResourceSet(resourceStream))
{
foreach (DictionaryEntry entry in resourceSet)
{
string resourceName = (string)entry.Key;
object satelliteValue = entry.Value;
object mainValue;
if (!mainAssemblyResourceCache.TryGetMainResource(mainResource, resourceName, out mainValue))
{
string msg = String.Format(CultureInfo.InvariantCulture,
"The resource {0} in the file {1} exist in the satellite assembly but not in the main assembly",
resourceName, satelliteResource.Name);
Runner.Report(satelliteAssembly, Severity.Low, Confidence.High, msg);
continue;
}
Type satelliteType = satelliteValue.GetType();
Type mainType = mainValue.GetType();
if (!satelliteType.Equals(mainType))
{
string msg = String.Format(CultureInfo.InvariantCulture,
"The resource {0} in the file {1} is of type {2} in the satellite assembly but of type {3} in the main assembly",
resourceName, satelliteResource.Name, satelliteType, mainType);
Runner.Report(satelliteAssembly, Severity.High, Confidence.High, msg);
continue;
}
if (satelliteType.Equals(typeof(string)))
{
Bitmask <int> mainParameters = GetStringFormatExpectedParameters((string)mainValue);
Bitmask <int> satelliteParameters = GetStringFormatExpectedParameters((string)satelliteValue);
if (!mainParameters.Equals(satelliteParameters))
{
string msg = String.Format(CultureInfo.InvariantCulture,
"The string resource {0} in the file {1} does not use the same string format parameters in the satellite and main assemblies",
resourceName, satelliteResource.Name);
Runner.Report(satelliteAssembly, Severity.High, Confidence.Normal, msg);
}
}
}
}
}
public void SetPublic(IMetadataTokenProvider provider)
{
public_api.Add(provider);
}
public void Inject(ICSharpCode.ILSpy.TreeNodes.ILSpyTreeNode node, string name, IMetadataTokenProvider member)
{
//Name and namespace
var typeName = node is ModuleTreeNode ? (name.Substring(name.Contains(".") ? name.LastIndexOf('.') + 1 : 0)) : name;
var typeNamespace = node is ModuleTreeNode ? (name.Substring(0, name.Contains(".") ? name.LastIndexOf('.') : 0)) : string.Empty;
//Checks that the typename isn't empty
if (string.IsNullOrEmpty(typeName))
{
MessageBox.Show("Please, specify the name of the type", "Type name required", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
//Creates a new class definition
var c = new TypeDefinition(
typeNamespace,
typeName,
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Sealed
)
{
IsAnsiClass = true,
};
//Destination module
ModuleDefinition module = null;
//Adds to the node and specifies the base class
Helpers.Tree.AddTreeNode(node, c,
m => { module = m; c.BaseType = new TypeReference("System", "Enum", m, m.TypeSystem.Corlib, true); },
t => { module = t.Module; c.BaseType = new TypeReference("System", "Enum", t.Module, t.Module.TypeSystem.Corlib, true); }
);
//Injects the field value___
c.Fields.Add(new FieldDefinition(
"value__",
FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName,
module.TypeSystem.Int32
));
}
private bool CheckAmountOfParameters (IMetadataTokenProvider eventType, IMethodSignature invoke)
{
if (invoke.HasParameters && (invoke.Parameters.Count == 2))
return true;
Runner.Report (eventType, Severity.Medium, Confidence.High, "The delegate should have 2 parameters");
return false;
}
public MethodParameterValue(int parameterIndex, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes, IMetadataTokenProvider sourceContext)
{
Kind = ValueNodeKind.MethodParameter;
ParameterIndex = parameterIndex;
DynamicallyAccessedMemberTypes = dynamicallyAccessedMemberTypes;
SourceContext = sourceContext;
}
public bool IsMarked(IMetadataTokenProvider provider)
{
throw null;
}
public void Processed (IMetadataTokenProvider provider)
{
processed.Add (provider);
}
/// <summary>
/// Loads the children
/// </summary>
protected override void LoadChildren()
{
//Checks if the children must be filled manually
if (ManuallyFilledChildren)
return;
//IEnumerable containing the childrenot the node
IEnumerable<IMetadataTokenProvider> children = null;
//Assembly
if (_tokenProvider is AssemblyDefinition)
children = ((AssemblyDefinition)_tokenProvider).Modules;
//Module
else if (_tokenProvider is ModuleDefinition)
{
//Types
IEnumerable<TypeDefinition> types = ((ModuleDefinition)_tokenProvider).Types;
if (this.ChildrenFilter != null)
types = types.Where(x => this.ChildrenFilter(x));
//Groups the types by namespace and adds
foreach (var node in types.GroupBy(x => x.Namespace)
.OrderBy(x => x.Key)
.Select(x =>
{
var n = new NamespaceTreeNode(x.Key);
foreach (var t in x.OrderBy(y => y.Name))
n.Children.Add(new ILEditTreeNode(t, false) { ChildrenFilter = this.ChildrenFilter, Foreground = this.Foreground });
return n;
}))
{
this.Children.Add(node);
}
//Returns
return;
}
//Type
else if (_tokenProvider is TypeDefinition)
{
var type = (TypeDefinition)_tokenProvider;
children =
type.NestedTypes.Cast<IMetadataTokenProvider>()
.Concat(type.Fields)
.Concat(type.Methods.Where(x => !(x.IsGetter || x.IsSetter || x.IsAddOn || x.IsRemoveOn || x.IsFire)))
.Concat(type.Properties)
.Concat(type.Events);
}
//Property
else if (_tokenProvider is PropertyDefinition)
{
var prop = (PropertyDefinition)_tokenProvider;
children =
new IMetadataTokenProvider[] { prop.GetMethod, prop.SetMethod }
.Where(x => x != null)
.Concat(prop.HasOtherMethods ? prop.OtherMethods.Cast<IMetadataTokenProvider>() : new IMetadataTokenProvider[] { });
}
//Event
else if (_tokenProvider is EventDefinition)
{
var evt = (EventDefinition)_tokenProvider;
children =
new IMetadataTokenProvider[] { evt.AddMethod, evt.RemoveMethod, evt.InvokeMethod }
.Where(x => x != null)
.Concat(evt.HasOtherMethods ? evt.OtherMethods.Cast<IMetadataTokenProvider>() : new IMetadataTokenProvider[] { });
}
//If there are no children returns
if (children == null)
return;
//Applies the filtering
if (ChildrenFilter != null)
children = children.Where(x => ChildrenFilter(x));
//Adds the children
foreach (var x in children)
this.Children.Add(new ILEditTreeNode(x, false) { ChildrenFilter = this.ChildrenFilter, Foreground = this.Foreground });
}
public void SetPublic (IMetadataTokenProvider provider)
{
public_api.Add (provider);
}
public bool IsMarked(IMetadataTokenProvider provider)
{
return(marked.Contains(provider));
}
private bool CheckParameterTypes (IMetadataTokenProvider eventType, IMethodSignature invoke)
{
bool ok = true;
if (!invoke.HasParameters)
return ok;
IList<ParameterDefinition> pdc = invoke.Parameters;
if (pdc.Count >= 1) {
string type_name = pdc [0].ParameterType.FullName;
if (String.Compare (type_name, "System.Object") != 0) {
Runner.Report (eventType, Severity.Medium, Confidence.High, String.Format ("The first parameter should have an object, not {0}", type_name));
ok = false;
}
}
if (pdc.Count >= 2) {
if (!pdc [1].ParameterType.Inherits ("System.EventArgs")) {
Runner.Report (eventType, Severity.Medium, Confidence.High, "The second parameter should be a subclass of System.EventArgs");
ok = false;
}
}
return ok;
}
/// <summary>
/// Creates a new instance of the <see cref="MethodBodySerializationContext"/> class.
/// </summary>
/// <param name="tokenProvider">
/// The object responsible for providing new metadata tokens to members referenced by instructions.
/// </param>
/// <param name="diagnosticBag">
/// The bag that is used to collect diagnostic information during the serialization process.
/// </param>
public MethodBodySerializationContext(IMetadataTokenProvider tokenProvider, DiagnosticBag diagnosticBag)
{
TokenProvider = tokenProvider ?? throw new ArgumentNullException(nameof(tokenProvider));
DiagnosticBag = diagnosticBag ?? throw new ArgumentNullException(nameof(diagnosticBag));
}
public void UnrecognizedReflectionAccessPattern(IMemberDefinition source, Instruction sourceInstruction, IMetadataTokenProvider accessedItem, string message)
{
PreviousRecorder?.UnrecognizedReflectionAccessPattern(source, sourceInstruction, accessedItem, message);
UnrecognizedPatterns.Add(new ReflectionAccessPattern {
Source = source,
SourceInstruction = sourceInstruction,
AccessedItem = accessedItem,
Message = message
});
}
public EventImporter(IMetadataTokenProvider member, IMetadataTokenProvider destination, MemberImportingSession session)
: this(member, destination, session, true)
{
}
public GenericInstanceTypeImporter(IMetadataTokenProvider member, IMetadataTokenProvider destination, MemberImportingSession session)
: base(member, destination, session)
{
}
string GetKey(IMetadataTokenProvider provider)
{
return($"{provider.MetadataToken.TokenType}:{provider}");
}
private UInt32 GetMetadataToken(
IMetadataTokenProvider token)
{
UInt16 referenceId;
switch (token.MetadataToken.TokenType)
{
case TokenType.TypeRef:
_context.TypeReferencesTable.TryGetTypeReferenceId((TypeReference)token, out referenceId);
return (UInt32)0x01000000 | referenceId;
case TokenType.TypeDef:
_context.TypeDefinitionTable.TryGetTypeReferenceId((TypeDefinition)token, out referenceId);
return (UInt32)0x04000000 | referenceId;
case TokenType.TypeSpec:
_context.TypeSpecificationsTable.TryGetTypeReferenceId((TypeReference) token, out referenceId);
return (UInt32)0x08000000 | referenceId;
case TokenType.Field:
_context.FieldsTable.TryGetFieldReferenceId((FieldDefinition) token, false, out referenceId);
return (UInt32)0x05000000 | referenceId;
}
return 0U;
}
public ReflectionPatternContext(LinkContext context, IMemberDefinition source, IMetadataTokenProvider memberWithRequirements,
Instruction instruction = null)
{
_context = context;
Source = source;
MemberWithRequirements = memberWithRequirements;
Instruction = instruction;
#if DEBUG
_patternAnalysisAttempted = false;
_patternReported = false;
#endif
}
protected virtual void ElementRemoved(IMetadataTokenProvider element)
{
}
public void Mark(IMetadataTokenProvider provider)
{
marked.Add(provider);
}
protected bool CheckProcessed (IMetadataTokenProvider provider)
{
if (Annotations.IsProcessed (provider))
return true;
Annotations.Processed (provider);
return false;
}
public void RecognizedReflectionAccessPattern(IMemberDefinition source, Instruction sourceInstruction, IMetadataTokenProvider accessedItem)
{
PreviousRecorder?.RecognizedReflectionAccessPattern(source, sourceInstruction, accessedItem);
RecognizedPatterns.Add(new ReflectionAccessPattern {
Source = source,
SourceInstruction = sourceInstruction,
AccessedItem = accessedItem
});
}
