File types emit

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/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/SymbolDisplay/SymbolDisplayVisitor.Types.cs

@@ -182,13 +182,11 @@ 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.GetSymbol() is SourceMemberContainerTypeSymbol { 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 = tree.GetDisplayFileName() 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));

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

@@ -478,14 +478,15 @@ public virtual bool IsImplicitClass
         /// </summary>
         public abstract override string Name { get; }
 
+#nullable enable
         /// <summary>
         /// Return the name including the metadata arity suffix.
         /// </summary>
         public override string MetadataName
         {
             get
             {
-                return MangleName ? MetadataHelpers.ComposeAritySuffixedMetadataName(Name, Arity) : Name;
+                return MangleName ? MetadataHelpers.ComposeAritySuffixedMetadataName(Name, Arity, this.AssociatedFileIdentifier()) : Name;
             }
         }
 
@@ -498,6 +499,7 @@ internal abstract bool MangleName
             // Intentionally no default implementation to force consideration of appropriate implementation for each new subclass
             get;
         }
+#nullable disable
 
         /// <summary>
         /// Collection of names of members declared within this type. May return duplicates.

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

@@ -932,7 +932,7 @@ internal override bool MangleName
         {
             get
             {
-                return Arity > 0;
+                return Arity > 0 || IsFile;
             }
         }
 

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

@@ -30,6 +30,7 @@ internal enum GeneratedNameKind
         ReusableHoistedLocalField = '7',
         LambdaCacheField = '9',
         FixedBufferField = 'e',
+        FileType = 'F',
         AnonymousType = 'f',
         TransparentIdentifier = 'h',
         AnonymousTypeField = 'i',

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

@@ -7,6 +7,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Text;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -1361,6 +1362,64 @@ public static bool IsFileTypeOrUsesFileTypes(this TypeSymbol type)
             return foundType is not null;
         }
 
+        internal static string? AssociatedFileIdentifier(this NamedTypeSymbol type)
+        {
+            if (type is not SourceMemberContainerTypeSymbol { AssociatedSyntaxTree: SyntaxTree tree })
+            {
+                return null;
+            }
+            var ordinal = type.DeclaringCompilation.GetSyntaxTreeOrdinal(tree);
+
+            var pooledBuilder = PooledStringBuilder.GetInstance();
+            var sb = pooledBuilder.Builder;
+            sb.Append('<');
+            AppendFileName(tree, sb);
+            sb.Append('>');
+            sb.Append((char)GeneratedNameKind.FileType);
+            sb.Append(ordinal);
+            sb.Append("__");
+            return pooledBuilder.ToStringAndFree();
+        }
+
+        internal static string GetDisplayFileName(this SyntaxTree tree)
+        {
+            var pooledBuilder = PooledStringBuilder.GetInstance();
+            var sb = pooledBuilder.Builder;
+            AppendFileName(tree, sb);
+            return pooledBuilder.ToStringAndFree();
+        }
+
+        private static void AppendFileName(SyntaxTree tree, StringBuilder sb)
+        {
+            // note: a "file path" for a syntax tree can be basically any string.
+            // since methods like Path.GetFileNameWithoutExtension throw when invalid path characters are found,
+            // we implement more of a heuristic here.
+            var originalFilePath = tree.FilePath;
+            var fileNameStartIndex = Math.Max(originalFilePath.LastIndexOf('/'), originalFilePath.LastIndexOf('\\')) + 1;
+            var fileNameEndIndex = originalFilePath.LastIndexOf('.');
+            if (fileNameEndIndex < fileNameStartIndex)
+            {
+                fileNameEndIndex = originalFilePath.Length;
+            }
+
+            for (int i = fileNameStartIndex; i < fileNameEndIndex; i++)
+            {
+                var ch = originalFilePath[i];
+                switch (ch)
+                {
+                    case '_':
+                    case >= 'a' and <= 'z':
+                    case >= 'A' and <= 'Z':
+                    case >= '0' and <= '9':
+                        sb.Append(ch);
+                        break;
+                    default:
+                        sb.Append('_');
+                        break;
+                }
+            }
+        }
+
         public static bool IsPointerType(this TypeSymbol type)
         {
             return type is PointerTypeSymbol;