@ttsc/wasm 0.12.2 → 0.12.4

package/shim-vendor/shim/ast/safe_text.go

@@ -0,0 +1,86 @@
+// gen_shims:hand-maintained
+//
+// Total-function replacement for upstream `(*Node).Text()`.
+//
+// Upstream panics for any Kind missing from its switch — most notably
+// KindQualifiedName, which surfaces in JSDoc parameter names (`@param
+// obj.field`) and dotted entity references. NodeText handles
+// QualifiedName by recursing on the left subtree and joining with the
+// right identifier, and falls back to the source-text slice for any
+// other Kind so downstream code can treat the helper as a total
+// function over *Node instead of guarding each call site.
+
+package ast
+
+import (
+  "strings"
+
+  innerast "github.com/microsoft/typescript-go/internal/ast"
+)
+
+// NodeText returns the identifier-like text of a node. It mirrors
+// upstream `(*Node).Text()` where upstream has an arm, adds a
+// QualifiedName arm that joins `left.right`, and falls back to the
+// node's source slice for any other Kind. Returns "" for nil.
+func NodeText(n *Node) string {
+  if n == nil {
+    return ""
+  }
+  switch n.Kind {
+  case KindIdentifier,
+    innerast.KindPrivateIdentifier,
+    KindStringLiteral,
+    KindNumericLiteral,
+    KindBigIntLiteral,
+    KindNoSubstitutionTemplateLiteral,
+    KindTemplateHead,
+    KindTemplateMiddle,
+    KindTemplateTail,
+    innerast.KindRegularExpressionLiteral,
+    innerast.KindJsxNamespacedName,
+    innerast.KindJSDocText,
+    innerast.KindJSDocLink,
+    innerast.KindJSDocLinkCode,
+    innerast.KindJSDocLinkPlain,
+    innerast.KindMetaProperty:
+    return n.Text()
+  case KindQualifiedName:
+    qn := n.AsQualifiedName()
+    if qn == nil {
+      return ""
+    }
+    left := NodeText(qn.Left)
+    right := ""
+    if qn.Right != nil {
+      right = qn.Right.Text()
+    }
+    switch {
+    case left == "" && right == "":
+      return ""
+    case left == "":
+      return right
+    case right == "":
+      return left
+    default:
+      return left + "." + right
+    }
+  }
+  return nodeSourceText(n)
+}
+
+// nodeSourceText returns the verbatim source slice covered by the node's
+// position range, trimmed of surrounding whitespace. Same byte range
+// scanner.GetTextOfNode would read; safe for any Kind because it does
+// not inspect per-Kind data fields.
+func nodeSourceText(n *innerast.Node) string {
+  file := innerast.GetSourceFileOfNode(n)
+  if file == nil {
+    return ""
+  }
+  text := file.Text()
+  pos, end := n.Pos(), n.End()
+  if pos < 0 || end > len(text) || pos >= end {
+    return ""
+  }
+  return strings.TrimSpace(text[pos:end])
+}

package/shim-vendor/shim/ast/shim.go

@@ -177,44 +177,68 @@ const (
   ModifierFlagsReadonly  = innerast.ModifierFlagsReadonly
 )
 
+// NewNodeFactory creates an AST node factory with the supplied creation hooks.
+// Pass a zero-value NodeFactoryHooks to get the default factory behaviour.
 func NewNodeFactory(options NodeFactoryHooks) *NodeFactory {
   return innerast.NewNodeFactory(options)
 }
 
+// NewNodeVisitor creates a visitor that calls visit for each node encountered
+// during a tree walk, delegating node recreation to factory using hooks.
 func NewNodeVisitor(visit func(node *Node) *Node, factory *NodeFactory, options NodeVisitorHooks) *NodeVisitor {
   return innerast.NewNodeVisitor(visit, factory, options)
 }
 
+// IsFunctionLike reports whether node is any function-like construct
+// (function declaration, arrow function, method, constructor, accessor, etc.).
 func IsFunctionLike(node *Node) bool {
   return innerast.IsFunctionLike(node)
 }
 
