private NamedTypeSymbol RetargetNamedTypeDefinitionFromUnderlyingAssembly(NamedTypeSymbol type) { // The type is defined in the underlying assembly. var module = type.ContainingModule; if (ReferenceEquals(module, this.UnderlyingModule)) { Debug.Assert(module.Ordinal == 0); Debug.Assert(!type.IsExplicitDefinitionOfNoPiaLocalType); var container = type.ContainingType; while ((object)container != null) { if (container.IsExplicitDefinitionOfNoPiaLocalType) { // Types nested into local types are not supported. return((NamedTypeSymbol)this.SymbolMap.GetOrAdd(type, new UnsupportedMetadataTypeSymbol())); } container = container.ContainingType; } return((NamedTypeSymbol)this.SymbolMap.GetOrAdd(type, _retargetingModule._createRetargetingNamedType)); } else { // The type is defined in one of the added modules Debug.Assert(module.Ordinal > 0); CSharpModuleSymbol addedModule = (CSharpModuleSymbol)this.RetargetingAssembly.Modules[module.Ordinal]; Debug.Assert(ReferenceEquals(((CSharpModuleSymbol)module).Module, addedModule.Module)); return(RetargetNamedTypeDefinition((CSharpNamedTypeSymbol)type, addedModule)); } }
/// <summary> /// Constructor. /// </summary> /// <param name="underlyingAssembly"> /// The underlying AssemblySymbol, cannot be an instance of RetargetingAssemblySymbol. /// </param> /// <param name="isLinked"> /// Assembly is /l-ed by compilation that is using it as a reference. /// </param> internal RetargetingAssemblySymbol(SourceAssemblySymbol underlyingAssembly, bool isLinked) { Debug.Assert((object)underlyingAssembly != null); _underlyingAssembly = underlyingAssembly; ModuleSymbol[] modules = new ModuleSymbol[underlyingAssembly.Modules.Length]; modules[0] = new RetargetingModuleSymbol(this, (SourceModuleSymbol)underlyingAssembly.Modules[0]); for (int i = 1; i < underlyingAssembly.Modules.Length; i++) { CSharpModuleSymbol under = (CSharpModuleSymbol)underlyingAssembly.Modules[i]; modules[i] = new CSharpModuleSymbol(this, under.UnderlyingModule, i); } _modules = modules.AsImmutableOrNull(); _isLinked = isLinked; }
private static NamedTypeSymbol RetargetNamedTypeDefinition(CSharpNamedTypeSymbol type, CSharpModuleSymbol addedModule) { Debug.Assert(!type.ContainingModule.Equals(addedModule) && ReferenceEquals(((CSharpModuleSymbol)type.ContainingModule).Module, addedModule.Module)); TypeSymbol cached; if (addedModule.CSharpSymbolMap.TryGetSymbol(type.CSharpSymbol, out cached)) { return((NamedTypeSymbol)cached); } NamedTypeSymbol result; NamedTypeSymbol containingType = type.ContainingType; MetadataTypeName mdName; if ((object)containingType != null) { // Nested type. We need to retarget // the enclosing type and then go back and get the type we are interested in. NamedTypeSymbol scope = RetargetNamedTypeDefinition((CSharpNamedTypeSymbol)containingType, addedModule); mdName = MetadataTypeName.FromTypeName(type.MetadataName, forcedArity: type.Arity); result = scope.LookupMetadataType(ref mdName); Debug.Assert((object)result != null && result.Arity == type.Arity); } else { string namespaceName = type.ContainingNamespace.ToDisplayString(SymbolDisplayFormat.QualifiedNameOnlyFormat); mdName = MetadataTypeName.FromNamespaceAndTypeName(namespaceName, type.MetadataName, forcedArity: type.Arity); result = addedModule.LookupTopLevelMetadataType(ref mdName); Debug.Assert(result.Arity == type.Arity); } return(result); }