From 2665e5d4ec57e7d9c2920b3279d37033cf65451f Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Tue, 30 May 2023 16:44:35 -0700
Subject: [PATCH 1/8] Fix HasFileLocalTypes check for constructed types

---
 .../Portable/Symbols/TypeSymbolExtensions.cs  |   2 +-
 .../Symbols/Source/FileModifierTests.cs       | 184 ++++++++++++++++++
 2 files changed, 185 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
index e716400a60e8b..abf20dfbb33dc 100644
--- a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
+++ b/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.OriginalDefinition is SourceMemberContainerTypeSymbol { IsFileLocal: true }, arg: (object?)null);
             return foundType is not null;
         }
 
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
index 96928b63c0555..94c6a43843dc1 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
@@ -2020,6 +2020,31 @@ public void SignatureUsage_06()
             Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "Del2").WithArguments("C", "Del2").WithLocation(6, 12));
     }
 
+    [Fact]
+    public void SignatureUsage_06_2()
+    {
+        var source = """
+            file class C<T>
+            {
+            }
+
+            delegate void Del1(C<int> c); // 1
+            delegate C<int> Del2(); // 2
+
+            file delegate void Del3(C<int> c); // ok
+            file delegate C<int> Del4(); // ok
+            """;
+
+        var comp = CreateCompilation(source);
+        comp.VerifyDiagnostics(
+            // (5,15): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'Del1'.
+            // delegate void Del1(C<int> c); // 1
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "Del1").WithArguments("C<int>", "Del1").WithLocation(5, 15),
+            // (6,17): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'Del2'.
+            // delegate C<int> Del2(); // 2
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "Del2").WithArguments("C<int>", "Del2").WithLocation(6, 17));
+    }
+
     [Fact]
     public void SignatureUsage_07()
     {
@@ -2093,6 +2118,60 @@ class D
             Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C", "D").WithLocation(7, 14));
     }
 
+    [Fact]
+    public void SignatureUsage_10()
+    {
+        var source = """
+            #pragma warning disable 67, 169 // unused event, field
+
+            file class C<T> { }
+            file delegate void Del<T>(T input);
+
+            class C
+            {
+                private C<int> F; // 1
+                private event Del<int> E; // 2
+                private void M(C<int> input) { } // 3
+                private C<int> M() => throw null!; // 4
+
+                private C<int> P { get; set; } // 5
+                private C<int> this[int i] => throw null!; // 6
+            }
+
+            file class FC
+            {
+                private C<int> F;
+                private event Del<int> E;
+                private void M(C<int> input) { }
+                private C<int> M() => throw null!;
+
+                private C<int> P { get; set; }
+                private C<int> this[int i] => throw null!;
+            }
+            """;
+
+        var comp = CreateCompilation(source);
+        comp.VerifyDiagnostics(
+            // (8,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            //     private C<int> F; // 1
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "F").WithArguments("C<int>", "C").WithLocation(8, 20),
+            // (9,28): error CS9051: File-local type 'Del<int>' cannot be used in a member signature in non-file-local type 'C'.
+            //     private event Del<int> E; // 2
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "E").WithArguments("Del<int>", "C").WithLocation(9, 28),
+            // (10,18): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            //     private void M(C<int> input) { } // 3
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C<int>", "C").WithLocation(10, 18),
+            // (11,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            //     private C<int> M() => throw null!; // 4
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C<int>", "C").WithLocation(11, 20),
+            // (13,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            //     private C<int> P { get; set; } // 5
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "P").WithArguments("C<int>", "C").WithLocation(13, 20),
+            // (14,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            //     private C<int> this[int i] => throw null!; // 6
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "this").WithArguments("C<int>", "C").WithLocation(14, 20));
+    }
+
     [Fact]
     public void AccessModifiers_01()
     {
@@ -2285,6 +2364,34 @@ partial interface Derived : I2 { }
             Diagnostic(ErrorCode.ERR_FileTypeBase, "Derived").WithArguments("I1", "Derived").WithLocation(3, 19));
     }
 
