Fix HasFileLocalTypes check for constructed types

src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs

@@ -1336,7 +1336,7 @@ internal static ImmutableArray<Symbol> GetCandidateMembers(NamespaceOrTypeSymbol
 
         private bool IsInScopeOfAssociatedSyntaxTree(Symbol symbol)
         {
-            while (symbol is not null and not NamedTypeSymbol { AssociatedFileIdentifier: not null })
+            while (symbol is not null and not NamedTypeSymbol { IsFileLocal: true })
             {
                 symbol = symbol.ContainingType;
             }

src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs

@@ -2480,7 +2480,7 @@ private BestSymbolInfo GetBestSymbolInfo(ArrayBuilder<Symbol> symbols, out BestS
 
         private static BestSymbolLocation GetLocation(CSharpCompilation compilation, Symbol symbol)
         {
-            if (symbol is SourceMemberContainerTypeSymbol { IsFileLocal: true })
+            if (symbol is NamedTypeSymbol { IsFileLocal: true })
             {
                 return BestSymbolLocation.FromFile;
             }

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

@@ -3392,7 +3392,7 @@ public override void VisitNamespace(NamespaceSymbol symbol)
             public override void VisitNamedType(NamedTypeSymbol symbol)
             {
                 Debug.Assert(symbol.ContainingSymbol.Kind == SymbolKind.Namespace); // avoid unnecessary traversal of nested types
-                if (symbol.AssociatedFileIdentifier is not null)
+                if (symbol.IsFileLocal)
                 {
                     var location = symbol.GetFirstLocation();
                     var filePath = location.SourceTree?.FilePath;

src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/PublicSymbols/AnonymousManager.TypeOrDelegatePublicSymbol.cs

@@ -73,6 +73,7 @@ internal sealed override bool MangleName
                 get { return false; }
             }
 
+            internal sealed override bool IsFileLocal => false;
             internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
             public sealed override int Arity

src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeOrDelegateTemplateSymbol.cs

@@ -237,6 +237,7 @@ internal sealed override bool MangleName
                 get { return this.Arity > 0; }
             }
 
+            internal sealed override bool IsFileLocal => false;
             internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
             internal sealed override ImmutableArray<TypeWithAnnotations> TypeArgumentsWithAnnotationsNoUseSiteDiagnostics

src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs

@@ -578,7 +578,8 @@ internal override bool MangleName
             get { return _originalDefinition.MangleName; }
         }
 
-        internal override FileIdentifier? AssociatedFileIdentifier => _originalDefinition.AssociatedFileIdentifier;
+        internal sealed override bool IsFileLocal => _originalDefinition.IsFileLocal;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier => _originalDefinition.AssociatedFileIdentifier;
 
         internal override DiagnosticInfo? ErrorInfo
         {

src/Compilers/CSharp/Portable/Symbols/ExtendedErrorTypeSymbol.cs

@@ -145,6 +145,7 @@ internal override bool MangleName
             }
         }
 
+        internal override bool IsFileLocal => false;
         internal override FileIdentifier? AssociatedFileIdentifier => null;
 
         public override Symbol? ContainingSymbol

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs

@@ -394,7 +394,8 @@ internal override ModuleSymbol ContainingModule
             get;
         }
 
-        internal override FileIdentifier? AssociatedFileIdentifier
+        internal sealed override bool IsFileLocal => _lazyUncommonProperties is { lazyFilePathChecksum: { IsDefault: false }, lazyDisplayFileName: { } };
+        internal sealed override FileIdentifier? AssociatedFileIdentifier
         {
             get
             {

src/Compilers/CSharp/Portable/Symbols/MissingMetadataTypeSymbol.cs

@@ -48,7 +48,8 @@ internal override bool MangleName
             }
         }
 
-        internal override FileIdentifier? AssociatedFileIdentifier => null;
+        internal sealed override bool IsFileLocal => false;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
         /// <summary>
         /// Get the arity of the missing type.

src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs

@@ -495,6 +495,8 @@ public override string MetadataName
             }
         }
 
+        internal abstract bool IsFileLocal { get; }
+
         /// <summary>
         /// If this type is a file-local type, returns an identifier for the file this type was declared in. Otherwise, returns null.
         /// </summary>

src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs

@@ -177,7 +177,8 @@ internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo()
         internal sealed override NamedTypeSymbol NativeIntegerUnderlyingType => _underlyingType;
 
         // note: there is no supported way to create a native integer type whose underlying type is file-local.
-        internal override FileIdentifier? AssociatedFileIdentifier => null;
+        internal sealed override bool IsFileLocal => false;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
         internal sealed override bool IsRecord => false;
         internal sealed override bool IsRecordStruct => false;

