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); }
/// <summary> /// Appends a formatted string of type arguments. Enclosed in angle brackets and comma-delimited. /// </summary> protected override void AppendGenericArguments(IGenericMethodInstanceReference method, NameFormattingOptions formattingOptions, StringBuilder sb) { Contract.Requires(method != null); Contract.Requires(sb != null); if ((formattingOptions & NameFormattingOptions.OmitTypeArguments) != 0) { return; } sb.Append("(Of "); bool first = true; string delim = ((formattingOptions & NameFormattingOptions.OmitWhiteSpaceAfterListDelimiter) == 0) ? ", " : ","; foreach (ITypeReference argument in method.GenericArguments) { if (first) { first = false; } else { sb.Append(delim); } sb.Append(this.typeNameFormatter.GetTypeName(argument, formattingOptions)); } sb.Append(")"); }
public override void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { if (Process(genericMethodInstanceReference)) { visitor.Visit(genericMethodInstanceReference); } base.Visit(genericMethodInstanceReference); }
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); }
public override void TraverseChildren(IGenericMethodInstanceReference genericMethodInstanceReference) { var methodDef = genericMethodInstanceReference.ResolvedMethod; if (methodDef == Dummy.Method) { this.EmitError(genericMethodInstanceReference, ErrorCode.GenericMethodInstanceResolution); } base.TraverseChildren(genericMethodInstanceReference); }
public virtual void Visit(IMethodReference methodReference) { IGenericMethodInstanceReference genericMethodInstanceReference = methodReference.AsGenericMethodInstanceReference; if (genericMethodInstanceReference != null) { this.Visit(genericMethodInstanceReference); } else { this.Visit((ITypeMemberReference)methodReference); } }
private MethodBase GetGenericMethodInstance(IGenericMethodInstanceReference genericMethodInstanceReference) { var genericMethodReference = genericMethodInstanceReference.GenericMethod; var genericMethod = (MethodInfo)this.GetMethod(genericMethodReference); var typeArguments = new Type[genericMethodReference.GenericParameterCount]; var i = 0; foreach (var arg in genericMethodInstanceReference.GenericArguments) { typeArguments[i++] = this.GetType(arg); } var genericMethodInstance = genericMethod.MakeGenericMethod(typeArguments); this.methodMap.Add(genericMethodInstanceReference.InternedKey, genericMethodInstance); return(genericMethodInstance); }
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> /// Returns a C#-like string that corresponds to the signature of the given method and that conforms to the specified formatting options. /// </summary> //^ [Pure] public virtual string GetMethodSignature(IMethodReference method, NameFormattingOptions formattingOptions) { StringBuilder sb = new StringBuilder(); this.AppendReturnTypeSignature(method, formattingOptions, sb); this.AppendMethodName(method, formattingOptions, sb); IGenericMethodInstanceReference /*?*/ genericMethodInstance = method as IGenericMethodInstanceReference; if (genericMethodInstance != null) { this.AppendGenericArguments(genericMethodInstance, formattingOptions, sb); } else if (method.IsGeneric) { this.AppendGenericParameters(method, formattingOptions, sb); } this.AppendMethodParameters(method.Parameters, formattingOptions, sb); return(sb.ToString()); }
private IMethodReference GetCorrespondingThreeArgContractMethod(IMethodReference originalMethod) { ushort genericParameters = 0; string contractMethodName = originalMethod.Name.Value; string keyName = contractMethodName; IGenericMethodInstanceReference methodInstance = originalMethod as IGenericMethodInstanceReference; if (methodInstance != null) { originalMethod = methodInstance.GenericMethod; genericParameters = originalMethod.GenericParameterCount; keyName = originalMethod.Name.Value + genericParameters; } #region Backward compatibility with v4 Beta 1 which went out with RequiresAlways in it (REMOVE WHEN THAT IS DELETED) bool backwardCompat = false; if (contractMethodName.Equals("RequiresAlways")) { contractMethodName = "Requires1"; // The one is for the generic parameter genericParameters = 1; backwardCompat = true; } #endregion Backward compatibility with v4 Beta 1 which went out with RequiresAlways in it (REMOVE WHEN THAT IS DELETED) IMethodReference methodToUse; this.threeArgumentVersionofContractMethod.TryGetValue(keyName, out methodToUse); if (methodToUse == null) { #region Create a method methodToUse = CreateThreeArgVersionOfMethod(contractMethodName, keyName, genericParameters, backwardCompat); #endregion Create a method } if (genericParameters != 0) { // instantiate method to use methodToUse = new Microsoft.Cci.Immutable.GenericMethodInstanceReference(methodToUse, backwardCompat ? IteratorHelper.GetSingletonEnumerable <ITypeReference>(this.systemArgumentExceptionType) : methodInstance.GenericArguments, this.host.InternFactory); var key = methodToUse.InternedKey; } return(methodToUse); }
/// <summary> /// Appends a formatted string of type arguments. Enclosed in angle brackets and comma-delimited. /// </summary> protected virtual void AppendGenericArguments(IGenericMethodInstanceReference method, NameFormattingOptions formattingOptions, StringBuilder sb) { if ((formattingOptions & NameFormattingOptions.OmitTypeArguments) != 0) { return; } sb.Append("<"); bool first = true; string delim = ((formattingOptions & NameFormattingOptions.OmitWhiteSpaceAfterListDelimiter) == 0) ? ", " : ","; foreach (ITypeReference argument in method.GenericArguments) { if (first) { first = false; } else { sb.Append(delim); } sb.Append(_typeNameFormatter.GetTypeName(argument, formattingOptions)); } sb.Append(">"); }
public override void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { this.Visit(genericMethodInstanceReference.GetGenericArguments(Context)); this.Visit(genericMethodInstanceReference.GetGenericMethod(Context)); }
public override void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { genericMethodInstanceReference.GenericMethod.ResolvedMethod.Dispatch(this); foreach (var genArg in genericMethodInstanceReference.GenericArguments) { Contract.Assume(genArg != null); genArg.ResolvedType.Dispatch(this); } }
/// <summary> /// Rewrites the given generic method instance reference. /// </summary> public virtual IGenericMethodInstanceReference Rewrite( IGenericMethodInstanceReference genericMethodInstanceReference) { return genericMethodInstanceReference; }
public virtual void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { }
protected override uint GetOrAddMethodSpecIndex(IGenericMethodInstanceReference reference) { return(this.methodSpecIndex.GetOrAdd(reference)); }
/// <summary> /// Traverses the children of the generic method instance reference. /// </summary> public virtual void TraverseChildren(IGenericMethodInstanceReference genericMethodInstanceReference) { Contract.Requires(genericMethodInstanceReference != null); this.TraverseChildren((IMethodReference)genericMethodInstanceReference); this.Traverse(genericMethodInstanceReference.Attributes); if (this.stopTraversal) return; this.Traverse(genericMethodInstanceReference.ContainingType); if (this.stopTraversal) return; this.Traverse(genericMethodInstanceReference.GenericArguments); if (this.stopTraversal) return; this.Traverse(genericMethodInstanceReference.GenericMethod); //cannot be generic if (this.stopTraversal) return; this.Traverse(genericMethodInstanceReference.Parameters); if (this.stopTraversal) return; this.Traverse(genericMethodInstanceReference.Type); if (this.stopTraversal) return; if (genericMethodInstanceReference.ReturnValueIsModified) this.Traverse(genericMethodInstanceReference.ReturnValueCustomModifiers); }
/// <summary> /// Traverses the generic method instance reference. /// </summary> public void Traverse(IGenericMethodInstanceReference genericMethodInstanceReference) { Contract.Requires(genericMethodInstanceReference != null); if (!this.objectsThatHaveAlreadyBeenTraversed.Add(genericMethodInstanceReference)) return; if (this.preorderVisitor != null) this.preorderVisitor.Visit(genericMethodInstanceReference); if (this.stopTraversal) return; this.TraverseChildren(genericMethodInstanceReference); if (this.stopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(genericMethodInstanceReference); }
uint GetGenericMethodInstanceReferenceInternedKey(IGenericMethodInstanceReference genericMethodInstanceReference) { Contract.Requires(genericMethodInstanceReference != null); var genericMethodInternedId = genericMethodInstanceReference.GenericMethod.InternedKey; uint genericArgumentsInternedId = this.GetTypeReferenceListInternedId(genericMethodInstanceReference.GenericArguments.GetEnumerator()); uint value = this.GenericMethodInstanceHashtable.Find(genericMethodInternedId, genericArgumentsInternedId); if (value == 0) { value = this.CurrentMethodReferenceInternValue++; this.GenericMethodInstanceHashtable.Add(genericMethodInternedId, genericArgumentsInternedId, value); } return value; }
protected override MethodSpecificationHandle GetOrAddMethodSpecificationHandle(IGenericMethodInstanceReference reference) { return(MetadataTokens.MethodSpecificationHandle(_methodSpecIndex.GetOrAdd(reference))); }
public override void TraverseChildren(IGenericMethodInstanceReference genericMethodInstanceReference) { base.TraverseChildren(genericMethodInstanceReference); }
public override void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { allElements.Add(new InvokInfo(Traverser, "IGenericMethodInstanceReference", genericMethodInstanceReference)); }
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); }
public override void TraverseChildren(IGenericMethodInstanceReference genericMethodInstanceReference) { if (this.closedGenericMethodInstances[genericMethodInstanceReference.InternedKey] != null) return; if (!IsOpen(genericMethodInstanceReference)) { this.closedGenericMethodInstances[genericMethodInstanceReference.InternedKey] = genericMethodInstanceReference; this.TraverseChildren(genericMethodInstanceReference.ResolvedMethod); } }
public override void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { this.Visit(genericMethodInstanceReference.GetGenericArguments(Context)); this.Visit(genericMethodInstanceReference.GetGenericMethod(Context)); }
public override void Visit(IGenericMethodInstanceReference method) { // TODO: check Visit(method.GenericArguments); Visit(method.GenericMethod); }
public override void TraverseChildren(IGenericMethodInstanceReference genericMethodInstanceReference) { base.TraverseChildren(genericMethodInstanceReference); }
public override void TraverseChildren(IGenericMethodInstanceReference genericMethodInstanceReference) { MethodEnter(genericMethodInstanceReference); base.TraverseChildren(genericMethodInstanceReference); MethodExit(); }
//^ ensures this.path.Count == old(this.path.Count); /// <summary> /// Performs some computation with the given generic method instance reference. /// </summary> /// <param name="genericMethodInstanceReference"></param> public virtual void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { }
public void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { throw new NotImplementedException(); }
public void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { this.traverser.Traverse(genericMethodInstanceReference); }
public override void Visit(IGenericMethodInstanceReference method) { // TODO: check Visit(method.GenericArguments); Visit(method.GenericMethod); }
/// <summary> /// Performs some computation with the given generic method instance reference. /// </summary> public void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { this.Visit((IMethodReference)genericMethodInstanceReference); }
public override void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) { if(Process(genericMethodInstanceReference)){visitor.Visit(genericMethodInstanceReference);} base.Visit(genericMethodInstanceReference); }
/// <summary> /// Performs some computation with the given generic method instance reference. /// </summary> /// <param name="genericMethodInstanceReference"></param> public virtual void Visit(IGenericMethodInstanceReference genericMethodInstanceReference) //^ ensures this.path.Count == old(this.path.Count); { }
public static bool IsOpen(IGenericMethodInstanceReference genericMethodInstanceReference) { Contract.Requires(genericMethodInstanceReference != null); if (TypeHelper.IsOpen(genericMethodInstanceReference.ContainingType)) return true; foreach (var genArg in genericMethodInstanceReference.GenericArguments) { Contract.Assume(genArg != null); if (TypeHelper.IsOpen(genArg)) return true; } return false; }
public virtual void onMetadataElement(IGenericMethodInstanceReference genericMethodInstanceReference) { }
public virtual void onMetadataElement(IGenericMethodInstanceReference genericMethodInstanceReference) { }
public override void TraverseChildren(IGenericMethodInstanceReference genericMethodInstanceReference) { MethodEnter(genericMethodInstanceReference); base.TraverseChildren(genericMethodInstanceReference); MethodExit(); }
private MethodBase GetGenericMethodInstance(IGenericMethodInstanceReference genericMethodInstanceReference) { var genericMethodReference = genericMethodInstanceReference.GenericMethod; var genericMethod = (MethodInfo)this.GetMethod(genericMethodReference); var typeArguments = new Type[genericMethodReference.GenericParameterCount]; var i = 0; foreach (var arg in genericMethodInstanceReference.GenericArguments) typeArguments[i++] = this.GetType(arg); var genericMethodInstance = genericMethod.MakeGenericMethod(typeArguments); this.methodMap.Add(genericMethodInstanceReference.InternedKey, genericMethodInstance); return genericMethodInstance; }