+    [Fact]
+    public void BaseClause_06()
+    {
+        var source = """
+        file class C<T> { }
+
+        class D : C<int>, I<int> { } // 1
+        file class E : C<int>, I<int> { }
+
+        file interface I<T> { }
+
+        class F : I<int> { } // ok
+        file class G : I<int> { }
+
+        interface J : I<int> { } // 2
+        file interface K : I<int> { }
+        """;
+
+        var comp = CreateCompilation((source, "Program.cs"));
+        comp.VerifyEmitDiagnostics(
+            // Program.cs(3,7): error CS9053: File-local type 'C<int>' cannot be used as a base type of non-file-local type 'D'.
+            // class D : C<int>, I<int> { } // 1
+            Diagnostic(ErrorCode.ERR_FileTypeBase, "D").WithArguments("C<int>", "D").WithLocation(3, 7),
+            // Program.cs(11,11): error CS9053: File-local type 'I<int>' cannot be used as a base type of non-file-local type 'J'.
+            // interface J : I<int> { } // 2
+            Diagnostic(ErrorCode.ERR_FileTypeBase, "J").WithArguments("I<int>", "J").WithLocation(11, 11));
+    }
+
     [Fact]
     public void InterfaceImplementation_01()
     {
@@ -2541,6 +2648,48 @@ public void Constraints_04()
             Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "C").WithArguments("C", "D2<T>").WithLocation(5, 36));
     }
 
+    [Fact]
+    public void Constraints_05()
+    {
+        var source = """
+            file class C<T> { }
+
+            class D
+            {
+                private void M<T>(T t) where T : C<int> { } // 1
+            }
+
+            file class E
+            {
+                private void M<T>(T t) where T : C<int> { } // ok
+            }
+            """;
+
+        var comp = CreateCompilation(source);
+        comp.VerifyDiagnostics(
+            // (5,38): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'D.M<T>(T)'.
+            //     private void M<T>(T t) where T : C<int> { } // 1
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "C<int>").WithArguments("C<int>", "D.M<T>(T)").WithLocation(5, 38));
+    }
+
+    [Fact]
+    public void Constraints_06()
+    {
+        var source = """
+            file class C<T> { }
+
+            class D<T> where T : C<int> { } // 1
+
+            file class E<T> where T : C<int> { } // ok
+            """;
+
+        var comp = CreateCompilation(source);
+        comp.VerifyDiagnostics(
+            // (3,22): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'D<T>'.
+            // class D<T> where T : C<int> { } // 1
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "C<int>").WithArguments("C<int>", "D<T>").WithLocation(3, 22));
+    }
+
     [Fact]
     public void PrimaryConstructor_01()
     {
@@ -2882,6 +3031,41 @@ public static void Main()
                 Diagnostic(ErrorCode.ERR_NameNotInContext, "M").WithArguments("M").WithLocation(5, 9));
     }
 