+// IsPropertyAssignment reports whether node is a key:value pair inside an
+// object literal expression.
 func IsPropertyAssignment(node *Node) bool {
   return innerast.IsPropertyAssignment(node)
 }
 
+// IsPropertyDeclaration reports whether node is a class property declaration.
 func IsPropertyDeclaration(node *Node) bool {
   return innerast.IsPropertyDeclaration(node)
 }
 
+// IsModuleBlock reports whether node is the body block of a namespace or
+// module declaration.
 func IsModuleBlock(node *Node) bool {
   return innerast.IsModuleBlock(node)
 }
 
+// IsStringLiteral reports whether node is a string literal token.
 func IsStringLiteral(node *Node) bool {
   return innerast.IsStringLiteral(node)
 }
 
+// IsPropertyAccessExpression reports whether node is a dotted member access
+// (e.g. `a.b`).
 func IsPropertyAccessExpression(node *Node) bool {
   return innerast.IsPropertyAccessExpression(node)
 }
 
+// IsElementAccessExpression reports whether node is a bracket member access
+// (e.g. `a[b]`).
 func IsElementAccessExpression(node *Node) bool {
   return innerast.IsElementAccessExpression(node)
 }
 
+// GetSourceFileOfNode walks up the parent chain to return the SourceFile that
+// owns the given node. Linked from the internal package via go:linkname because
+// the function is unexported there.
+//
 //go:linkname GetSourceFileOfNode github.com/microsoft/typescript-go/internal/ast.GetSourceFileOfNode
 func GetSourceFileOfNode(node *innerast.Node) *innerast.SourceFile
 
+// GetNodeAtPosition returns the deepest AST node whose range covers position
+// in file. When includeJSDoc is true the search descends into JSDoc sub-trees.
+// Linked from the internal package via go:linkname.
+//
 //go:linkname GetNodeAtPosition github.com/microsoft/typescript-go/internal/ast.GetNodeAtPosition
 func GetNodeAtPosition(file *innerast.SourceFile, position int, includeJSDoc bool) *innerast.Node

package/shim-vendor/shim/ast/test/node_text_joins_multi_hop_qualified_name_test.go

@@ -0,0 +1,32 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextJoinsMultiHopQualifiedName verifies NodeText joins a
+// multi-hop QualifiedName as "A.B.C".
+//
+// Locks the recursion in the QualifiedName arm. QualifiedName.Left is an
+// *EntityName (Identifier OR QualifiedName), so a non-recursive
+// implementation would silently drop everything but the final two
+// segments — breaking dotted references like
+// `IShoppingCoupon.IDirection.Inner` that show up in real-world JSDoc
+// and type-argument positions.
+//
+// 1. Construct A.B then ((A.B).C) via NewQualifiedName.
+// 2. Call NodeText on the outer node.
+// 3. Assert the result is "A.B.C".
+func TestNodeTextJoinsMultiHopQualifiedName(t *testing.T) {
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  a := factory.NewIdentifier("A")
+  b := factory.NewIdentifier("B")
+  c := factory.NewIdentifier("C")
+  ab := factory.NewQualifiedName(a, b)
+  abc := factory.NewQualifiedName(ab, c)
+  if got := shimast.NodeText(abc); got != "A.B.C" {
+    t.Fatalf("NodeText(A.B.C) = %q, want %q", got, "A.B.C")
+  }
+}

package/shim-vendor/shim/ast/test/node_text_joins_one_hop_qualified_name_test.go