src/Compilers/CSharp/Portable/Symbols/NoPiaAmbiguousCanonicalTypeSymbol.cs

@@ -49,7 +49,8 @@ internal override bool MangleName
             }
         }
 
-        internal override FileIdentifier? AssociatedFileIdentifier => null;
+        internal sealed override bool IsFileLocal => false;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
         public AssemblySymbol EmbeddingAssembly
         {

src/Compilers/CSharp/Portable/Symbols/NoPiaIllegalGenericInstantiationSymbol.cs

@@ -41,7 +41,8 @@ internal override bool MangleName
             }
         }
 
-        internal override FileIdentifier? AssociatedFileIdentifier => null;
+        internal sealed override bool IsFileLocal => false;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
         public NamedTypeSymbol UnderlyingSymbol
         {

src/Compilers/CSharp/Portable/Symbols/NoPiaMissingCanonicalTypeSymbol.cs

@@ -73,7 +73,8 @@ internal override bool MangleName
             }
         }
 
-        internal override FileIdentifier? AssociatedFileIdentifier => null;
+        internal sealed override bool IsFileLocal => false;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
         public string? Guid
         {

src/Compilers/CSharp/Portable/Symbols/PlaceholderTypeArgumentSymbol.cs

@@ -48,6 +48,7 @@ internal override bool MangleName
             }
         }
 
+        internal override bool IsFileLocal => false;
         internal override FileIdentifier? AssociatedFileIdentifier => null;
 
         internal override DiagnosticInfo? ErrorInfo

src/Compilers/CSharp/Portable/Symbols/PublicModel/NamedTypeSymbol.cs

@@ -195,10 +195,10 @@ INamedTypeSymbol INamedTypeSymbol.TupleUnderlyingType
         bool INamedTypeSymbol.IsSerializable => UnderlyingNamedTypeSymbol.IsSerializable;
 
         bool INamedTypeSymbol.IsFileLocal =>
-            // Even though we round-trip the file identifier through metadata to support EE,
-            // we don't want public API to give the impression that the compiler considers a metadata type to be a file-local type.
+            // Internally we can treat a metadata type as being a file-local type for EE.
+            // For public API, only source types are considered file-local types.
             UnderlyingNamedTypeSymbol.OriginalDefinition is SourceMemberContainerTypeSymbol
-                && UnderlyingNamedTypeSymbol.AssociatedFileIdentifier is not null;
+                && UnderlyingNamedTypeSymbol.IsFileLocal;
 
         INamedTypeSymbol INamedTypeSymbol.NativeIntegerUnderlyingType => UnderlyingNamedTypeSymbol.NativeIntegerUnderlyingType.GetPublicSymbol();
 

src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs

@@ -389,6 +389,7 @@ public sealed override bool AreLocalsZeroed
             get { throw ExceptionUtilities.Unreachable(); }
         }
 
+        internal override bool IsFileLocal => _underlyingType.IsFileLocal;
         internal override FileIdentifier? AssociatedFileIdentifier => _underlyingType.AssociatedFileIdentifier;
 
         internal sealed override NamedTypeSymbol AsNativeInteger() => throw ExceptionUtilities.Unreachable();

src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs

@@ -841,7 +841,7 @@ internal override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySym
 
         internal bool IsNew => HasFlag(DeclarationModifiers.New);
 
-        internal bool IsFileLocal => HasFlag(DeclarationModifiers.File);
+        internal sealed override bool IsFileLocal => HasFlag(DeclarationModifiers.File);
 
         internal bool IsUnsafe => HasFlag(DeclarationModifiers.Unsafe);
 

src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs

