public static IMethodReference CanonicalizeMethodReference(IMethodReference method) { // function pointers don't have declaring types and they don't // really fit our model, so we ignore them. if (null == method.ContainingType) { return(null); } // // first canonicalize the method... // IGenericMethodInstanceReference genMeth = method as IGenericMethodInstanceReference; if ((genMeth != null)) { method = genMeth.GenericMethod; } //ITypeDefinitionMember memberDef; ISpecializedMethodReference specializedMethodRef = method as ISpecializedMethodReference; if (specializedMethodRef != null) { method = specializedMethodRef.UnspecializedVersion; } //else //member = member as ITypeDefinitionMember; return(method); }
public override void Visit(ISpecializedMethodReference specializedMethodReference) { if (Process(specializedMethodReference)) { visitor.Visit(specializedMethodReference); } base.Visit(specializedMethodReference); }
public override void Visit(IMethodReference methodReference) { IGenericMethodInstanceReference /*?*/ genericMethodInstanceReference = methodReference.AsGenericMethodInstanceReference; if (genericMethodInstanceReference != null) { this.Visit(genericMethodInstanceReference); return; } if (!alreadySeen.Add(methodReference)) { return; } // If we have a ref to a varargs method then we always generate an entry in the MethodRef table, // even if it is a method in the current module. (Note that we are not *required* to do so if // in fact the number of extra arguments passed is zero; in that case we are permitted to use // an ordinary method def token. We consistently choose to emit a method ref regardless.) IUnitReference /*?*/ definingUnit = TypeHelper.GetDefiningUnitReference(methodReference.GetContainingType(Context), Context); if (definingUnit != null && ReferenceEquals(definingUnit, this.module) && !methodReference.AcceptsExtraArguments) { return; } this.Visit((ITypeMemberReference)methodReference); ISpecializedMethodReference /*?*/ specializedMethodReference = methodReference.AsSpecializedMethodReference; if (specializedMethodReference != null) { IMethodReference unspecializedMethodReference = specializedMethodReference.UnspecializedVersion; this.Visit(unspecializedMethodReference.GetType(Context)); this.Visit(unspecializedMethodReference.GetParameters(Context)); if (unspecializedMethodReference.ReturnValueIsModified) { this.Visit(unspecializedMethodReference.ReturnValueCustomModifiers); } } else { this.Visit(methodReference.GetType(Context)); this.Visit(methodReference.GetParameters(Context)); if (methodReference.ReturnValueIsModified) { this.Visit(methodReference.ReturnValueCustomModifiers); } } if (methodReference.AcceptsExtraArguments) { this.Visit(methodReference.ExtraParameters); } ReserveMethodToken(methodReference); }
private static void VisitMethodReference(IMethodReference methodReference, EmitContext context) { Debug.Assert(methodReference != null); // Visit containing type VisitTypeReference(methodReference.GetContainingType(context), context); // Visit generic arguments if any IGenericMethodInstanceReference genericInstance = methodReference.AsGenericMethodInstanceReference; if (genericInstance != null) { foreach (var arg in genericInstance.GetGenericArguments(context)) { VisitTypeReference(arg, context); } methodReference = genericInstance.GetGenericMethod(context); } // Translate substituted method to original definition ISpecializedMethodReference specializedMethod = methodReference.AsSpecializedMethodReference; if (specializedMethod != null) { methodReference = specializedMethod.UnspecializedVersion; } // Visit parameter types VisitParameters(methodReference.GetParameters(context), context); if (methodReference.AcceptsExtraArguments) { VisitParameters(methodReference.ExtraParameters, context); } // Visit return value type VisitTypeReference(methodReference.GetType(context), context); foreach (var typeModifier in methodReference.RefCustomModifiers) { VisitTypeReference(typeModifier.GetModifier(context), context); } foreach (var typeModifier in methodReference.ReturnValueCustomModifiers) { VisitTypeReference(typeModifier.GetModifier(context), context); } }
public static T UnWrapMember <T>(this T member) where T : ITypeMemberReference { IGenericMethodInstanceReference genericMethod = member as IGenericMethodInstanceReference; if (genericMethod != null) { return((T)genericMethod.GenericMethod.UnWrapMember()); } ISpecializedNestedTypeReference type = member as ISpecializedNestedTypeReference; if (type != null) { return((T)type.UnspecializedVersion.UnWrapMember()); } ISpecializedMethodReference method = member as ISpecializedMethodReference; if (method != null) { return((T)method.UnspecializedVersion.UnWrapMember()); } ISpecializedFieldReference field = member as ISpecializedFieldReference; if (field != null) { return((T)field.UnspecializedVersion.UnWrapMember()); } ISpecializedPropertyDefinition property = member as ISpecializedPropertyDefinition; if (property != null) { return((T)property.UnspecializedVersion.UnWrapMember()); } ISpecializedEventDefinition evnt = member as ISpecializedEventDefinition; if (evnt != null) { return((T)evnt.UnspecializedVersion.UnWrapMember()); } return(member); }
/// <summary> /// Performs some computation with the given specialized method reference. /// </summary> public virtual void Visit(ISpecializedMethodReference specializedMethodReference) { }
public void Visit(ISpecializedMethodReference specializedMethodReference) { throw new NotImplementedException(); }
public override void TraverseChildren(ISpecializedMethodReference specializedMethodReference) { MethodEnter(specializedMethodReference); base.TraverseChildren(specializedMethodReference); MethodExit(); }
public virtual void onMetadataElement(ISpecializedMethodReference specializedMethodReference) { }
public void Visit(ISpecializedMethodReference specializedMethodReference) { this.traverser.Traverse(specializedMethodReference); }
public static ITypeMemberReference CanonicalizeMemberReference(ITypeMemberReference member) { if (null == member) { return(null); } if (member == null || member == Dummy.Method) { throw new Exception("Can't resolve member"); } // function pointers don't have declaring types and they don't // really fit our model, so we ignore them. if (null == member.ContainingType) { return(null); } // // first canonicalize the method... // IGenericMethodInstanceReference genMeth = member as IGenericMethodInstanceReference; if ((genMeth != null)) { member = genMeth.GenericMethod; } ISpecializedMethodReference specializedMethodRef = member as ISpecializedMethodReference; ISpecializedFieldReference specializedFieldRef = member as ISpecializedFieldReference; ISpecializedPropertyDefinition specializedPropertyDef = member as ISpecializedPropertyDefinition; ISpecializedEventDefinition specializedEventDef = member as ISpecializedEventDefinition; ISpecializedMethodDefinition specializedMethodDef = member as ISpecializedMethodDefinition; ISpecializedFieldDefinition specializedFieldDef = member as ISpecializedFieldDefinition; if (specializedMethodRef != null) { member = specializedMethodRef.UnspecializedVersion; } else if (specializedFieldRef != null) { member = specializedFieldRef.UnspecializedVersion; } else if (specializedPropertyDef != null) { member = specializedPropertyDef.UnspecializedVersion; } else if (specializedEventDef != null) { member = specializedEventDef.UnspecializedVersion; } else if (specializedMethodDef != null) { member = specializedMethodDef.UnspecializedVersion; } else if (specializedFieldDef != null) { member = specializedFieldDef.UnspecializedVersion; } if (member == null) { throw new Exception("Can't canonicalize some member."); } return(member); }
/// <summary> /// Rewrites the given specialized method reference. /// </summary> public virtual IMethodReference Rewrite(ISpecializedMethodReference specializedMethodReference) { return specializedMethodReference; }
public override void Visit(ISpecializedMethodReference specializedMethodReference) { allElements.Add(new InvokInfo(Traverser, "ISpecializedMethodReference", specializedMethodReference)); }
public override void Visit(ISpecializedMethodReference specializedMethodReference) { if(Process(specializedMethodReference)){visitor.Visit(specializedMethodReference);} base.Visit(specializedMethodReference); }
/// <summary> /// Traverses the specialized method reference. /// </summary> public void Traverse(ISpecializedMethodReference specializedMethodReference) { Contract.Requires(specializedMethodReference != null); if (!this.objectsThatHaveAlreadyBeenTraversed.Add(specializedMethodReference)) return; if (this.preorderVisitor != null) this.preorderVisitor.Visit(specializedMethodReference); if (this.stopTraversal) return; this.TraverseChildren(specializedMethodReference); if (this.stopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(specializedMethodReference); }
/// <summary> /// Traverses the children of the specialized method reference. /// </summary> public virtual void TraverseChildren(ISpecializedMethodReference specializedMethodReference) { Contract.Requires(specializedMethodReference != null); this.TraverseChildren((IMethodReference)specializedMethodReference); if (this.stopTraversal) return; this.Traverse(specializedMethodReference.UnspecializedVersion); }
/// <summary> /// Performs some computation with the given specialized method reference. /// </summary> public virtual void Visit(ISpecializedMethodReference specializedMethodReference) { }
/// <summary> /// Performs some computation with the given specialized method reference. /// </summary> public void Visit(ISpecializedMethodReference specializedMethodReference) { this.Visit((IMethodReference)specializedMethodReference); }
public virtual void onMetadataElement(ISpecializedMethodReference specializedMethodReference) { }
public override void TraverseChildren(ISpecializedMethodReference specializedMethodReference) { MethodEnter(specializedMethodReference); base.TraverseChildren(specializedMethodReference); MethodExit(); }
/// <summary> /// Traverses the children of the specialized method reference. /// </summary> public virtual void TraverseChildren(ISpecializedMethodReference specializedMethodReference) { this.TraverseChildren((IMethodReference)specializedMethodReference); if (this.stopTraversal) return; this.Traverse(specializedMethodReference.UnspecializedVersion); }