@@ -0,0 +1,31 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextJoinsOneHopQualifiedName verifies NodeText joins a one-hop
+// QualifiedName as "left.right".
+//
+// Locks the QualifiedName arm that upstream lacks: upstream's
+// (*Node).Text() panics with `Unhandled case in Node.Text:
+// *ast.QualifiedName` because the switch has no arm for the Kind. typia's
+// metadata_js_doc_parameter_name calls Text() on a JSDoc tag's Name()
+// which is a QualifiedName for `@param obj.field description`, so the
+// panic surfaces inside the nestia/typia build pipeline. NodeText must
+// turn a `Foo.Bar` qualified name into the dotted string.
+//
+// 1. Construct Foo.Bar via NewQualifiedName(Foo, Bar).
+// 2. Call NodeText on the qualified node.
+// 3. Assert the result is "Foo.Bar".
+func TestNodeTextJoinsOneHopQualifiedName(t *testing.T) {
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  left := factory.NewIdentifier("Foo")
+  right := factory.NewIdentifier("Bar")
+  qn := factory.NewQualifiedName(left, right)
+  if got := shimast.NodeText(qn); got != "Foo.Bar" {
+    t.Fatalf("NodeText(Foo.Bar) = %q, want %q", got, "Foo.Bar")
+  }
+}

package/shim-vendor/shim/ast/test/node_text_returns_empty_for_nil_test.go

@@ -0,0 +1,23 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextReturnsEmptyForNil verifies NodeText returns "" for a nil node.
+//
+// Locks the nil-guard at the top of NodeText. The helper is a total function
+// over *Node — typia's JSDoc parameter-name extractor calls it without
+// checking — so a nil-deref here would be a behaviour change for every
+// caller. The empty-string contract is the only signal that lets callers
+// skip "no parameter name" entries cleanly.
+//
+// 1. Call NodeText(nil).
+// 2. Assert the result is "".
+func TestNodeTextReturnsEmptyForNil(t *testing.T) {
+  if got := shimast.NodeText(nil); got != "" {
+    t.Fatalf("NodeText(nil) = %q, want %q", got, "")
+  }
+}

package/shim-vendor/shim/ast/test/node_text_returns_identifier_text_test.go

@@ -0,0 +1,27 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextReturnsIdentifierText verifies NodeText returns the
+// identifier text when the node Kind already has an upstream Text() arm.
+//
+// Covers the delegated branch: for Kinds upstream supports (Identifier,
+// StringLiteral, template parts, …), NodeText must forward to the
+// upstream method verbatim. Falling back to the source slice would
+// return "" for synthesised nodes that have no source range, breaking
+// every factory-built tree we hand to the typia metadata factory.
+//
+// 1. Construct a synthesised Identifier via NewIdentifier("Foo").
+// 2. Call NodeText on it.
+// 3. Assert the result is "Foo".
+func TestNodeTextReturnsIdentifierText(t *testing.T) {
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  id := factory.NewIdentifier("Foo")
+  if got := shimast.NodeText(id); got != "Foo" {
+    t.Fatalf("NodeText(Identifier) = %q, want %q", got, "Foo")
+  }
+}

package/shim-vendor/shim/ast/test/node_text_skips_empty_qualified_left_test.go

@@ -0,0 +1,30 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextSkipsEmptyQualifiedLeft verifies NodeText does not emit a
+// stray leading "." when the left segment of a QualifiedName resolves
+// to the empty string.
+//
+// Parser recovery (and synthesised trees) can produce a QualifiedName
+// whose Left identifier carries empty text. A naive `left + "." + right`
+// concatenation would yield `.Inner`, which downstream code (the typia
+// metadata factory uses this as a map key) would treat as a distinct
+// parameter name. The arm has to drop the empty segment instead.
+//
+// 1. Build a QualifiedName whose Left is an Identifier created with "".
+// 2. Call NodeText on the qualified node.
+// 3. Assert the result is the right-hand text with no leading dot.
+func TestNodeTextSkipsEmptyQualifiedLeft(t *testing.T) {
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  left := factory.NewIdentifier("")
+  right := factory.NewIdentifier("Inner")
+  qn := factory.NewQualifiedName(left, right)
+  if got := shimast.NodeText(qn); got != "Inner" {
+    t.Fatalf("NodeText(<empty>.Inner) = %q, want %q", got, "Inner")
+  }
+}

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

@@ -59,34 +59,50 @@ const (
   ElementFlagsVariadic = innerchecker.ElementFlagsVariadic
 )
 
+// IsTupleType reports whether t is a fixed-length tuple type.
 func IsTupleType(t *innerchecker.Type) bool {
   return innerchecker.IsTupleType(t)
 }
 