+    [Fact]
+    public void GlobalUsingStatic_03()
+    {
+        var source = """
+            global using static C<int>;
+
+            file class C<T>
+            {
+                public static void M() { }
+            }
+            """;
+
+        var main = """
+            class Program
+            {
+                public static void Main()
+                {
+                    M();
+                }
+            }
+            """;
+
+        var compilation = CreateCompilation(new[] { (source, "file1.cs"), (main, "file2.cs") });
+        compilation.VerifyDiagnostics(
+            // file1.cs(1,1): hidden CS8019: Unnecessary using directive.
+            // global using static C<int>;
+            Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "global using static C<int>;").WithLocation(1, 1),
+            // file1.cs(1,21): error CS9055: File-local type 'C<int>' cannot be used in a 'global using static' directive.
+            // global using static C<int>;
+            Diagnostic(ErrorCode.ERR_GlobalUsingStaticFileType, "C<int>").WithArguments("C<int>").WithLocation(1, 21),
+            // file2.cs(5,9): error CS0103: The name 'M' does not exist in the current context
+            //         M();
+            Diagnostic(ErrorCode.ERR_NameNotInContext, "M").WithArguments("M").WithLocation(5, 9));
+    }
+
     [Fact]
     public void UsingStatic_01()
     {

From 6fe8fce438df62905d26ac7828b4a02a00dd2ab7 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Wed, 31 May 2023 15:32:25 -0700
Subject: [PATCH 2/8] Introduce NamedTypeSymbol.IsFileLocal

---
 src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs       | 2 +-
 .../CSharp/Portable/Compilation/CSharpCompilation.cs        | 2 +-
 .../AnonymousManager.TypeOrDelegatePublicSymbol.cs          | 1 +
 .../AnonymousType.TypeOrDelegateTemplateSymbol.cs           | 1 +
 src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs    | 3 ++-
 .../CSharp/Portable/Symbols/ExtendedErrorTypeSymbol.cs      | 1 +
 .../Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs       | 3 ++-
 .../CSharp/Portable/Symbols/MissingMetadataTypeSymbol.cs    | 3 ++-
 src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs    | 2 ++
 .../CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs      | 3 ++-
 .../Portable/Symbols/NoPiaAmbiguousCanonicalTypeSymbol.cs   | 3 ++-
 .../Symbols/NoPiaIllegalGenericInstantiationSymbol.cs       | 3 ++-
 .../Portable/Symbols/NoPiaMissingCanonicalTypeSymbol.cs     | 3 ++-
 .../Portable/Symbols/PlaceholderTypeArgumentSymbol.cs       | 1 +
 .../CSharp/Portable/Symbols/PublicModel/NamedTypeSymbol.cs  | 6 +++---
 .../Symbols/Retargeting/RetargetingNamedTypeSymbol.cs       | 1 +
 .../Portable/Symbols/Source/SourceMemberContainerSymbol.cs  | 2 +-
 .../CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs   | 1 +
 .../Portable/Symbols/Synthesized/SynthesizedContainer.cs    | 1 +
 .../Synthesized/SynthesizedEmbeddedAttributeSymbol.cs       | 3 ++-
 src/Compilers/CSharp/Portable/Symbols/UnboundGenericType.cs | 1 +
 .../Portable/Symbols/UnsupportedMetadataTypeSymbol.cs       | 1 +
 .../CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs       | 3 ++-
 .../Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs  | 1 +
 24 files changed, 36 insertions(+), 15 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs
index d3cbe2574fbca..f5d2c0995d061 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs
+++ b/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;
             }
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index 3ecebb7fae368..fc78d7102a22f 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/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;
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/PublicSymbols/AnonymousManager.TypeOrDelegatePublicSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/PublicSymbols/AnonymousManager.TypeOrDelegatePublicSymbol.cs
index 06788db9915e5..09f97ddf812c2 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/PublicSymbols/AnonymousManager.TypeOrDelegatePublicSymbol.cs
+++ b/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
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeOrDelegateTemplateSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeOrDelegateTemplateSymbol.cs
index ec05349c85c53..7a1d71b3aea79 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeOrDelegateTemplateSymbol.cs
+++ b/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
diff --git a/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs
index 230869b1083c1..9a5f60990d32e 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs
+++ b/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
         {
diff --git a/src/Compilers/CSharp/Portable/Symbols/ExtendedErrorTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ExtendedErrorTypeSymbol.cs
index 1beb24ad71c41..74be7fa53d0a7 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ExtendedErrorTypeSymbol.cs
+++ b/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
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
index 55abe62496b5c..35ea877efa7ec 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
+++ b/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 => AssociatedFileIdentifier is not null;
+        internal sealed override FileIdentifier? AssociatedFileIdentifier
         {
             get
             {
diff --git a/src/Compilers/CSharp/Portable/Symbols/MissingMetadataTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/MissingMetadataTypeSymbol.cs
index 29c3189a7f126..4eb2298265afe 100644
--- a/src/Compilers/CSharp/Portable/Symbols/MissingMetadataTypeSymbol.cs
+++ b/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.
diff --git a/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs
index a9d13c85c4175..2a50bca783f4a 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs
+++ b/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>
diff --git a/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
index 7a296e86a1722..b0a43b159ead3 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
+++ b/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;
diff --git a/src/Compilers/CSharp/Portable/Symbols/NoPiaAmbiguousCanonicalTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NoPiaAmbiguousCanonicalTypeSymbol.cs
index eaecffd33c8a7..a1d83b05ff17c 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NoPiaAmbiguousCanonicalTypeSymbol.cs
+++ b/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
         {
diff --git a/src/Compilers/CSharp/Portable/Symbols/NoPiaIllegalGenericInstantiationSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NoPiaIllegalGenericInstantiationSymbol.cs
index 06e5b8cc138af..a051fb8b976b0 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NoPiaIllegalGenericInstantiationSymbol.cs
+++ b/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
         {
diff --git a/src/Compilers/CSharp/Portable/Symbols/NoPiaMissingCanonicalTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NoPiaMissingCanonicalTypeSymbol.cs
index e785f225d49ec..14cd9b7558f85 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NoPiaMissingCanonicalTypeSymbol.cs
+++ b/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
         {
diff --git a/src/Compilers/CSharp/Portable/Symbols/PlaceholderTypeArgumentSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/PlaceholderTypeArgumentSymbol.cs
index 8545ec720d59c..8ac21488f2074 100644
--- a/src/Compilers/CSharp/Portable/Symbols/PlaceholderTypeArgumentSymbol.cs
+++ b/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
diff --git a/src/Compilers/CSharp/Portable/Symbols/PublicModel/NamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/PublicModel/NamedTypeSymbol.cs
index 8f26fefe58f55..38863cab17cb7 100644
--- a/src/Compilers/CSharp/Portable/Symbols/PublicModel/NamedTypeSymbol.cs
+++ b/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();
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs
index 14be3d9c59bf7..ed82a7972917b 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs
+++ b/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();
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
index d038c2ece3ebf..02251fe1ce03b 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
+++ b/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);
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs
index 508d2addb26f4..093204f055809 100644
--- a/src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs
+++ b/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();
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
index e8372fb269453..90e3812955994 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
+++ b/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
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedAttributeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedAttributeSymbol.cs
index 7e0e82cf48c51..0974a84390384 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedAttributeSymbol.cs
+++ b/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;
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/UnboundGenericType.cs b/src/Compilers/CSharp/Portable/Symbols/UnboundGenericType.cs
index 4d62bc15cbfa8..dd45b91113b68 100644
--- a/src/Compilers/CSharp/Portable/Symbols/UnboundGenericType.cs
+++ b/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
diff --git a/src/Compilers/CSharp/Portable/Symbols/UnsupportedMetadataTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/UnsupportedMetadataTypeSymbol.cs
index 568823bb450e0..8aaaf41029d72 100644
--- a/src/Compilers/CSharp/Portable/Symbols/UnsupportedMetadataTypeSymbol.cs
+++ b/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;
     }
 }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs
index cfca66891dc05..556c9a82de733 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs
+++ b/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
         {
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs
index 2bd6c9a780ad0..11c1711c45f55 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs
@@ -159,6 +159,7 @@ internal override bool MangleName
             get { return false; }
         }
 
+        internal override bool IsFileLocal => false;
         internal override FileIdentifier? AssociatedFileIdentifier => null;
 
         public override IEnumerable<string> MemberNames

From 5149e29750558e94e6104bcf07ec178bdf572735 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Wed, 31 May 2023 16:45:29 -0700
Subject: [PATCH 3/8] verify some symbols in new tests

---
 .../Symbols/Source/FileModifierTests.cs       | 62 ++++++++++++++-----
 1 file changed, 47 insertions(+), 15 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
index 94c6a43843dc1..0b8e3d44bbf13 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
@@ -2043,6 +2043,10 @@ public void SignatureUsage_06_2()
             // (6,17): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'Del2'.
             // delegate C<int> Del2(); // 2
             Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "Del2").WithArguments("C<int>", "Del2").WithLocation(6, 17));
+
+        var del1 = comp.GetMember<NamedTypeSymbol>("Del1");
+        var cInt = (ConstructedNamedTypeSymbol)del1.DelegateInvokeMethod.Parameters[0].Type;
+        Assert.True(cInt.IsFileLocal);
     }
 
     [Fact]
