fix

Author: elringus

docs/guide/specialization.md

@@ -60,7 +60,9 @@ The `[SpecializeImport]` attribute accepts optional `CS`, `JS`, `JSCtor` and `De
     Decl: "[Symbol.iterator](): IterableIterator<T>;")]
 ```
 
-The `CS` snippet can contain `$it` markers — they will be replaced with the fully-qualified C# syntax of the specialized instance. This allows referencing the concrete specialized instances in the proxy when the specialization is applied to a base class.
+The `CS` snippet can contain `$full` markers — they will be replaced with the fully-qualified type name of the specialized instance. This allows referencing the concrete specialized instances in the proxy when the specialization is applied to a base class.
+
+The `Decl` snippet can contain `$full`, `$name` and `$T{I}` markers — first is the same as CS one, but in TypeScript context, name is the short type name and `T` is the fully-qualified name of the generic type argument with the `{I}` inde (if any), for example `$T{0}` is replaced with the first generic argument.
 
 When `Decl` value starts with `export ` — the content will replace the entire TypeScript declaration of the type, instead of splicing it into the bottom of the default type declaration.
 

src/cs/Bootsharp.Common/Attributes/SpecializeImportAttribute.cs

@@ -13,7 +13,7 @@ namespace Bootsharp;
 /// </param>
 /// <param name="CS">
 /// Raw snippet spliced into the generated C# import proxy class body.
-/// All occurrences of '$it' are replaced with the fully-qualified C# syntax of the specialized instance type.
+/// All occurrences of '$full' are replaced with the fully-qualified type name of the specialized instance type.
 /// </param>
 /// <param name="JS">
 /// Raw snippet spliced into the generated JavaScript export proxy class body.
@@ -24,6 +24,10 @@ namespace Bootsharp;
 /// <param name="Decl">
 /// Raw snippet spliced into the generated TypeScript declaration.
 /// When starts with 'export ' will instead replace the whole declaration.
+/// Occurrences of '$name' are replaced with the name of the specialized instance type.
+/// Occurrences of '$full' are replaced with the fully-qualified name of the specialized instance type.
+/// When the instance type is generic, occurrences of '$T{I}' are replaced with the fully-qualified names
+/// of the generic type arguments with the {I} index, starting with 0 (eg, '$T0' is the first generic arg).
 /// </param>
 [AttributeUsage(AttributeTargets.Class)]
 public sealed class SpecializeImportAttribute (Type Clr, string? CS = null, string? JS = null,

src/cs/Bootsharp.Publish.Test/GenerateCS/CSInstanceTest.cs

@@ -287,7 +287,7 @@ public void GeneratesForCustomSpecializationOfBaseClass ()
             public abstract class Event<T>;
             public sealed class IntEvent : Event<int>;
 
-            [SpecializeImport(typeof(Event<>), CS: "protected override object Unwrap () => new $it();")]
+            [SpecializeImport(typeof(Event<>), CS: "protected override object Unwrap () => new $full();")]
             public abstract class EventImport<T> (int id) : SpecializedImport(id);
 
             [SpecializeExport(typeof(Event<>))]

src/cs/Bootsharp.Publish.Test/GenerateJS/DeclarationTest.cs

@@ -71,6 +71,25 @@ export namespace Foo {
             """);
     }
 
+    [Fact]
+    public void TypeNestedUnderInstancedDeclaredUnderNamespace ()
+    {
+        AddAssembly(
+            With("public class Foo { public record Bar; public int Value { get; } }"),
+            WithClass("[Export] public static Foo Get (Foo.Bar b) => default;"));
+        Execute();
+        Contains(
+            """
+            export interface Foo {
+                readonly value: number;
+            }
+            export namespace Foo {
+                export type Bar = Readonly<{
+                }>;
+            }
+            """);
+    }
+
     [Fact]
     public void CrawledTypeDoesNotOverrideSpecialized ()
     {
@@ -358,6 +377,22 @@ export interface Interface {
             """);
     }
 
+    [Fact]
+    public void ExtendsClosedGenericWithClosedArguments ()
+    {
+        AddAssembly(
+            With("public interface IBar<T> { T Get (); }"),
+            With("public class Foo : IBar<int> { public int Get () => 0; }"),
+            WithClass("[Export] public static Foo UseFoo (IBar<int> bar) => default;"));
+        Execute();
+        Contains(
+            """
+            export interface Foo extends IBar<number> {
+                get(): number;
+            }
+            """);
+    }
+
     [Fact]
     public void GeneratedForSpecializedTypes ()
     {
@@ -400,6 +435,27 @@ public class Class { [Export] public static Foo Get () => default; }
         DoesNotContain("export interface Foo");
     }
 