+// Checker_getIndexInfosOfType returns the index signatures (string/number/symbol
+// index infos) declared on t.
 func Checker_getIndexInfosOfType(recv *innerchecker.Checker, t *innerchecker.Type) []*innerchecker.IndexInfo {
   return recv.GetIndexInfosOfType(t)
 }
 
+// Checker_getPropertiesOfType returns the named property symbols of t. For
+// union and intersection types this is the set of properties visible on every
+// member.
 func Checker_getPropertiesOfType(recv *innerchecker.Checker, t *innerchecker.Type) []*innerast.Symbol {
   return recv.GetPropertiesOfType(t)
 }
 
+// Checker_getApparentProperties returns the properties visible on t after
+// resolving primitive wrapper types (e.g. string → String).
 func Checker_getApparentProperties(recv *innerchecker.Checker, t *innerchecker.Type) []*innerast.Symbol {
   return recv.GetApparentProperties(t)
 }
 
+// Checker_getTypeArguments returns the type arguments of a generic reference
+// type, or nil when t is not a reference.
 func Checker_getTypeArguments(recv *innerchecker.Checker, t *innerchecker.Type) []*innerchecker.Type {
   return recv.GetTypeArguments(t)
 }
 
+// Checker_getTypeOfSymbol returns the declared type of symbol, resolving
+// aliases and following late-bound types.
 func Checker_getTypeOfSymbol(recv *innerchecker.Checker, symbol *innerast.Symbol) *innerchecker.Type {
   return recv.GetTypeOfSymbol(symbol)
 }
 
+// Checker_getTypeOfSymbolAtLocation returns the contextual type of symbol as
+// observed at the given AST node (useful for narrowed types in control flow).
 func Checker_getTypeOfSymbolAtLocation(recv *innerchecker.Checker, symbol *innerast.Symbol, node *innerast.Node) *innerchecker.Type {
   return recv.GetTypeOfSymbolAtLocation(symbol, node)
 }
 
+// Checker_getTypeOfPropertyOfType looks up the type of the named property on t
+// and returns nil when no such property exists.
 func Checker_getTypeOfPropertyOfType(recv *innerchecker.Checker, t *innerchecker.Type, name string) *innerchecker.Type {
   return recv.GetTypeOfPropertyOfType(t, name)
 }