@@ -2127,7 +2131,7 @@ public void SignatureUsage_10()
             file class C<T> { }
             file delegate void Del<T>(T input);
 
-            class C
+            class C1
             {
                 private C<int> F; // 1
                 private event Del<int> E; // 2
@@ -2152,24 +2156,37 @@ class C
 
         var comp = CreateCompilation(source);
         comp.VerifyDiagnostics(
-            // (8,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            // (8,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C1'.
             //     private C<int> F; // 1
-            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "F").WithArguments("C<int>", "C").WithLocation(8, 20),
-            // (9,28): error CS9051: File-local type 'Del<int>' cannot be used in a member signature in non-file-local type 'C'.
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "F").WithArguments("C<int>", "C1").WithLocation(8, 20),
+            // (9,28): error CS9051: File-local type 'Del<int>' cannot be used in a member signature in non-file-local type 'C1'.
             //     private event Del<int> E; // 2
-            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "E").WithArguments("Del<int>", "C").WithLocation(9, 28),
-            // (10,18): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "E").WithArguments("Del<int>", "C1").WithLocation(9, 28),
+            // (10,18): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C1'.
             //     private void M(C<int> input) { } // 3
-            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C<int>", "C").WithLocation(10, 18),
-            // (11,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C<int>", "C1").WithLocation(10, 18),
+            // (11,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C1'.
             //     private C<int> M() => throw null!; // 4
