[wasm] Fix JSExport on struct and records

src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportStubContext.cs

@@ -4,7 +4,9 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
+using System.Text;
 using System.Threading;
 
 using Microsoft.CodeAnalysis;
@@ -16,6 +18,14 @@ namespace Microsoft.Interop.JavaScript
 {
     internal sealed class JSSignatureContext : IEquatable<JSSignatureContext>
     {
+        private static SymbolDisplayPartKind[] nameKinds = new[]
+        {
+            SymbolDisplayPartKind.ClassName,
+            SymbolDisplayPartKind.StructName,
+            SymbolDisplayPartKind.RecordClassName,
+            SymbolDisplayPartKind.RecordStructName
+        };
+
         internal static readonly string GeneratorName = typeof(JSImportGenerator).Assembly.GetName().Name;
 
         internal static readonly string GeneratorVersion = typeof(JSImportGenerator).Assembly.GetName().Version.ToString();
@@ -118,14 +128,8 @@ public static JSSignatureContext Create(
             };
             int typesHash = Math.Abs((int)hash);
 
-
-
             var fullName = $"{method.ContainingType.ToDisplayString()}.{method.Name}";
-            string qualifiedName;
-            var ns = string.Join(".", method.ContainingType.ToDisplayParts().Where(p => p.Kind == SymbolDisplayPartKind.NamespaceName).Select(x => x.ToString()).ToArray());
-            var cn = string.Join("/", method.ContainingType.ToDisplayParts().Where(p => p.Kind == SymbolDisplayPartKind.ClassName).Select(x => x.ToString()).ToArray());
-            var qclasses = method.ContainingType.ContainingNamespace == null ? ns : ns + "." + cn;
-            qualifiedName = $"[{env.Compilation.AssemblyName}]{qclasses}:{method.Name}";
+            string qualifiedName = GetQualifiedName(env, method);
 
             return new JSSignatureContext()
             {
@@ -143,6 +147,54 @@ public static JSSignatureContext Create(
             };
         }
 
+        private static string GetQualifiedName(StubEnvironment env, IMethodSymbol method)
+        {
+            bool isFirstTypeName = true;
+            string? namespaceName = null;
+            string? className;
+            StringBuilder nameBuilder = new StringBuilder();
+            ImmutableArray<SymbolDisplayPart> nameParts = method.ContainingType.ToDisplayParts();
+            foreach (SymbolDisplayPart namePart in nameParts)
+            {
+                if (namePart.Kind == SymbolDisplayPartKind.NamespaceName)
+                {
+                    if (!isFirstTypeName)
+                        throw new InvalidOperationException($"Found namespace name '{namePart}' after some type names '{nameBuilder}'");
+
+                    if (nameBuilder.Length != 0)
+                        nameBuilder.Append('.');
+
+                    nameBuilder.Append(namePart);
+                }
+                else if (Array.IndexOf(nameKinds, namePart.Kind) >= 0)
+                {
+                    if (isFirstTypeName)
+                    {
+                        namespaceName = nameBuilder.ToString();
+                        nameBuilder.Clear();
+                        isFirstTypeName = false;
+                    }
+
+                    if (nameBuilder.Length != 0)
+                        nameBuilder.Append('/');
+
+                    nameBuilder.Append(namePart);
+                }
+                else
+                {
+                    throw new InvalidOperationException($"Name kind '{namePart.Kind}' should be reached");
+                }
+            }
+
+            if (isFirstTypeName)
+                throw new InvalidOperationException($"Type name not found in '{nameParts}'");
+            else
+                className = nameBuilder.ToString();
+
+            string qualifiedClassName = namespaceName == null ? className : namespaceName + "." + className;
+            return $"[{env.Compilation.AssemblyName}]{qualifiedClassName}:{method.Name}";
+        }
+
         private static (ImmutableArray<TypePositionInfo>, IMarshallingGeneratorFactory) GenerateTypeInformation(IMethodSymbol method, GeneratorDiagnostics diagnostics, StubEnvironment env)
         {
             var jsMarshallingAttributeParser = new JSMarshallingAttributeInfoParser(env.Compilation, diagnostics, method);

src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/JSImportExportTest.cs

@@ -1199,7 +1199,54 @@ public void JsExportString(string value)
         public void JsExportStringNoNs()
         {
             var actual = JavaScriptTestHelper.invoke2_String("test", nameof(JavaScriptTestHelperNoNamespace.EchoString));
-            Assert.Equal("test!", actual);
+            Assert.Equal("test51", actual);
+        }
+
+        [Fact]
+        public void JsExportStructClassRecords()
+        {
+            var actual = JavaScriptTestHelper.invokeStructClassRecords("test");
+            Assert.Equal(40, actual.Length);
+            Assert.Equal("test11", actual[0]);
+            Assert.Equal("test12", actual[1]);
+            Assert.Equal("test13", actual[2]);
+            Assert.Equal("test14", actual[3]);
+            Assert.Equal("test15", actual[4]);
+            Assert.Equal("test21", actual[5]);
+            Assert.Equal("test22", actual[6]);
+            Assert.Equal("test23", actual[7]);
+            Assert.Equal("test24", actual[8]);
+            Assert.Equal("test25", actual[9]);
+            Assert.Equal("test31", actual[10]);
+            Assert.Equal("test32", actual[11]);
+            Assert.Equal("test33", actual[12]);
+            Assert.Equal("test34", actual[13]);
+            Assert.Equal("test35", actual[14]);
+            Assert.Equal("test41", actual[15]);
+            Assert.Equal("test42", actual[16]);
+            Assert.Equal("test43", actual[17]);
+            Assert.Equal("test44", actual[18]);
+            Assert.Equal("test45", actual[19]);
+            Assert.Equal("test51", actual[20]);
+            Assert.Equal("test52", actual[21]);
+            Assert.Equal("test53", actual[22]);
+            Assert.Equal("test54", actual[23]);
+            Assert.Equal("test55", actual[24]);
+            Assert.Equal("test61", actual[25]);
+            Assert.Equal("test62", actual[26]);
+            Assert.Equal("test63", actual[27]);
+            Assert.Equal("test64", actual[28]);
+            Assert.Equal("test65", actual[29]);
+            Assert.Equal("test71", actual[30]);
+            Assert.Equal("test72", actual[31]);
+            Assert.Equal("test73", actual[32]);
+            Assert.Equal("test74", actual[33]);
+            Assert.Equal("test75", actual[34]);
+            Assert.Equal("test81", actual[35]);
+            Assert.Equal("test82", actual[36]);
+            Assert.Equal("test83", actual[37]);
+            Assert.Equal("test84", actual[38]);
+            Assert.Equal("test85", actual[39]);
         }
 
         [Fact]