@ttsc/wasm 0.15.5 → 0.15.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/wasm",
-  "version": "0.15.5",
+  "version": "0.15.6",
   "description": "Build in-browser ttsc playgrounds. Compose ttsc + typescript-go with your own plugins via the Go host helper.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -38,7 +38,7 @@
   "homepage": "https://ttsc.dev",
   "devDependencies": {
     "@types/node": "^25.3.0",
-    "@typescript/native-preview": "7.0.0-dev.20260616.1",
+    "@typescript/native-preview": "7.0.0-dev.20260617.2",
     "rimraf": "^6.1.2"
   },
   "scripts": {

package/shim-vendor/shim/checker/shim.go

@@ -225,3 +225,104 @@ func Checker_getMinArgumentCount(recv *innerchecker.Checker, signature *innerche
   }
   return checkerGetMinArgumentCount(recv, signature)
 }
+
+// Checker_getSignaturesOfType returns the call or construct signatures declared
+// on t, selected by kind (SignatureKindCall / SignatureKindConstruct). This is
+// the producer companion to Checker_getMinArgumentCount and
+// Checker_getReturnTypeOfSignature: without it the *Signature those two consume
+// could not be obtained. A type-transform plugin uses the construct signatures
+// of a class's constructor type to detect the `new C(x)` strategy and the call
+// signatures of a static `from` member to detect the `C.from(x)` strategy.
+// Returns nil if recv or t is nil.
+func Checker_getSignaturesOfType(recv *innerchecker.Checker, t *innerchecker.Type, kind innerchecker.SignatureKind) []*innerchecker.Signature {
+  if recv == nil || t == nil {
+    return nil
+  }
+  return recv.GetSignaturesOfType(t, kind)
+}
+
+// Checker_getReturnTypeOfSignature returns the return type of signature, used to
+// verify that a static `from(x)` factory actually returns the class instance
+// type before selecting the `C.from(x)` construction strategy. Returns nil if
+// recv or signature is nil.
+func Checker_getReturnTypeOfSignature(recv *innerchecker.Checker, signature *innerchecker.Signature) *innerchecker.Type {
+  if recv == nil || signature == nil {
+    return nil
+  }
+  return recv.GetReturnTypeOfSignature(signature)
+}
+
+// Signature_parameterCount returns the number of declared value parameters of a
+// call/construct signature. A rest parameter counts as one and the `this`
+// parameter is excluded (it is held separately from the value parameters).
+//
+// Checker_getMinArgumentCount alone cannot tell a zero-parameter signature
+// (`()` — minimum 0) from a single-optional-parameter one (`(x?)` — also
+// minimum 0). A type-transform plugin needs that distinction to replicate the
+// type-level "single meaningful argument" rule — a FIRST parameter must exist
+// and every later parameter must be optional or rest — as
+// `Signature_parameterCount(sig) >= 1 && Checker_getMinArgumentCount(c, sig) <= 1`.
+// Without it the `new C(x)` / `C.from(x)` strategies silently fall back to field
+// copy for every optional-first constructor or factory. Returns 0 if signature
+// is nil.
+func Signature_parameterCount(signature *innerchecker.Signature) int {
+  if signature == nil {
+    return 0
+  }
+  return len(signature.Parameters())
+}
+
+// Signature_parameters returns the declared value-parameter symbols of a
+// call/construct signature, in declaration order, excluding the synthetic
+// `this` parameter. The first element is the seed parameter of a `new C(seed)`
+// constructor or a `C.from(seed)` factory; feeding it to Checker_getTypeOfSymbol
+// yields the seed TYPE the plugin must decode before constructing the instance.
+//
+// Signature_parameterCount is len() of this slice; the slice itself is needed
+// because detection (count + min-args) is not enough — emission requires the
+// seed parameter's type. Returns nil if signature is nil.
+func Signature_parameters(signature *innerchecker.Signature) []*innerast.Symbol {
+  if signature == nil {
+    return nil
+  }
+  return signature.Parameters()
+}
+
+// Signature_hasRestParameter reports whether the signature's last value
+// parameter is a rest parameter (`...xs: S[]`). It is the signal a from/new
+// transform needs to tell a rest-only single-seed call `(...xs: S[])` — whose
+// seed is the ELEMENT S — from a genuine array-typed parameter `(seed: S[])` —
+// whose seed is the array S[]: getTypeOfSymbol yields `S[]` for BOTH, so without
+// this flag they are indistinguishable and the rest case decodes the wrong
+// shape.
+//
+// The rest ELEMENT is the seed ONLY when the rest parameter is the sole value
+// parameter, i.e. `Signature_hasRestParameter(sig) && Signature_parameterCount(sig) == 1`.
+// A leading-required + rest-tail signature `(s: S, ...r: R[])` also has a rest
+// parameter (this returns true), but its seed is the FIRST parameter S — read it
+// from Signature_parameters(sig)[0], NOT the rest element — matching
+// ClassifiableSeed, whose `[infer P, ...Rest]` arm picks P=S there. Returns
+// false if signature is nil.
+func Signature_hasRestParameter(signature *innerchecker.Signature) bool {
+  if signature == nil {
+    return false
+  }
+  return signature.HasRestParameter()
+}
+
+// Checker_getRestTypeOfSignature returns the ELEMENT type of the signature's
+// rest parameter (`...xs: S[]` -> S; a tuple rest unwraps to its element too),
+// which is the seed type for a rest-ONLY single-argument constructor/factory —
+// matching ClassifiableSeed, which unwraps the rest to its element. When the
+// signature has NO rest parameter it falls back to `any` upstream; and a
+// leading-required + rest-tail `(s: S, ...r: R[])` has a rest parameter yet its
+// seed is the FIRST parameter S, not the rest element. So take the rest element
+// only when `Signature_hasRestParameter(sig) && Signature_parameterCount(sig) == 1`;
+// otherwise read Signature_parameters(sig)[0]. Returns nil if recv or signature
+// is nil.
+func Checker_getRestTypeOfSignature(recv *innerchecker.Checker, signature *innerchecker.Signature) *innerchecker.Type {
+  if recv == nil || signature == nil {
+    return nil
+  }
+  return recv.GetRestTypeOfSignature(signature)
+}