+    [Fact]
+    public void SpecializedDeclarationSubstitutesTemplates ()
+    {
+        AddAssembly(With(
+            """
+            public delegate void Handler (string arg);
+            public abstract class Event<T> where T : System.Delegate;
+            public sealed class HandlerEvent : Event<Handler>;
+            [SpecializeImport(typeof(Event<>), Decl: "export interface $name { broadcast: $T0; }")]
+            public abstract class EventImport<T> (int id) : SpecializedImport(id) where T : System.Delegate
+            {
+                public abstract void Subscribe (T handler);
+            }
+            [SpecializeExport(typeof(Event<>))]
+            public sealed class EventExport<T> (Event<T> it) : SpecializedExport(it) where T : System.Delegate;
+            public class Class { [Export] public static HandlerEvent Get () => default; }
+            """));
+        Execute();
+        Contains("export interface HandlerEvent { broadcast: Handler; }");
+    }
+
     [Fact]
     public void GeneratedForCollections ()
     {

src/cs/Bootsharp.Publish/GenerateCS/CSInstanceGenerator.cs

@@ -98,7 +98,7 @@ public sealed class {{it.Proxy.Id}} (int id) : {{sp.Import.Syntax}}(id)
           {
               ~{{it.Proxy.Id}}() => Instances.DisposeImported(_id);
 
-              {{Fmt([..it.Members.Select(EmitMemberImport), sp.CS?.Replace("$it", it.Syntax)])}}
+              {{Fmt([..it.Members.Select(EmitMemberImport), sp.CS?.Replace("$full", it.Syntax)])}}
           }
           """;
 

src/cs/Bootsharp.Publish/GenerateJS/Declarations/DeclarationGenerator.cs

@@ -33,32 +33,31 @@ public string Generate (JSModule module)
     }
 
     private string EmitImports (JSModule md) => Fmt([
-        $$"""import type * as $bcl from "{{md.To("bcl/index")}}";""",
+        $"""import type * as $bcl from "{md.To("bcl/index")}";""",
         ..mds.GetImported(md).Select(imp =>
             $"""import type * as {imp.Alias} from "{md.ToMd(imp.Path)}";""")
     ], 0);
 
     private void DeclareNode (JSNode node)
     {
-        var surf = node.Types.FirstOrDefault(s => s is SurfaceMeta and not InstanceMeta);
-        var wrap = surf != null || node.Children.Count > 0;
-        if (wrap)
-        {
-            if (surf != null) doc.Type(surf);
-            bld.Enter($"export namespace {node.Name} {{");
-        }
+        var surfaces = new List<SurfaceMeta>();
         foreach (var type in node.Types)
             // Dedup by CLR to discard the other side of a bidirectional (export+import)
             // instance surface and closed generic variants (all produce same open type).
             if (declared.Add(OpenGeneric(type.Clr)))
                 if (type is SerializedEnumMeta enu) DeclareEnum(enu);
-                else if (type is SerializedObjectMeta o) DeclareSerialized(o);
-                else if (type is DelegateMeta d) DeclareDelegate(d);
+                else if (type is SerializedObjectMeta ser) DeclareSerialized(ser);
+                else if (type is DelegateMeta del) DeclareDelegate(del);
                 else if (type is InstanceMeta it) DeclareInstance(it);
-                else if (type is SurfaceMeta srf) DeclareSurface(srf);
+                else if (type is SurfaceMeta srf) surfaces.Add(srf);
+        if (surfaces.Count == 0 && node.Children.Count == 0) return;
+        if (surfaces.Count > 0) doc.Type(surfaces[0]);
+        bld.Enter($"export namespace {node.Name} {{");
+        foreach (var surface in surfaces)
+            DeclareSurface(surface);
         foreach (var child in node.Children)
             DeclareNode(child);
-        if (wrap) bld.Exit("}");
+        bld.Exit("}");
     }
 
     private void DeclareEnum (SerializedEnumMeta enu)
@@ -77,7 +76,7 @@ private void DeclareEnum (SerializedEnumMeta enu)
     private void DeclareSerialized (SerializedObjectMeta obj)
     {
         doc.Type(obj);
-        var ext = spec.Types.HasBase(obj.Clr, out var bs) ? $"{ts.BuildFullName(bs.Clr)} & " : "";
+        var ext = spec.Types.HasBase(obj.Clr, out var bs) ? $"{ts.BuildRef(bs.Clr)} & " : "";
         bld.Enter($$"""export type {{ts.BuildName(obj.Clr)}} = {{ext}}Readonly<{""");
         foreach (var prop in obj.Properties.Where(p => ShouldDeclareOn(obj.Clr, p.Info)))
         {
@@ -98,25 +97,33 @@ private void DeclareDelegate (DelegateMeta del)
     private void DeclareInstance (InstanceMeta it)
     {
         doc.Type(it);
-        if (it.Proxy is SpecializedProxy { Decl: { } sp } && sp.StartsWith("export "))
-        {
-            bld.Line(sp);
-            return;
-        }
+        if (DeclareSpecialized(out var specialized)) return;
         bld.Enter($$"""export interface {{ts.BuildName(it.Clr)}}{{BuildExtensions()}} {""");
         foreach (var member in it.Members.Where(m => ShouldDeclareOn(it.Clr, m.Info)))
             if (member is EventMeta evt) DeclareEvent(evt);
             else if (member is PropertyMeta prop) DeclareProperty(prop);
             else if (member is MethodMeta method) DeclareMethod(method);
-        if (it.Proxy is SpecializedProxy { Decl: { } decl }) bld.Line(decl);
+        if (specialized != null) bld.Line(specialized);
         bld.Exit("}");
 
+        bool DeclareSpecialized (out string? decl)
+        {
+            if (string.IsNullOrEmpty(decl = (it.Proxy as SpecializedProxy)?.Decl)) return false;
+            decl = decl.Replace("$name", ts.BuildName(it.Clr)).Replace("$full", ts.BuildRef(it.Clr));
+            var args = (it.Proxy as SpecializedProxy)!.Import.Clr.GetGenericArguments();
+            for (var i = 0; i < args.Length; i++)
+                decl = decl.Replace($"$T{i}", ts.BuildRef(args[i]));
+            var replaces = decl.StartsWith("export ");
+            if (replaces) bld.Line(decl);
+            return replaces;
+        }
+
         string BuildExtensions ()
         {
             if (it.Proxy is SpecializedProxy) return ""; // specialized surfaces are self-contained
             var ext = it.Clr.GetInterfaces().Where(i => IsUserType(i) && spec.Types.Has(i)).ToList();
             if (spec.Types.HasBase(it.Clr, out var bs)) ext.Insert(0, bs.Clr);
-            return ext.Count == 0 ? "" : $" extends {string.Join(", ", ext.Select(ts.BuildFullName))}";
+            return ext.Count == 0 ? "" : $" extends {string.Join(", ", ext.Select(ts.BuildRef))}";
         }
 
         void DeclareEvent (EventMeta evt)

src/cs/Bootsharp.Publish/GenerateJS/Declarations/TypeSyntaxBuilder.cs

@@ -16,14 +16,14 @@ public void EnterModule (JSModule module)
 
     public string BuildName (Type type)
     {
-        var full = BuildFullName(type);
+        var full = BuildRef(OpenGeneric(type));
         var dotIdx = full.LastIndexOf('.');
         return dotIdx > 0 ? full[(dotIdx + 1)..] : full;
     }
 
-    public string BuildFullName (Type type)
+    public string BuildRef (Type type)
     {
-        return Build(OpenGeneric(type), null);
+        return Build(type, null);
     }
 
     public string BuildArg (ParameterInfo param)

src/cs/Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 
     <PropertyGroup>
-        <Version>0.9.0-alpha.21</Version>
+        <Version>0.9.0-alpha.28</Version>
         <Authors>Elringus</Authors>
         <PackageTags>javascript typescript ts js wasm node deno bun interop codegen</PackageTags>
         <PackageProjectUrl>https://bootsharp.com</PackageProjectUrl>

src/js/test/cs/Test.Library/Modules/BidirectionalCS.cs

@@ -5,7 +5,7 @@ namespace Test.Library;
 public class BidirectionalCS : IBidirectional
 {
     public event Action<IBidirectional?>? OnBiChanged;
-    public SpecialBiHandlerEvent OnSpecial { get; } = new();
+    public IBidirectional.SpecialEvent OnSpecial { get; } = new();
 
     public IBidirectional? Bi { get; set => NotifyChanged(field = value); } = null!;
 

src/js/test/cs/Test.Library/Modules/IBidirectional.cs

@@ -4,10 +4,29 @@ namespace Test.Library;
 
 public interface IBidirectional
 {
+    public delegate void SpecialHandler (IBidirectional? bi);
+    public sealed class SpecialEvent : Event<SpecialHandler>
+    {
+        public IBidirectional? Last { get; private set; }
+
+        public void Broadcast (IBidirectional? bi)
+        {
+            Last = bi;
+            foreach (var handler in Handlers)
+                handler(bi);
+        }
+
+        public override void Replay (SpecialHandler handler)
+        {
+            if (Last is { } last)
+                handler(last);
+        }
+    }
+
     event Action<IBidirectional?>? OnBiChanged;
 
     IBidirectional? Bi { get; set; }
-    SpecialBiHandlerEvent OnSpecial { get; }
+    SpecialEvent OnSpecial { get; }
 
     IBidirectional? EchoBi (IBidirectional? bi);
 }