@@ -94,6 +110,8 @@ func Checker_getTypeOfPropertyOfType(recv *innerchecker.Checker, t *innerchecker
 //go:linkname checkerGetAliasSymbolForTypeNode github.com/microsoft/typescript-go/internal/checker.(*Checker).getAliasSymbolForTypeNode
 func checkerGetAliasSymbolForTypeNode(recv *innerchecker.Checker, node *innerast.Node) *innerast.Symbol
 
+// Checker_getAliasSymbolForTypeNode returns the alias symbol that a type node
+// refers to when the node is itself a type alias reference (e.g. `type Foo = ...`).
 func Checker_getAliasSymbolForTypeNode(recv *innerchecker.Checker, node *innerast.Node) *innerast.Symbol {
   return checkerGetAliasSymbolForTypeNode(recv, node)
 }
@@ -101,6 +119,8 @@ func Checker_getAliasSymbolForTypeNode(recv *innerchecker.Checker, node *inneras
 //go:linkname checkerGetDeclarationOfAliasSymbol github.com/microsoft/typescript-go/internal/checker.(*Checker).getDeclarationOfAliasSymbol
 func checkerGetDeclarationOfAliasSymbol(recv *innerchecker.Checker, symbol *innerast.Symbol) *innerast.Node
 
+// Checker_getDeclarationOfAliasSymbol resolves an import/export alias symbol to
+// its original declaration node.
 func Checker_getDeclarationOfAliasSymbol(recv *innerchecker.Checker, symbol *innerast.Symbol) *innerast.Node {
   return checkerGetDeclarationOfAliasSymbol(recv, symbol)
 }
@@ -108,6 +128,8 @@ func Checker_getDeclarationOfAliasSymbol(recv *innerchecker.Checker, symbol *inn
 //go:linkname checkerGetTargetOfImportSpecifier github.com/microsoft/typescript-go/internal/checker.(*Checker).getTargetOfImportSpecifier
 func checkerGetTargetOfImportSpecifier(recv *innerchecker.Checker, node *innerast.Node) *innerast.Symbol
 
+// Checker_getTargetOfImportSpecifier resolves an import specifier node to the
+// exported symbol it binds. Returns nil if recv or node is nil.
 func Checker_getTargetOfImportSpecifier(recv *innerchecker.Checker, node *innerast.Node) *innerast.Symbol {
   if recv == nil || node == nil {
     return nil
@@ -115,6 +137,8 @@ func Checker_getTargetOfImportSpecifier(recv *innerchecker.Checker, node *innera
   return checkerGetTargetOfImportSpecifier(recv, node)
 }
 
+// Checker_getAliasedSymbol follows an alias chain to its final target symbol.
+// Returns nil if recv or symbol is nil.
 func Checker_getAliasedSymbol(recv *innerchecker.Checker, symbol *innerast.Symbol) *innerast.Symbol {
   if recv == nil || symbol == nil {
     return nil
@@ -132,6 +156,11 @@ func checkerResolveEntityName(
   location *innerast.Node,
 ) *innerast.Symbol
 
+// Checker_resolveEntityName resolves a dotted entity name (identifier or
+// qualified name) to the symbol it denotes, filtered by meaning flags.
+// When ignoreErrors is true, resolution failures are silent. When
+// dontResolveAlias is true, the returned symbol may still be an alias.
+// Returns nil if recv or name is nil.
 func Checker_resolveEntityName(
   recv *innerchecker.Checker,
   name *innerast.Node,
@@ -149,6 +178,9 @@ func Checker_resolveEntityName(
 //go:linkname checkerGetTypeNameSymbol github.com/microsoft/typescript-go/internal/checker.getTypeNameSymbol
 func checkerGetTypeNameSymbol(t *innerchecker.Type) *innerast.Symbol
 
+// Type_getTypeNameSymbol returns the symbol attached to t's type name field,
+// or nil when t has no name symbol or t is nil. Linked via go:linkname because
+// getTypeNameSymbol is a package-level unexported function in the checker.
 func Type_getTypeNameSymbol(t *innerchecker.Type) *innerast.Symbol {
   if t == nil {
     return nil
@@ -159,6 +191,7 @@ func Type_getTypeNameSymbol(t *innerchecker.Type) *innerast.Symbol {
 //go:linkname checkerIsArrayType github.com/microsoft/typescript-go/internal/checker.(*Checker).isArrayType
 func checkerIsArrayType(recv *innerchecker.Checker, t *innerchecker.Type) bool
 
+// Checker_isArrayType reports whether t is the built-in Array<T> reference type.
 func Checker_isArrayType(recv *innerchecker.Checker, t *innerchecker.Type) bool {
   return checkerIsArrayType(recv, t)
 }
@@ -166,6 +199,8 @@ func Checker_isArrayType(recv *innerchecker.Checker, t *innerchecker.Type) bool
 //go:linkname checkerGetBaseTypes github.com/microsoft/typescript-go/internal/checker.(*Checker).getBaseTypes
 func checkerGetBaseTypes(recv *innerchecker.Checker, t *innerchecker.Type) []*innerchecker.Type
 
+// Checker_getBaseTypes returns the list of base types (from `extends` clauses)
+// for a class or interface type. Returns nil if recv or t is nil.
 func Checker_getBaseTypes(recv *innerchecker.Checker, t *innerchecker.Type) []*innerchecker.Type {
   if recv == nil || t == nil {
     return nil

package/shim-vendor/shim/core/shim.go

@@ -1,17 +1,34 @@
+// Package core re-exports the subset of typescript-go's internal/core types
+// and constants that plugins and the ttsc driver need. It provides compiler
+// options, script-kind discrimination, tri-state booleans, and text-range
+// primitives without exposing the full internal surface.
 package core
 
 import innercore "github.com/microsoft/typescript-go/internal/core"
 
+// CompilerOptions holds the parsed tsconfig compiler options passed to the
+// TypeScript-Go program host.
 type CompilerOptions = innercore.CompilerOptions
+
+// Tristate is a three-valued boolean: TSFalse, TSTrue, or TSUnknown. Used by
+// CompilerOptions fields that can be explicitly unset.
 type Tristate = innercore.Tristate
+
+// TextPos is a zero-based byte offset into a source file's text.
 type TextPos = innercore.TextPos
+
+// TextRange is a half-open [Pos, End) byte range inside a source file.
 type TextRange = innercore.TextRange
+
+// ScriptKind identifies the syntactic flavour of a source file.
 type ScriptKind = innercore.ScriptKind
 
 const (
+  // TSFalse and TSTrue are the explicit-false and explicit-true Tristate values.
   TSFalse = innercore.TSFalse
   TSTrue  = innercore.TSTrue
 
+  // ScriptKind* constants enumerate the file flavours typescript-go recognises.
   ScriptKindUnknown  = innercore.ScriptKindUnknown
   ScriptKindJS       = innercore.ScriptKindJS
   ScriptKindJSX      = innercore.ScriptKindJSX

package/shim-vendor/shim/diagnosticwriter/shim.go

@@ -1,3 +1,7 @@
+// Package diagnosticwriter re-exports the subset of typescript-go's
+// internal/diagnosticwriter surface that the ttsc driver uses. It provides
+// FormatASTDiagnosticsWithColorAndContext for rendering pure tsgo diagnostics
+// and delegates the mixed lint+tsgo rendering path to the adjacent lint.go.
 package diagnosticwriter
 
 import (

package/shim-vendor/shim/lsp/shim.go

@@ -8,10 +8,10 @@
 package lsp
 
 import (
-	"io"
-	_ "unsafe"
+  "io"
+  _ "unsafe"
 
-	innerlsp "github.com/microsoft/typescript-go/internal/lsp"
+  innerlsp "github.com/microsoft/typescript-go/internal/lsp"
 )
 
 // Server is the opaque LSP server type from tsgo.

package/shim-vendor/shim/printer/shim.go

@@ -1,3 +1,7 @@
+// Package printer re-exports the typescript-go internal/printer types and
+// wraps the three functions that the ttsc driver and transform plugins need
+// to emit source text from an AST. The surface is intentionally narrow: only
+// the construction and single-file emit path are exposed.
 package printer
 
 import (
@@ -5,19 +9,35 @@ import (
   innerprinter "github.com/microsoft/typescript-go/internal/printer"
 )
 
+// PrintHandlers provides optional hooks (e.g. substituteNode) called during
+// AST emission.
 type PrintHandlers = innerprinter.PrintHandlers
+
+// Printer holds the stateful emitter produced by NewPrinter.
 type Printer = innerprinter.Printer
+
+// PrinterOptions configures newline style, source-map generation, and other
+// emission knobs.
 type PrinterOptions = innerprinter.PrinterOptions
+
+// EmitContext accumulates per-emit metadata (source maps, comment positions)
+// and must be created fresh for each emit round via NewEmitContext.
 type EmitContext = innerprinter.EmitContext
 
+// NewPrinter creates an emitter with the supplied options, substitution hooks,
+// and emit context. Callers must pass the same EmitContext to all operations
+// in a single emit round.
 func NewPrinter(options PrinterOptions, handlers PrintHandlers, emitContext *EmitContext) *Printer {
   return innerprinter.NewPrinter(options, handlers, emitContext)
 }
 
+// NewEmitContext allocates a fresh EmitContext for a new emit round.
 func NewEmitContext() *EmitContext {
   return innerprinter.NewEmitContext()
 }
 
+// EmitSourceFile renders the full source file through the printer and returns
+// the emitted text.
 func EmitSourceFile(p *Printer, sourceFile *ast.SourceFile) string {
   return p.EmitSourceFile(sourceFile)
 }