File types emit (#61646)

Author: RikkiGibson

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

@@ -2493,7 +2493,8 @@ protected AssemblySymbol GetForwardedToAssembly(string name, int arity, ref Name
 
             // NOTE: This won't work if the type isn't using CLS-style generic naming (i.e. `arity), but this code is
             // only intended to improve diagnostic messages, so false negatives in corner cases aren't a big deal.
-            var metadataName = MetadataHelpers.ComposeAritySuffixedMetadataName(name, arity);
+            // File types can't be forwarded, so we won't attempt to determine a file identifier to attach to the metadata name.
+            var metadataName = MetadataHelpers.ComposeAritySuffixedMetadataName(name, arity, associatedFileIdentifier: null);
             var fullMetadataName = MetadataHelpers.BuildQualifiedName(qualifierOpt?.ToDisplayString(SymbolDisplayFormat.QualifiedNameOnlyFormat), metadataName);
             var result = GetForwardedToAssembly(fullMetadataName, diagnostics, location);
             if ((object)result != null)

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -7112,6 +7112,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_FileTypeBase" xml:space="preserve">
     <value>File type '{0}' cannot be used as a base type of non-file type '{1}'.</value>
   </data>
+  <data name="ERR_FileTypeNested" xml:space="preserve">
+    <value>File type '{0}' must be defined in a top level type; '{0}' is a nested type.</value>
+  </data>
   <data name="IDS_FeatureUnsignedRightShift" xml:space="preserve">
     <value>unsigned right shift</value>
   </data>

src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeReference.cs

@@ -40,6 +40,16 @@ bool Cci.INamedTypeReference.MangleName
             }
         }
 
+#nullable enable
+        string? Cci.INamedTypeReference.AssociatedFileIdentifier
+        {
+            get
+            {
+                return UnderlyingNamedType.AssociatedFileIdentifier();
+            }
+        }
+#nullable disable
+
         string Cci.INamedEntity.Name
         {
             get

src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs

@@ -756,6 +756,16 @@ bool Cci.INamedTypeReference.MangleName
             }
         }
 
+#nullable enable
+        string? Cci.INamedTypeReference.AssociatedFileIdentifier
+        {
+            get
+            {
+                return AdaptedNamedTypeSymbol.AssociatedFileIdentifier();
+            }
+        }
+#nullable disable
+
         string Cci.INamedEntity.Name
         {
             get

src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs

@@ -660,7 +660,7 @@ private void ReportExportedTypeNameCollisions(ImmutableArray<Cci.ExportedType> e
                 // exported types are not emitted in EnC deltas (hence generation 0):
                 string fullEmittedName = MetadataHelpers.BuildQualifiedName(
                     ((Cci.INamespaceTypeReference)type.GetCciAdapter()).NamespaceName,
-                    Cci.MetadataWriter.GetMangledName(type.GetCciAdapter(), generation: 0));
+                    Cci.MetadataWriter.GetMetadataName(type.GetCciAdapter(), generation: 0));
 
                 // First check against types declared in the primary module
                 if (ContainsTopLevelType(fullEmittedName))

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2095,6 +2095,7 @@ internal enum ErrorCode
         ERR_FileTypeDisallowedInSignature = 9300,
         ERR_FileTypeNoExplicitAccessibility = 9301,
         ERR_FileTypeBase = 9302,
+        ERR_FileTypeNested = 9303,
 
         #endregion
 

src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Types.cs

@@ -10,6 +10,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.SymbolDisplay;
 using Roslyn.Utilities;
 
@@ -182,17 +183,28 @@ public override void VisitNamedType(INamedTypeSymbol symbol)
             AddNullableAnnotations(symbol);
 
             if ((format.CompilerInternalOptions & SymbolDisplayCompilerInternalOptions.IncludeContainingFileForFileTypes) != 0
-                // PROTOTYPE(ft): public API?
-                && symbol.GetSymbol() is SourceMemberContainerTypeSymbol { IsFile: true } fileType)
+                && symbol is Symbols.PublicModel.Symbol { UnderlyingSymbol: NamedTypeSymbol { AssociatedSyntaxTree: SyntaxTree tree } internalSymbol })
             {
-                var tree = symbol.DeclaringSyntaxReferences[0].SyntaxTree;
-                var fileDescription = tree.FilePath is { Length: not 0 } path
-                    ? Path.GetFileNameWithoutExtension(path)
-                    : $"<tree {fileType.DeclaringCompilation.SyntaxTrees.IndexOf(tree)}>";
+                var fileDescription = getDisplayFileName(tree) is { Length: not 0 } path
+                    ? path
+                    : $"<tree {internalSymbol.DeclaringCompilation.SyntaxTrees.IndexOf(tree)}>";
 
                 builder.Add(CreatePart(SymbolDisplayPartKind.Punctuation, symbol, "@"));
                 builder.Add(CreatePart(SymbolDisplayPartKind.ModuleName, symbol, fileDescription));
             }
+
+            static string getDisplayFileName(SyntaxTree tree)
+            {
+                if (tree.FilePath.Length == 0)
+                {
+                    return "";
+                }
+
+                var pooledBuilder = PooledStringBuilder.GetInstance();
+                var sb = pooledBuilder.Builder;
+                GeneratedNames.AppendFileName(tree.FilePath, sb);
+                return pooledBuilder.ToStringAndFree();
+            }
         }
 
         private void VisitNamedTypeWithoutNullability(INamedTypeSymbol symbol)

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

@@ -73,6 +73,8 @@ internal sealed override bool MangleName
                 get { return false; }
             }
 
+            internal sealed override SyntaxTree? AssociatedSyntaxTree => null;
+
             public sealed override int Arity
             {
                 get { return 0; }

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

@@ -237,6 +237,8 @@ internal sealed override bool MangleName
                 get { return this.Arity > 0; }
             }
 
+            internal sealed override SyntaxTree? AssociatedSyntaxTree => null;
+
             internal sealed override ImmutableArray<TypeWithAnnotations> TypeArgumentsWithAnnotationsNoUseSiteDiagnostics
             {
                 get { return GetTypeParametersAsTypeArguments(); }

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

@@ -578,6 +578,8 @@ internal override bool MangleName
             get { return _originalDefinition.MangleName; }
         }
 
+        internal override SyntaxTree? AssociatedSyntaxTree => _originalDefinition.AssociatedSyntaxTree;
+
         internal override DiagnosticInfo? ErrorInfo
         {
             get { return _originalDefinition.ErrorInfo; }