@@ -300,7 +300,10 @@ private static void CheckMembers(NamespaceSymbol @namespace, Dictionary<string,
                 Array.Clear(memberOfArity, 0, memberOfArity.Length);
                 foreach (var symbol in result[name])
                 {
-                    var nts = symbol as NamedTypeSymbol;
+                    var nts = symbol as SourceMemberContainerTypeSymbol;
+                    // It should be impossible to have a type member of a source namespace symbol which is not a SourceMemberContainerTypeSymbol
+                    Debug.Assert((object)nts != null || symbol is not TypeSymbol);
+
                     var arity = ((object)nts != null) ? nts.Arity : 0;
                     if (arity >= memberOfArity.Length)
                     {
@@ -335,15 +338,19 @@ private static void CheckMembers(NamespaceSymbol @namespace, Dictionary<string,
 
                     if ((object)other != null)
                     {
+                        // To decide whether type declarations are duplicates, we need to access members only available on the source original definition symbols.
+                        Debug.Assert((object)nts.OriginalDefinition == nts && (object)other.OriginalDefinition == other);
+                        Debug.Assert(other is not TypeSymbol || other is SourceMemberContainerTypeSymbol);
+
                         switch (nts, other)
                         {
-                            case (SourceNamedTypeSymbol left, SourceNamedTypeSymbol right) when isFileLocalTypeInSeparateFileFrom(left, right) || isFileLocalTypeInSeparateFileFrom(right, left):
+                            case ({ } left, SourceMemberContainerTypeSymbol right) when isFileLocalTypeInSeparateFileFrom(left, right) || isFileLocalTypeInSeparateFileFrom(right, left):
                                 // no error
                                 break;
-                            case (SourceNamedTypeSymbol { IsFileLocal: true }, _) or (_, SourceNamedTypeSymbol { IsFileLocal: true }):
+                            case ({ IsFileLocal: true }, _) or (_, SourceMemberContainerTypeSymbol { IsFileLocal: true }):
                                 diagnostics.Add(ErrorCode.ERR_FileLocalDuplicateNameInNS, symbol.GetFirstLocationOrNone(), name, @namespace);
                                 break;
-                            case (SourceNamedTypeSymbol { IsPartial: true }, SourceNamedTypeSymbol { IsPartial: true }):
+                            case ({ IsPartial: true }, SourceMemberContainerTypeSymbol { IsPartial: true }):
                                 diagnostics.Add(ErrorCode.ERR_PartialTypeKindConflict, symbol.GetFirstLocationOrNone(), symbol);
                                 break;
                             default:
@@ -366,7 +373,7 @@ private static void CheckMembers(NamespaceSymbol @namespace, Dictionary<string,
                 }
             }
 
-            static bool isFileLocalTypeInSeparateFileFrom(SourceNamedTypeSymbol possibleFileLocalType, SourceNamedTypeSymbol otherSymbol)
+            static bool isFileLocalTypeInSeparateFileFrom(SourceMemberContainerTypeSymbol possibleFileLocalType, SourceMemberContainerTypeSymbol otherSymbol)
             {
                 if (!possibleFileLocalType.IsFileLocal)
                 {

src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs

@@ -429,6 +429,7 @@ internal override IEnumerable<CSharpAttributeData> GetCustomAttributesToEmit(PEM
             throw ExceptionUtilities.Unreachable();
         }
 
+        internal sealed override bool IsFileLocal => _underlyingType.IsFileLocal;
         internal sealed override FileIdentifier? AssociatedFileIdentifier => _underlyingType.AssociatedFileIdentifier;
 
         internal sealed override NamedTypeSymbol AsNativeInteger() => throw ExceptionUtilities.Unreachable();

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs

@@ -166,6 +166,7 @@ internal override IEnumerable<FieldSymbol> GetFieldsToEmit()
         internal override bool MangleName => Arity > 0;
 
 #nullable enable
+        internal sealed override bool IsFileLocal => false;
         internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 #nullable disable
 

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedAttributeSymbol.cs

@@ -99,7 +99,8 @@ internal abstract class SynthesizedEmbeddedAttributeSymbolBase : NamedTypeSymbol
 
         internal override bool MangleName => false;
 
-        internal override FileIdentifier? AssociatedFileIdentifier => null;
+        internal sealed override bool IsFileLocal => false;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
         internal override bool HasCodeAnalysisEmbeddedAttribute => true;
 

src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs

@@ -1366,7 +1366,7 @@ public static bool IsPartial(this TypeSymbol type)
 
         public static bool HasFileLocalTypes(this TypeSymbol type)
         {
-            var foundType = type.VisitType(predicate: (type, _, _) => type is SourceMemberContainerTypeSymbol { IsFileLocal: true }, arg: (object?)null);
+            var foundType = type.VisitType(predicate: (type, _, _) => type is NamedTypeSymbol { IsFileLocal: true }, arg: (object?)null);
             return foundType is not null;
         }
 

src/Compilers/CSharp/Portable/Symbols/UnboundGenericType.cs

@@ -91,6 +91,7 @@ internal override bool MangleName
             }
         }
 
+        internal override bool IsFileLocal => false;
         internal override FileIdentifier? AssociatedFileIdentifier => null;
 
         internal override DiagnosticInfo ErrorInfo

src/Compilers/CSharp/Portable/Symbols/UnsupportedMetadataTypeSymbol.cs

@@ -38,6 +38,7 @@ internal override bool MangleName
             }
         }
 
+        internal override bool IsFileLocal => false;
         internal override FileIdentifier? AssociatedFileIdentifier => null;
     }
 }

src/Compilers/CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs

@@ -44,7 +44,8 @@ internal override bool MangleName
             }
         }
 
-        internal override FileIdentifier? AssociatedFileIdentifier => null;
+        internal sealed override bool IsFileLocal => false;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier => null;
 
         public override ImmutableArray<TypeParameterSymbol> TypeParameters
         {