/// <summary>
/// Returns a reference to the unit that defines the given referenced type. If the referenced type is a structural type, such as a pointer or a generic type instance,
/// then the result is null.
/// </summary>
public static IUnitReference /*?*/ GetDefiningUnitReference(ITypeReference typeReference, EmitContext context)
{
INestedTypeReference /*?*/ nestedTypeReference = typeReference.AsNestedTypeReference;
while (nestedTypeReference != null)
{
if (nestedTypeReference.AsGenericTypeInstanceReference != null)
{
return(null);
}
typeReference = nestedTypeReference.GetContainingType(context);
nestedTypeReference = typeReference.AsNestedTypeReference;
}
INamespaceTypeReference /*?*/ namespaceTypeReference = typeReference.AsNamespaceTypeReference;
if (namespaceTypeReference == null)
{
return(null);
}
Debug.Assert(namespaceTypeReference.AsGenericTypeInstanceReference == null);
return(namespaceTypeReference.GetUnit(context));
}
private static void AppendAssemblyQualifierIfNecessary(StringBuilder sb, ITypeReference typeReference, out bool isAssemQualified, EmitContext context)
{
INestedTypeReference nestedType = typeReference.AsNestedTypeReference;
if (nestedType != null)
{
AppendAssemblyQualifierIfNecessary(sb, nestedType.GetContainingType(context), out isAssemQualified, context);
return;
}
IGenericTypeInstanceReference genInst = typeReference.AsGenericTypeInstanceReference;
if (genInst != null)
{
AppendAssemblyQualifierIfNecessary(sb, genInst.GetGenericType(context), out isAssemQualified, context);
return;
}
IArrayTypeReference arrType = typeReference as IArrayTypeReference;
if (arrType != null)
{
AppendAssemblyQualifierIfNecessary(sb, arrType.GetElementType(context), out isAssemQualified, context);
return;
}
IPointerTypeReference pointer = typeReference as IPointerTypeReference;
if (pointer != null)
{
AppendAssemblyQualifierIfNecessary(sb, pointer.GetTargetType(context), out isAssemQualified, context);
return;
}
isAssemQualified = false;
IAssemblyReference referencedAssembly = null;
INamespaceTypeReference namespaceType = typeReference.AsNamespaceTypeReference;
if (namespaceType != null)
{
referencedAssembly = namespaceType.GetUnit(context) as IAssemblyReference;
}
if (referencedAssembly != null)
{
var containingAssembly = context.Module.GetContainingAssembly(context);
if (containingAssembly == null || !ReferenceEquals(referencedAssembly, containingAssembly))
{
sb.Append(", ");
sb.Append(MetadataWriter.StrongName(referencedAssembly));
isAssemQualified = true;
}
}
}
public override void Visit(INamespaceTypeReference namespaceTypeReference)
{
if (!this.typeReferenceNeedsToken && namespaceTypeReference.TypeCode(Context) != PrimitiveTypeCode.NotPrimitive)
{
return;
}
RecordTypeReference(namespaceTypeReference);
var unit = namespaceTypeReference.GetUnit(Context);
var assemblyReference = unit as IAssemblyReference;
if (assemblyReference != null)
{
this.Visit(assemblyReference);
}
else
{
var moduleReference = unit as IModuleReference;
if (moduleReference != null)
{
// If this is a module from a referenced multi-module assembly,
// the assembly should be used as the resolution scope.
assemblyReference = moduleReference.GetContainingAssembly(Context);
if (assemblyReference != null && assemblyReference != this.module.AsAssembly)
{
this.Visit(assemblyReference);
}
else
{
this.Visit(moduleReference);
}
}
}
}
public override void Visit(INamespaceTypeReference namespaceTypeReference)
{
if (!this.typeReferenceNeedsToken && namespaceTypeReference.TypeCode(Context) != PrimitiveTypeCode.NotPrimitive)
{
return;
}
RecordTypeReference(namespaceTypeReference);
var unit = namespaceTypeReference.GetUnit(Context);
var assemblyReference = unit as IAssemblyReference;
if (assemblyReference != null)
{
this.Visit(assemblyReference);
}
else
{
var moduleReference = unit as IModuleReference;
if (moduleReference != null)
{
// If this is a module from a referenced multi-module assembly,
// the assembly should be used as the resolution scope.
assemblyReference = moduleReference.GetContainingAssembly(Context);
if (assemblyReference != null && assemblyReference != this.module.AsAssembly)
{
this.Visit(assemblyReference);
}
else
{
this.Visit(moduleReference);
}
}
}
}