-            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C<int>", "C").WithLocation(11, 20),
-            // (13,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C<int>", "C1").WithLocation(11, 20),
+            // (13,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C1'.
             //     private C<int> P { get; set; } // 5
-            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "P").WithArguments("C<int>", "C").WithLocation(13, 20),
-            // (14,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C'.
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "P").WithArguments("C<int>", "C1").WithLocation(13, 20),
+            // (14,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C1'.
             //     private C<int> this[int i] => throw null!; // 6
-            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "this").WithArguments("C<int>", "C").WithLocation(14, 20));
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "this").WithArguments("C<int>", "C1").WithLocation(14, 20));
+
+        verifyConstructedFileType(comp.GetMember<FieldSymbol>("C1.F").Type);
+        verifyConstructedFileType(comp.GetMember<EventSymbol>("C1.E").Type);
+        verifyConstructedFileType(comp.GetMember<MethodSymbol>("C1.M(C<int>)").Parameters[0].Type);
+        verifyConstructedFileType(comp.GetMember<MethodSymbol>("C1.M()").ReturnType);
+        verifyConstructedFileType(comp.GetMember<PropertySymbol>("C1.P").Type);
+        verifyConstructedFileType(comp.GetMember<PropertySymbol>("C1.Item").Type);
+
+        void verifyConstructedFileType(TypeSymbol type)
+        {
+            var cInt = (ConstructedNamedTypeSymbol)type;
+            Assert.True(cInt.IsFileLocal);
+        }
     }
 
     [Fact]
