internal override ITypeReference/*?*/ GetAsTypeReference(PEFileToObjectModel peFileToObjectModel, IMetadataReaderModuleReference module) {
foreach (var aref in peFileToObjectModel.GetAssemblyReferences()) {
var assemRef = aref as AssemblyReference;
if (assemRef == null) continue;
if (assemRef.AssemblyIdentity.Equals(this.AssemblyIdentity))
return this.TypeName.GetAsTypeReference(peFileToObjectModel, assemRef);
}
if (module.ContainingAssembly.AssemblyIdentity.Equals(this.AssemblyIdentity))
return this.TypeName.GetAsTypeReference(peFileToObjectModel, module);
AssemblyFlags flags = this.Retargetable ? AssemblyFlags.Retargetable : (AssemblyFlags)0;
return this.TypeName.GetAsTypeReference(peFileToObjectModel, new AssemblyReference(peFileToObjectModel, 0, this.AssemblyIdentity, flags));
}
internal override ITypeReference/*?*/ GetAsTypeReference(PEFileToObjectModel peFileToObjectModel, IMetadataReaderModuleReference module) {
ITypeReference/*?*/ elementType = this.ElementType.GetAsTypeReference(peFileToObjectModel, module);
if (elementType == null) return null;
if (this.Rank == 0)
return Vector.GetVector(elementType, peFileToObjectModel.InternFactory);
else
return Matrix.GetMatrix(elementType, this.Rank, peFileToObjectModel.InternFactory);
}
internal override ITypeReference GetAsTypeReference(
PEFileToObjectModel peFileToObjectModel,
IMetadataReaderModuleReference module
) {
ITypeReference/*?*/ targetType = this.TargetType.GetAsTypeReference(peFileToObjectModel, module);
if (targetType == null) return null;
return ManagedPointerType.GetManagedPointerType(targetType, peFileToObjectModel.InternFactory);
}
internal override INamedTypeDefinition/*?*/ ResolveNominalTypeName(IMetadataReaderModuleReference module) {
var containingType = this.ContainingTypeName.ResolveNominalTypeName(module);
if (containingType == null) return null;
return TypeHelper.GetNestedType(containingType, this.UnmangledTypeName, (int)this.GenericParameterCount);
}
internal override ITypeReference/*?*/ GetAsTypeReference(PEFileToObjectModel peFileToObjectModel, IMetadataReaderModuleReference module) {
var nominalType = this.GenericTemplate.GetAsNomimalType(peFileToObjectModel, module);
if (nominalType == null) return null;
int argumentUsed;
return this.GetSpecializedTypeReference(peFileToObjectModel, nominalType, out argumentUsed, mostNested: true);
}
internal override INamedTypeDefinition/*?*/ ResolveNominalTypeName(IMetadataReaderModuleReference module) {
var readerModule = module.ResolvedModule as Module;
if (readerModule != null) {
var peFileToObjectModel = readerModule.PEFileToObjectModel;
if (this.NamespaceName == null)
return peFileToObjectModel.ResolveNamespaceTypeDefinition(
peFileToObjectModel.NameTable.EmptyName,
this.Name
);
else
return peFileToObjectModel.ResolveNamespaceTypeDefinition(
this.NamespaceName.FullyQualifiedName,
this.Name
);
}
IUnitNamespace containingNamespace;
if (this.NamespaceName == null)
containingNamespace = module.ResolvedModule.UnitNamespaceRoot;
else
containingNamespace = this.NamespaceName.Resolve(module.ResolvedModule);
if (containingNamespace == null) return null;
foreach (var member in containingNamespace.GetMembersNamed(this.UnmangledTypeName, false)) {
var t = member as INamedTypeDefinition;
if (t != null && t.GenericParameterCount == this.GenericParameterCount) return t;
}
var assembly = module as IAssembly;
if (assembly == null) return null;
foreach (var alias in assembly.ExportedTypes) {
var nsAlias = alias as INamespaceAliasForType;
if (nsAlias == null || nsAlias.Name != this.UnmangledTypeName) continue;
var aliasedType = nsAlias.AliasedType.ResolvedType;
if (aliasedType.GenericParameterCount == this.GenericParameterCount) return aliasedType;
}
return null;
}
internal override IMetadataReaderNamedTypeReference/*?*/ GetAsNomimalType(
PEFileToObjectModel peFileToObjectModel,
IMetadataReaderModuleReference module
) {
return new NestedTypeNameTypeReference(module, this, peFileToObjectModel);
}
internal abstract INamedTypeDefinition/*?*/ ResolveNominalTypeName(IMetadataReaderModuleReference module);
internal override IMetadataReaderNamedTypeReference/*?*/ GetAsNomimalType(
PEFileToObjectModel peFileToObjectModel,
IMetadataReaderModuleReference module
) {
var typeRef = new NamespaceTypeNameTypeReference(module, this, peFileToObjectModel);
var redirectedTypeRef = peFileToObjectModel.ModuleReader.metadataReaderHost.Redirect(peFileToObjectModel.Module, typeRef) as INamespaceTypeReference;
if (redirectedTypeRef != typeRef && redirectedTypeRef != null) {
var namespaceName = this.GetNamespaceName(peFileToObjectModel.NameTable, redirectedTypeRef.ContainingUnitNamespace as INestedUnitNamespaceReference);
var mangledName = redirectedTypeRef.Name;
if (redirectedTypeRef.GenericParameterCount > 0)
mangledName = peFileToObjectModel.NameTable.GetNameFor(redirectedTypeRef.Name.Value+"`"+redirectedTypeRef.GenericParameterCount);
var redirectedNamespaceTypeName = new NamespaceTypeName(peFileToObjectModel.NameTable, namespaceName, mangledName, redirectedTypeRef.Name);
return new NamespaceTypeNameTypeReference(module, redirectedNamespaceTypeName, peFileToObjectModel);
}
return typeRef;
}
internal IMetadataReaderNamedTypeReference GetAsNamedTypeReference(
PEFileToObjectModel peFileToObjectModel, IMetadataReaderModuleReference module
) {
return this.GetAsNomimalType(peFileToObjectModel, module);
}
internal abstract IMetadataReaderNamedTypeReference/*?*/ GetAsNomimalType( PEFileToObjectModel peFileToObjectModel, IMetadataReaderModuleReference module );
internal abstract ITypeReference/*?*/ GetAsTypeReference( PEFileToObjectModel peFileToObjectModel, IMetadataReaderModuleReference module );
//^ invariant this.PEFileReader.TypeSpecTable.NumberOfRows >= 1 ==> this.ModuleTypeSpecHashtable != null;
TypeRefReference CreateTypeRefReference(
uint typeRefRowId,
TypeRefRow typeRefRow,
IMetadataReaderNamedTypeReference/*?*/ parentModuleTypeReference,
IMetadataReaderModuleReference moduleReference,
MetadataReaderSignatureTypeCode signatureTypeCode
) {
IName mangledTypeName = this.GetNameFromOffset(typeRefRow.Name);
ushort genericParamCount;
string typeName;
TypeCache.SplitMangledTypeName(mangledTypeName.Value, out typeName, out genericParamCount);
TypeRefReference moduleTypeRefReference;
if (parentModuleTypeReference == null) {
IName namespaceFullName = this.GetNameFromOffset(typeRefRow.Namespace);
NamespaceReference namespaceReference = this.GetNamespaceReferenceForString(moduleReference, namespaceFullName);
if (genericParamCount == 0) {
if (signatureTypeCode == MetadataReaderSignatureTypeCode.NotModulePrimitive) {
moduleTypeRefReference = new NamespaceTypeRefReferenceWithoutPrimitiveTypeCode(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
signatureTypeCode == MetadataReaderSignatureTypeCode.ValueType
);
} else {
moduleTypeRefReference = new NamespaceTypeRefReferenceWithPrimitiveTypeCode(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
signatureTypeCode
);
}
} else {
IName iTypeName = this.NameTable.GetNameFor(typeName);
moduleTypeRefReference = new GenericNamespaceTypeRefReference(
this,
iTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
mangledTypeName,
genericParamCount,
signatureTypeCode == MetadataReaderSignatureTypeCode.ValueType
);
}
} else {
if (genericParamCount == 0) {
moduleTypeRefReference = new NonGenericNestedTypeRefReference(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
parentModuleTypeReference,
signatureTypeCode == MetadataReaderSignatureTypeCode.ValueType
);
} else {
IName iTypeName = this.NameTable.GetNameFor(typeName);
moduleTypeRefReference = new GenericNestedTypeRefReference(
this,
iTypeName,
typeRefRowId,
moduleReference,
parentModuleTypeReference,
mangledTypeName,
genericParamCount,
signatureTypeCode == MetadataReaderSignatureTypeCode.ValueType
);
}
}
return moduleTypeRefReference;
}
internal NamespaceReference GetNamespaceReferenceForString(
IMetadataReaderModuleReference moduleReference,
IName iNamespaceFullName
) {
NamespaceReference/*?*/ retNamespaceReference = this.NamespaceReferenceINameHashtable.Find(moduleReference.InternedModuleId, (uint)iNamespaceFullName.UniqueKey);
if (retNamespaceReference != null)
return retNamespaceReference;
string namespaceFullName = iNamespaceFullName.Value;
if (namespaceFullName.Length == 0) {
retNamespaceReference = new RootNamespaceReference(this, moduleReference);
} else {
int lastDot = namespaceFullName.LastIndexOf('.');
string namespaceName = namespaceFullName;
string namespacePrefix = "";
if (lastDot != -1) {
namespacePrefix = namespaceFullName.Substring(0, lastDot);
namespaceName = namespaceFullName.Substring(lastDot + 1, namespaceFullName.Length - lastDot - 1);
}
IName iNamespacePrefix = this.NameTable.GetNameFor(namespacePrefix);
NamespaceReference parentNamespaceReference = this.GetNamespaceReferenceForString(moduleReference, iNamespacePrefix);
IName iNamespaceName = this.NameTable.GetNameFor(namespaceName);
retNamespaceReference = new NestedNamespaceReference(this, iNamespaceName, iNamespaceFullName, parentNamespaceReference);
}
this.NamespaceReferenceINameHashtable.Add(moduleReference.InternedModuleId, (uint)iNamespaceFullName.UniqueKey, retNamespaceReference);
return retNamespaceReference;
}
