internal ModuleReference(PEModuleBuilder moduleBeingBuilt, ModuleSymbol underlyingModule)
        {
            Debug.Assert(moduleBeingBuilt != null);
            Debug.Assert((object)underlyingModule != null);

            this.moduleBeingBuilt = moduleBeingBuilt;
            this.underlyingModule = underlyingModule;
        }

        internal SynthesizedGlobalMethodSymbol(ModuleSymbol containingModule, PrivateImplementationDetails privateImplType, TypeSymbol returnType, string name)
        {
            Debug.Assert((object)containingModule != null);
            Debug.Assert(privateImplType != null);
            Debug.Assert((object)returnType != null);
            Debug.Assert(name != null);

            _containingModule = containingModule;
            _privateImplType = privateImplType;
            _returnType = returnType;
            _name = name;
        }

 internal NamespaceSymbol Get_System_NamespaceSymbol(ModuleSymbol m)
 {
     var assembly = m.ContainingSymbol;
     SourceAssemblySymbol sourceAssembly = assembly as SourceAssemblySymbol;
     if (sourceAssembly != null)
     {
         return sourceAssembly.DeclaringCompilation.GlobalNamespace.GetMember<NamespaceSymbol>("System");
     }
     else
     {
         var peAssembly = (PEAssemblySymbol)assembly;
         return peAssembly.CorLibrary.GlobalNamespace.GetMember<NamespaceSymbol>("System");
     }
 }

        internal PEAssemblySymbol(PEAssembly assembly, DocumentationProvider documentationProvider, bool isLinked, MetadataImportOptions importOptions)
        {
            Debug.Assert(assembly != null);
            Debug.Assert(documentationProvider != null);
            _assembly = assembly;
            _documentationProvider = documentationProvider;

            var modules = new ModuleSymbol[assembly.Modules.Length];

            for (int i = 0; i < assembly.Modules.Length; i++)
            {
                modules[i] = new PEModuleSymbol(this, assembly.Modules[i], importOptions, i);
            }

            _modules = modules.AsImmutableOrNull();
            _isLinked = isLinked;
        }

 protected override IModuleReference TranslateModule(ModuleSymbol symbol, DiagnosticBag diagnostics)
 {
     var moduleSymbol = symbol as PEModuleSymbol;
     if ((object)moduleSymbol != null)
     {
         var module = moduleSymbol.Module;
         // Expose the individual runtime Windows.*.winmd modules as assemblies.
         // (The modules were wrapped in a placeholder Windows.winmd assembly
         // in MetadataUtilities.MakeAssemblyReferences.)
         if (MetadataUtilities.IsWindowsComponent(module.MetadataReader, module.Name) &&
             MetadataUtilities.IsWindowsAssemblyName(moduleSymbol.ContainingAssembly.Name))
         {
             var identity = module.ReadAssemblyIdentityOrThrow();
             return new Microsoft.CodeAnalysis.ExpressionEvaluator.AssemblyReference(identity);
         }
     }
     return base.TranslateModule(symbol, diagnostics);
 }

        /// <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>
        public 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++)
            {
                PEModuleSymbol under = (PEModuleSymbol)underlyingAssembly.Modules[i];
                modules[i] = new PEModuleSymbol(this, under.Module, under.ImportOptions, i);
            }

            _modules = modules.AsImmutableOrNull();
            _isLinked = isLinked;
        }

        private void CheckAnonymousTypes(ModuleSymbol module)
        {
            var ns = module.GlobalNamespace;
            Assert.NotNull(ns);

            CheckAnonymousType(ns.GetMember<NamedTypeSymbol>("<>f__AnonymousType0"), "<>f__AnonymousType0", "<>f__AnonymousType0`2");
            CheckAnonymousType(ns.GetMember<NamedTypeSymbol>("<>f__AnonymousType1"), "<>f__AnonymousType1", "<>f__AnonymousType1");
        }

 private TopLevel(ModuleSymbol module, ref MetadataTypeName fullName, int typeId)
     : this(module, ref fullName, fullName.ForcedArity == -1 || fullName.ForcedArity == fullName.InferredArity)
 {
     Debug.Assert(typeId == -1 || typeId == (int)SpecialType.None || Arity == 0 || MangleName);
     _lazyTypeId = typeId;
 }

        private void TestAttributeOnPartialMethodHelper(ModuleSymbol m, MethodSymbol fooMethod)
        {
            var a1Class = m.GlobalNamespace.GetTypeMember("A1");
            var a2Class = m.GlobalNamespace.GetTypeMember("A2");
            var b1Class = m.GlobalNamespace.GetTypeMember("B1");
            var b2Class = m.GlobalNamespace.GetTypeMember("B2");
            var c1Class = m.GlobalNamespace.GetTypeMember("C1");
            var c2Class = m.GlobalNamespace.GetTypeMember("C2");
            var d1Class = m.GlobalNamespace.GetTypeMember("D1");
            var d2Class = m.GlobalNamespace.GetTypeMember("D2");
            var e1Class = m.GlobalNamespace.GetTypeMember("E1");
            var e2Class = m.GlobalNamespace.GetTypeMember("E2");

            Assert.Equal(1, fooMethod.GetAttributes(a1Class).Count());
            Assert.Equal(1, fooMethod.GetAttributes(a2Class).Count());

            Assert.Equal(1, fooMethod.GetReturnTypeAttributes().Where(a => a.AttributeClass == b1Class).Count());
            Assert.Equal(1, fooMethod.GetReturnTypeAttributes().Where(a => a.AttributeClass == b2Class).Count());

            var typeParam1 = fooMethod.TypeParameters[0];
            Assert.Equal(1, typeParam1.GetAttributes(c1Class).Count());
            Assert.Equal(1, typeParam1.GetAttributes(c2Class).Count());

            var typeParam2 = fooMethod.TypeParameters[1];
            Assert.Equal(1, typeParam2.GetAttributes(d1Class).Count());
            Assert.Equal(1, typeParam2.GetAttributes(d2Class).Count());

            var param = fooMethod.Parameters[0];
            Assert.Equal(1, param.GetAttributes(e1Class).Count());
            Assert.Equal(1, param.GetAttributes(e2Class).Count());
        }

 public virtual void VisitModule(ModuleSymbol symbol)
 {
     DefaultVisit(symbol);
 }

        // NOTE: assumes there's a destructor.
        private static void ValidateDestructor(ModuleSymbol module, string typeName)
        {
            var @class = module.GlobalNamespace.GetMember<NamedTypeSymbol>(typeName);
            var destructor = @class.GetMember<MethodSymbol>(WellKnownMemberNames.DestructorName);

            Assert.Equal(MethodKind.Destructor, destructor.MethodKind);

            Assert.True(destructor.IsMetadataVirtual());
            Assert.False(destructor.IsVirtual);
            Assert.False(destructor.IsOverride);
            Assert.False(destructor.IsSealed);
            Assert.False(destructor.IsStatic);
            Assert.False(destructor.IsAbstract);
            Assert.Null(destructor.OverriddenMethod);

            Assert.Equal(SpecialType.System_Void, destructor.ReturnType.SpecialType);
            Assert.Equal(0, destructor.Parameters.Length);
            Assert.Equal(0, destructor.TypeParameters.Length);

            Assert.Equal(Accessibility.Protected, destructor.DeclaredAccessibility);
        }

        private void TypeAndNamespaceDifferByCase(ModuleSymbol module0)
        {
            var someName = module0.GlobalNamespace.GetMembers("SomenamE");
            Assert.Equal(someName.Length, 0);

            someName = module0.GlobalNamespace.GetMembers("somEnamE");
            Assert.Equal(someName.Length, 1);
            Assert.NotNull((someName[0] as NamedTypeSymbol));

            someName = module0.GlobalNamespace.GetMembers("SomeName");
            Assert.Equal(someName.Length, 1);
            Assert.NotNull((someName[0] as NamespaceSymbol));

            var someName1_1 = module0.GlobalNamespace.GetTypeMembers("somEnamE1").OrderBy((t) => t.Name).ToArray();
            var someName1_2 = module0.GlobalNamespace.GetTypeMembers("SomeName1").OrderBy((t) => t.Name).ToArray();

            Assert.Equal(1, someName1_1.Length);
            Assert.Equal("somEnamE1", someName1_1[0].Name);
            Assert.Equal(1, someName1_2.Length);
            Assert.Equal("SomeName1", someName1_2[0].Name);
            Assert.NotEqual(someName1_1[0], someName1_2[0]);

            var someName2_1 = module0.GlobalNamespace.GetMembers("somEnamE2").OfType<NamespaceSymbol>().OrderBy((t) => t.Name).ToArray();
            var someName2_2 = module0.GlobalNamespace.GetMembers("SomeName2").OfType<NamespaceSymbol>().OrderBy((t) => t.Name).ToArray();
            Assert.Equal(1, someName2_1.Length);
            Assert.Equal("somEnamE2", someName2_1[0].Name);
            Assert.Equal(1, someName2_2.Length);
            Assert.Equal("SomeName2", someName2_2[0].Name);
            Assert.NotEqual(someName2_1[0], someName2_2[0]);

            var otherName_1 = someName2_1[0].GetTypeMembers("OtherName");
            var otherName_2 = someName2_2[0].GetTypeMembers("OtherName");

            Assert.Equal(1, otherName_1.Length);
            Assert.Equal(1, otherName_2.Length);
            Assert.NotEqual(otherName_1[0], otherName_2[0]);

            var nestingClass = module0.GlobalNamespace.GetTypeMembers("NestingClass").Single();
            var someName3_1 = nestingClass.GetTypeMembers("SomeName3").OrderBy((t) => t.Name).ToArray();
            var someName3_2 = nestingClass.GetTypeMembers("somEnamE3").OrderBy((t) => t.Name).ToArray();

            Assert.Equal(1, someName3_1.Length);
            Assert.Equal(1, someName3_2.Length);
            Assert.Equal("somEnamE3", someName3_2[0].Name);
            Assert.Equal("SomeName3", someName3_1[0].Name);
        }

 public TopLevelWithCustomErrorInfo(ModuleSymbol module, ref MetadataTypeName emittedName, DiagnosticInfo errorInfo, WellKnownType typeId)
     : base(module, ref emittedName, typeId)
 {
     Debug.Assert(errorInfo != null);
     _errorInfo = errorInfo;
 }

 internal static XElement DumpTypeInfo(ModuleSymbol moduleSymbol)
 {
     return LoadChildNamespace(moduleSymbol.GlobalNamespace);
 }

 internal NamespaceSymbol Get_System_Security_NamespaceSymbol(ModuleSymbol m)
 {
     NamespaceSymbol sysNS = Get_System_NamespaceSymbol(m);
     return sysNS.GetMember<NamespaceSymbol>("Security");
 }

 internal NamespaceSymbol Get_System_Diagnostics_NamespaceSymbol(ModuleSymbol m)
 {
     NamespaceSymbol sysNS = Get_System_NamespaceSymbol(m);
     return sysNS.GetMember<NamespaceSymbol>("Diagnostics");
 }

 internal NamespaceSymbol Get_System_Runtime_CompilerServices_NamespaceSymbol(ModuleSymbol m)
 {
     NamespaceSymbol sysNS = Get_System_NamespaceSymbol(m);
     return Get_System_Runtime_CompilerServices_NamespaceSymbol(sysNS);
 }

 internal NamespaceSymbol Get_System_Runtime_InteropServices_WindowsRuntime_NamespaceSymbol(ModuleSymbol m)
 {
     NamespaceSymbol interopNS = Get_System_Runtime_InteropServices_NamespaceSymbol(m);
     return interopNS.GetMember<NamespaceSymbol>("WindowsRuntime");
 }

        // NOTE: assumes there's an event E in a type C.
        private static void ValidateEvent(ModuleSymbol module, bool isFromSource, bool isStatic, bool isFieldLike)
        {
            var @class = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
            var @event = @class.GetMember<EventSymbol>("E");

            Assert.Equal(SymbolKind.Event, @event.Kind);
            Assert.Equal(Accessibility.Public, @event.DeclaredAccessibility);
            Assert.Equal(isStatic, @event.IsStatic);
            Assert.False(@event.MustCallMethodsDirectly);

            var addMethod = @event.AddMethod;
            Assert.Equal(MethodKind.EventAdd, addMethod.MethodKind);
            Assert.Equal("void C.E.add", addMethod.ToTestDisplayString());
            addMethod.CheckAccessorShape(@event);

            var removeMethod = @event.RemoveMethod;
            Assert.Equal(MethodKind.EventRemove, removeMethod.MethodKind);
            Assert.Equal("void C.E.remove", removeMethod.ToTestDisplayString());
            removeMethod.CheckAccessorShape(@event);

            // Whether or not the event was field-like in source, it will look custom when loaded from metadata.
            if (isFieldLike && isFromSource)
            {
                Assert.True(@event.HasAssociatedField);
                var associatedField = @event.AssociatedField;
                Assert.Equal(SymbolKind.Field, associatedField.Kind);
                Assert.Equal(Accessibility.Private, associatedField.DeclaredAccessibility);
                Assert.Equal(isStatic, associatedField.IsStatic);
                Assert.Equal(@event.Type, associatedField.Type);
            }
            else
            {
                Assert.False(@event.HasAssociatedField);
                Assert.Null(@event.AssociatedField);
            }
        }

 public NoPiaIllegalGenericInstantiationSymbol(ModuleSymbol exposingModule, NamedTypeSymbol underlyingSymbol)
 {
     _exposingModule = exposingModule;
     _underlyingSymbol = underlyingSymbol;
 }