@@ -2370,8 +2387,8 @@ public void BaseClause_06()
         var source = """
         file class C<T> { }
 
-        class D : C<int>, I<int> { } // 1
-        file class E : C<int>, I<int> { }
+        class D : C<int> { } // 1
+        file class E : C<int> { }
 
         file interface I<T> { }
 
@@ -2390,6 +2407,15 @@ interface J : I<int> { } // 2
             // Program.cs(11,11): error CS9053: File-local type 'I<int>' cannot be used as a base type of non-file-local type 'J'.
             // interface J : I<int> { } // 2
             Diagnostic(ErrorCode.ERR_FileTypeBase, "J").WithArguments("I<int>", "J").WithLocation(11, 11));
+
+        var cInt = (ConstructedNamedTypeSymbol)comp.GetMember<NamedTypeSymbol>("D").BaseTypeNoUseSiteDiagnostics;
+        Assert.True(cInt.IsFileLocal);
+
+        var iInt = (ConstructedNamedTypeSymbol)comp.GetMember<NamedTypeSymbol>("F").InterfacesNoUseSiteDiagnostics()[0];
+        Assert.True(iInt.IsFileLocal);
+
+        iInt = (ConstructedNamedTypeSymbol)comp.GetMember<NamedTypeSymbol>("J").InterfacesNoUseSiteDiagnostics()[0];
+        Assert.True(iInt.IsFileLocal);
     }
 
     [Fact]
@@ -2670,6 +2696,9 @@ class D
             // (5,38): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'D.M<T>(T)'.
             //     private void M<T>(T t) where T : C<int> { } // 1
             Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "C<int>").WithArguments("C<int>", "D.M<T>(T)").WithLocation(5, 38));
+
+        var cInt = (ConstructedNamedTypeSymbol)comp.GetMember<MethodSymbol>("D.M").TypeParameters[0].ConstraintTypesNoUseSiteDiagnostics[0].Type;
+        Assert.True(cInt.IsFileLocal);
     }
 
     [Fact]
@@ -2688,6 +2717,9 @@ class D<T> where T : C<int> { } // 1
             // (3,22): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'D<T>'.
             // class D<T> where T : C<int> { } // 1
             Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "C<int>").WithArguments("C<int>", "D<T>").WithLocation(3, 22));
+
+        var cInt = (ConstructedNamedTypeSymbol)comp.GetMember<NamedTypeSymbol>("D").TypeParameters[0].ConstraintTypesNoUseSiteDiagnostics[0].Type;
+        Assert.True(cInt.IsFileLocal);
     }
 
     [Fact]

From c0999e5a9f63e7fb5fee9356a8a73b599c8c4164 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Wed, 31 May 2023 17:03:56 -0700
Subject: [PATCH 4/8] Fix test

---
 .../Symbols/Source/FileModifierTests.cs       | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
index 0b8e3d44bbf13..4894ee7d19cdd 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FileModifierTests.cs
@@ -2135,8 +2135,8 @@ class C1
             {
                 private C<int> F; // 1
                 private event Del<int> E; // 2
-                private void M(C<int> input) { } // 3
-                private C<int> M() => throw null!; // 4
+                private void M1(C<int> input) { } // 3
+                private C<int> M2() => throw null!; // 4
 
                 private C<int> P { get; set; } // 5
                 private C<int> this[int i] => throw null!; // 6
@@ -2146,8 +2146,8 @@ class C1
             {
                 private C<int> F;
                 private event Del<int> E;
-                private void M(C<int> input) { }
-                private C<int> M() => throw null!;
+                private void M1(C<int> input) { }
+                private C<int> M2() => throw null!;
 
                 private C<int> P { get; set; }
                 private C<int> this[int i] => throw null!;
@@ -2163,11 +2163,11 @@ class C1
             //     private event Del<int> E; // 2
             Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "E").WithArguments("Del<int>", "C1").WithLocation(9, 28),
             // (10,18): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C1'.
-            //     private void M(C<int> input) { } // 3
-            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C<int>", "C1").WithLocation(10, 18),
+            //     private void M1(C<int> input) { } // 3
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M1").WithArguments("C<int>", "C1").WithLocation(10, 18),
             // (11,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C1'.
-            //     private C<int> M() => throw null!; // 4
-            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M").WithArguments("C<int>", "C1").WithLocation(11, 20),
+            //     private C<int> M2() => throw null!; // 4
+            Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "M2").WithArguments("C<int>", "C1").WithLocation(11, 20),
             // (13,20): error CS9051: File-local type 'C<int>' cannot be used in a member signature in non-file-local type 'C1'.
             //     private C<int> P { get; set; } // 5
             Diagnostic(ErrorCode.ERR_FileTypeDisallowedInSignature, "P").WithArguments("C<int>", "C1").WithLocation(13, 20),
@@ -2177,10 +2177,10 @@ class C1
 
         verifyConstructedFileType(comp.GetMember<FieldSymbol>("C1.F").Type);
         verifyConstructedFileType(comp.GetMember<EventSymbol>("C1.E").Type);
-        verifyConstructedFileType(comp.GetMember<MethodSymbol>("C1.M(C<int>)").Parameters[0].Type);
-        verifyConstructedFileType(comp.GetMember<MethodSymbol>("C1.M()").ReturnType);
+        verifyConstructedFileType(comp.GetMember<MethodSymbol>("C1.M1").Parameters[0].Type);
+        verifyConstructedFileType(comp.GetMember<MethodSymbol>("C1.M2").ReturnType);
         verifyConstructedFileType(comp.GetMember<PropertySymbol>("C1.P").Type);
-        verifyConstructedFileType(comp.GetMember<PropertySymbol>("C1.Item").Type);
+        verifyConstructedFileType(comp.GetMember<PropertySymbol>("C1.this[]").Type);
 
         void verifyConstructedFileType(TypeSymbol type)
         {

From 6648862231a88df152b81c7524f6efd84b737385 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Thu, 1 Jun 2023 10:53:22 -0700
Subject: [PATCH 5/8] Address feedback

---
 .../CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs    | 2 +-
 src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
index 35ea877efa7ec..2e339b182a348 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
@@ -394,7 +394,7 @@ internal override ModuleSymbol ContainingModule
             get;
         }
 
-        internal sealed override bool IsFileLocal => AssociatedFileIdentifier is not null;
+        internal sealed override bool IsFileLocal => _lazyUncommonProperties is { lazyFilePathChecksum: { IsDefault: false }, lazyDisplayFileName: { } };
         internal sealed override FileIdentifier? AssociatedFileIdentifier
         {
             get
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
index abf20dfbb33dc..69bc5a621c81b 100644
--- a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
+++ b/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.OriginalDefinition 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;
         }
 

From 1f3099f0552ae2cdfcb7edb55b5836dedf7dc007 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Fri, 2 Jun 2023 15:55:29 -0700
Subject: [PATCH 6/8] Reduce and consolidate casting of symbols where we later
 check IsFileLocal

---
 .../CSharp/Portable/Binder/Binder_Symbols.cs    |  2 +-
 .../Symbols/Source/SourceNamespaceSymbol.cs     | 17 ++++++++++++-----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
index dec3baa78de6e..12ffd218658da 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
+++ b/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;
             }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
index e4c2c7a2a0e63..7715d4edfbe2e 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
+++ b/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)
                 {

From c8ce6d942eb801e8548d409b23372695f6b056c5 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Tue, 6 Jun 2023 11:53:10 -0700
Subject: [PATCH 7/8] Remove incorrect assert

---
 .../CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs      | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
index 7715d4edfbe2e..2fc089c01c3d1 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
@@ -340,7 +340,6 @@ private static void CheckMembers(NamespaceSymbol @namespace, Dictionary<string,
                     {
                         // 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)
                         {

From 280ef09dc5f19cbdf593b192ec91030a7966b4e0 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Thu, 8 Jun 2023 11:04:37 -0700
Subject: [PATCH 8/8] Fix assert

---
 .../CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
index 2fc089c01c3d1..9b91d96daaab4 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
@@ -338,8 +338,8 @@ 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);
+                        // To decide whether type declarations are duplicates, we need to access members which are only meaningful on source original definition symbols.
+                        Debug.Assert((object)nts?.OriginalDefinition == nts && (object)other.OriginalDefinition == other);
 
                         switch (nts, other)
                         {