/// <summary>
/// See if a type reference refers to a type definition that is compiler generated.
/// </summary>
/// <param name="typeReference"></param>
/// <returns></returns>
internal static bool IsCompilerGenerated(ITypeReference /*!*/ typeReference)
{
if (AttributeHelper.Contains(typeReference.ResolvedType.Attributes, typeReference.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))
{
return(true);
}
IGenericTypeInstanceReference genericTypeInstanceReference = typeReference as IGenericTypeInstanceReference;
if (genericTypeInstanceReference != null && IsCompilerGenerated(genericTypeInstanceReference.GenericType))
{
return(true);
}
ISpecializedNestedTypeReference specializedNestedType = typeReference as ISpecializedNestedTypeReference;
if (specializedNestedType != null && IsCompilerGenerated(specializedNestedType.UnspecializedVersion))
{
return(true);
}
ISpecializedNestedTypeDefinition specializedNestedTypeDefinition = typeReference as ISpecializedNestedTypeDefinition;
if (specializedNestedTypeDefinition != null && IsCompilerGenerated(specializedNestedTypeDefinition.UnspecializedVersion))
{
return(true);
}
INestedTypeReference nestedTypeReference = UnspecializedMethods.AsUnspecializedNestedTypeReference(typeReference);
if (nestedTypeReference != null)
{
return(IsCompilerGenerated(nestedTypeReference.ContainingType));
}
return(false);
}
public override void Visit(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
if (Process(specializedNestedTypeDefinition))
{
visitor.Visit(specializedNestedTypeDefinition);
}
base.Visit(specializedNestedTypeDefinition);
}
public static INamedTypeReference CanonicalizeTypeReference(ITypeReference type)
{
while (type != null)
{
IModifiedTypeReference modifiedType = type as IModifiedTypeReference;
IPointerTypeReference ptrType = type as IPointerTypeReference;
IManagedPointerType refType = type as IManagedPointerType;
IArrayTypeReference arrType = type as IArrayTypeReference;
IGenericTypeInstanceReference genType = type as IGenericTypeInstanceReference;
ISpecializedNestedTypeReference nestedType = type as ISpecializedNestedTypeReference;
// TODO: Why doesn't ISpecializedNestedTypeDefinition derive from ISpecializedNestedTypeReference?
ISpecializedNestedTypeDefinition nestedTypeDef = type as ISpecializedNestedTypeDefinition;
if (modifiedType != null)
{
type = modifiedType.UnmodifiedType;
}
else if (ptrType != null)
{
type = ptrType.TargetType;
}
else if (refType != null)
{
type = refType.TargetType;
}
else if (arrType != null)
{
type = arrType.ElementType;
}
else if (genType != null)
{
type = genType.GenericType;
}
else if (nestedType != null)
{
type = nestedType.UnspecializedVersion;
}
else if (nestedTypeDef != null)
{
type = nestedTypeDef.UnspecializedVersion;
}
else /* ITypeDefinition */
{
break;
}
}
return(type as INamedTypeReference);
}
public virtual void onMetadataElement(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition) { }
/// <summary>
/// Performs some computation with the given specialized nested type definition.
/// </summary>
public void Visit(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
this.Visit((INestedTypeDefinition)specializedNestedTypeDefinition);
}
public void Visit(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
//references are dispatched in such a way that they never get here.
//thus, assume that we are traversing a generic type instance.
this.traverser.Traverse((INestedTypeDefinition)specializedNestedTypeDefinition);
}
/// <summary>
/// Performs some computation with the given specialized nested type definition.
/// </summary>
public virtual void Visit(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
}
public void Visit(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
throw new NotImplementedException();
}
public virtual void onMetadataElement(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
}
/// <summary>
/// Performs some computation with the given specialized nested type definition.
/// </summary>
public virtual void Visit(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
}
public override void Visit(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
allElements.Add(new InvokInfo(Traverser, "ISpecializedNestedTypeDefinition", specializedNestedTypeDefinition));
}
public override void Visit(ISpecializedNestedTypeDefinition specializedNestedTypeDefinition)
{
if(Process(specializedNestedTypeDefinition)){visitor.Visit(specializedNestedTypeDefinition);}
base.Visit(specializedNestedTypeDefinition);
}
