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;
}