package/shim-vendor/shim/checker/signature_api_completeness.go

@@ -0,0 +1,58 @@
+package checker
+
+// Compile-time guard: the signature-introspection surface that typia's
+// plain.classify from/new construction-strategy detection depends on must
+// compose end-to-end through the shim.
+//
+// 0.15.5 exposed a CONSUMER of a *Signature (Checker_getMinArgumentCount)
+// without the PRODUCER that yields one (Checker_getSignaturesOfType): a
+// *Signature was nameable (the `Signature` alias) but unobtainable. The closure
+// auditor checks that every escaping type can be NAMED, not that it can be
+// PRODUCED, so it did not catch the gap and the feature stayed blocked.
+//
+// This lives in a NORMAL (non-_test) file on purpose. The shim/checker package
+// is a nested Go module that no CI job runs `go test` against, so a _test.go
+// guard would never be compiled and would silently stop guarding. As ordinary
+// package code it is type-checked by every build that links the shim (typia's
+// native plugin, ttsc's lint engine), so dropping or renaming any leg below
+// turns those builds red. It never runs (assigned to blank, never called).
+var _ = func(c *Checker, instanceType *Type) {
+  // class instance type -> class symbol -> constructor (static) type, which
+  // carries both the construct signatures and the static `from` member.
+  classSymbol := Type_getTypeNameSymbol(instanceType)
+  ctorType := Checker_getTypeOfSymbol(c, classSymbol)
+
+  // `new C(seed)` strategy: construct signatures -> arity (min args +
+  // parameter count, together disambiguating `()` from `(x?)`) -> return type
+  // -> the seed parameter's type. The seed is Signature_parameters[0]'s type,
+  // EXCEPT a rest-ONLY parameter `(...xs: S[])` — when
+  // `hasRestParameter && parameterCount == 1` — whose seed is the rest ELEMENT
+  // (getRestTypeOfSignature). A leading-required + rest-tail `(s, ...r)` still
+  // has hasRestParameter true but its seed is the first parameter S.
+  for _, sig := range Checker_getSignaturesOfType(c, ctorType, SignatureKindConstruct) {
+    _ = Checker_getMinArgumentCount(c, sig)
+    _ = Signature_parameterCount(sig)
+    _ = Checker_getReturnTypeOfSignature(c, sig)
+    if Signature_hasRestParameter(sig) {
+      _ = Checker_getRestTypeOfSignature(c, sig)
+    }
+    for _, p := range Signature_parameters(sig) {
+      _ = Checker_getTypeOfSymbol(c, p)
+    }
+  }
+
+  // `C.from(seed)` strategy: static `from` member -> its call signatures, read
+  // identically (arity, return type, seed parameter / rest element type).
+  fromType := Checker_getTypeOfPropertyOfType(c, ctorType, "from")
+  for _, sig := range Checker_getSignaturesOfType(c, fromType, SignatureKindCall) {
+    _ = Checker_getMinArgumentCount(c, sig)
+    _ = Signature_parameterCount(sig)
+    _ = Checker_getReturnTypeOfSignature(c, sig)
+    if Signature_hasRestParameter(sig) {
+      _ = Checker_getRestTypeOfSignature(c, sig)
+    }
+    for _, p := range Signature_parameters(sig) {
+      _ = Checker_getTypeOfSymbol(c, p)
+    }
+  }
+}