goscript 0.0.21 → 0.0.23

package/compiler/type-assert.go

@@ -0,0 +1,209 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"strings"
+)
+
+// writeTypeAssert handles the Go type assertion with comma-ok idiom in an
+// assignment context: `value, ok := interfaceExpr.(AssertedType)` (or with `=`).
+// It translates this to a TypeScript destructuring assignment (or declaration if `tok`
+// is `token.DEFINE` for `:=`) using the `$.typeAssert` runtime helper.
+//
+// The generated TypeScript is:
+// `[let] { value: valueName, ok: okName } = $.typeAssert<AssertedType_ts>(interfaceExpr_ts, 'AssertedTypeName');`
+//
+//   - `AssertedType_ts` is the TypeScript translation of `AssertedType`.
+//   - `interfaceExpr_ts` is the TypeScript translation of `interfaceExpr`.
+//   - `'AssertedTypeName'` is a string representation of the asserted type name,
+//     obtained via `getTypeNameString`, used for runtime error messages.
+//   - `valueName` and `okName` are the Go variable names from the LHS.
+//   - Blank identifiers (`_`) on the LHS are handled by omitting the corresponding
+//     property in the destructuring pattern (e.g., `{ ok: okName } = ...` if `value` is blank).
+//   - If `tok` is not `token.DEFINE` (i.e., for regular assignment `=`), the entire
+//     destructuring assignment is wrapped in parentheses `(...)` to make it a valid
+//     expression if needed, though typically assignments are statements.
+//
+// The statement is terminated with a newline.
+func (c *GoToTSCompiler) writeTypeAssert(lhs []ast.Expr, typeAssertExpr *ast.TypeAssertExpr, tok token.Token) error {
+	interfaceExpr := typeAssertExpr.X
+	assertedType := typeAssertExpr.Type
+
+	// Unwrap parenthesized expressions to handle cases like r.((<-chan T))
+	for {
+		if parenExpr, ok := assertedType.(*ast.ParenExpr); ok {
+			assertedType = parenExpr.X
+		} else {
+			break
+		}
+	}
+
+	// Ensure LHS has exactly two expressions (value and ok)
+	if len(lhs) != 2 {
+		return fmt.Errorf("type assertion assignment requires exactly 2 variables on LHS, got %d", len(lhs))
+	}
+
+	var okIsBlank bool
+	var okName string
+
+	okExpr := lhs[1]
+	okIdent, ok := okExpr.(*ast.Ident)
+	if !ok {
+		return fmt.Errorf("ok expression is not an identifier: %T", okExpr)
+	}
+	okIsBlank = okIdent.Name == "_"
+	okName = okIdent.Name
+
+	valueExpr := lhs[0]
+
+	// Determine if 'ok' variable is new in 'tok == token.DEFINE' context.
+	// This uses types.Info.Defs to see if the identifier is defined by this statement.
+	var okIsNewInDefine bool
+	if tok == token.DEFINE && !okIsBlank {
+		if c.pkg.TypesInfo.Defs[okIdent] != nil {
+			okIsNewInDefine = true
+		}
+	}
+
+	switch vLHS := valueExpr.(type) {
+	case *ast.Ident:
+		var valueIsBlank bool
+		var valueName string
+		valueIdent := vLHS
+		valueIsBlank = (valueIdent.Name == "_")
+		valueName = valueIdent.Name
+
+		var valueIsNewInDefine bool
+		if tok == token.DEFINE && !valueIsBlank {
+			if c.pkg.TypesInfo.Defs[valueIdent] != nil { // valueIdent is defined by this statement
+				valueIsNewInDefine = true
+			}
+		}
+
+		writeEndParen := false  // For wrapping assignment in parens to make it an expression
+		letDestructure := false // True if 'let { value: v, ok: o } = ...' is appropriate
+
+		if tok == token.DEFINE {
+			anyNewVars := (valueIsNewInDefine && !valueIsBlank) || (okIsNewInDefine && !okIsBlank)
+			// allVarsNewOrBlank means suitable for a single `let {v,o} = ...` destructuring
+			allVarsNewOrBlank := (valueIsBlank || valueIsNewInDefine) && (okIsBlank || okIsNewInDefine)
+
+			if allVarsNewOrBlank && anyNewVars {
+				letDestructure = true
+			} else if anyNewVars { // Mixed: some new, some existing. Declare new ones separately.
+				if !valueIsBlank && valueIsNewInDefine {
+					c.tsw.WriteLiterally("let ")
+					c.tsw.WriteLiterally(valueName)
+					c.tsw.WriteLiterally(": ")
+					c.WriteTypeExpr(assertedType) // Use WriteTypeExpr for TS type annotation
+					c.tsw.WriteLine("")
+				}
+				if !okIsBlank && okIsNewInDefine {
+					c.tsw.WriteLiterally("let ")
+					c.tsw.WriteLiterally(okName)
+					c.tsw.WriteLiterally(": boolean")
+					c.tsw.WriteLine("")
+				}
+				c.tsw.WriteLiterally("(") // Parenthesize the assignment part
+				writeEndParen = true
+			} else { // All variables exist
+				c.tsw.WriteLiterally("(")
+				writeEndParen = true
+			}
+		} else { // tok == token.ASSIGN
+			c.tsw.WriteLiterally("(")
+			writeEndParen = true
+		}
+
+		if letDestructure {
+			c.tsw.WriteLiterally("let ")
+		}
+
+		// Write the destructuring part: { value: v, ok: o }
+		c.tsw.WriteLiterally("{ ")
+		parts := []string{}
+		if !valueIsBlank {
+			parts = append(parts, fmt.Sprintf("value: %s", valueName))
+		}
+		if !okIsBlank {
+			parts = append(parts, fmt.Sprintf("ok: %s", okName))
+		}
+		c.tsw.WriteLiterally(strings.Join(parts, ", "))
+		c.tsw.WriteLiterally(" } = $.typeAssert<")
+		c.WriteTypeExpr(assertedType) // Generic: <AssertedTypeTS>
+		c.tsw.WriteLiterally(">(")
+		if err := c.WriteValueExpr(interfaceExpr); err != nil { // Arg1: interfaceExpr
+			return fmt.Errorf("failed to write interface expression in type assertion call: %w", err)
+		}
+		c.tsw.WriteLiterally(", ")
+		c.writeTypeDescription(assertedType) // Arg2: type info for runtime
+		c.tsw.WriteLiterally(")")
+
+		if writeEndParen {
+			c.tsw.WriteLiterally(")")
+		}
+		c.tsw.WriteLine("")
+
+	case *ast.SelectorExpr:
+		// Handle s.field, ok := expr.(Type)
+		tempValName := "_gs_ta_val_" // Fixed name for temporary value
+		tempOkName := "_gs_ta_ok_"   // Fixed name for temporary ok status
+
+		// Declare temporary variables:
+		// let _gs_ta_val_: AssertedTypeTS;
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally(tempValName)
+		c.tsw.WriteLiterally(": ")
+		c.WriteTypeExpr(assertedType) // TypeScript type for assertedType
+		c.tsw.WriteLine("")
+
+		// let _gs_ta_ok_: boolean;
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally(tempOkName)
+		c.tsw.WriteLiterally(": boolean")
+		c.tsw.WriteLine("")
+
+		// Perform type assertion into temporary variables:
+		// ({ value: _gs_ta_val_, ok: _gs_ta_ok_ } = $.typeAssert<AssertedTypeTS>(expr, "GoTypeStr"));
+		c.tsw.WriteLiterally("({ value: ")
+		c.tsw.WriteLiterally(tempValName)
+		c.tsw.WriteLiterally(", ok: ")
+		c.tsw.WriteLiterally(tempOkName)
+		c.tsw.WriteLiterally(" } = $.typeAssert<")
+		c.WriteTypeExpr(assertedType) // Generic: <AssertedTypeTS>
+		c.tsw.WriteLiterally(">(")
+		if err := c.WriteValueExpr(interfaceExpr); err != nil { // Arg1: interfaceExpr
+			return fmt.Errorf("failed to write interface expression in type assertion call: %w", err)
+		}
+		c.tsw.WriteLiterally(", ")
+		c.writeTypeDescription(assertedType) // Arg2: type info for runtime
+		c.tsw.WriteLine("))")
+
+		// Assign temporary value to the selector expression:
+		// s.f = _gs_ta_val_;
+		if err := c.WriteValueExpr(vLHS); err != nil { // Writes selector expression (e.g., "s.f")
+			return fmt.Errorf("failed to write LHS selector expression in type assertion: %w", err)
+		}
+		c.tsw.WriteLiterally(" = ")
+		c.tsw.WriteLiterally(tempValName)
+		c.tsw.WriteLine("")
+
+		// Assign temporary ok to the ok variable (e.g., okName = _gs_ta_ok_; or let okName = ...)
+		if !okIsBlank {
+			if okIsNewInDefine { // okIsNewInDefine was determined earlier based on tok == token.DEFINE and Defs check
+				c.tsw.WriteLiterally("let ")
+			}
+			c.tsw.WriteLiterally(okName)
+			c.tsw.WriteLiterally(" = ")
+			c.tsw.WriteLiterally(tempOkName)
+			c.tsw.WriteLine("")
+		}
+
+	default:
+		return fmt.Errorf("unhandled LHS expression type for value in type assertion: %T", valueExpr)
+	}
+
+	return nil
+}

package/compiler/type-info.go

@@ -0,0 +1,141 @@
+package compiler
+
+import "go/types"
+
+// writeTypeInfoObject writes a TypeScript TypeInfo object literal for a given Go type.
+func (c *GoToTSCompiler) writeTypeInfoObject(typ types.Type) {
+	if typ == nil {
+		c.tsw.WriteLiterally("{ kind: $.TypeKind.Basic, name: 'any' }") // Or handle as error
+		return
+	}
+
+	// If typ is a *types.Named, handle it by reference to break recursion.
+	if namedType, ok := typ.(*types.Named); ok {
+		if namedType.Obj().Name() == "error" && namedType.Obj().Pkg() == nil { // Check for builtin error
+			c.tsw.WriteLiterally("{ kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] }")
+		} else {
+			// For all other named types, output their name as a string literal.
+			// This relies on the type being registered elsewhere (e.g., via registerStructType or registerInterfaceType)
+			// so the TypeScript runtime can resolve the reference.
+			c.tsw.WriteLiterallyf("%q", namedType.Obj().Name())
+		}
+		return // Return after handling the named type by reference.
+	}
+
+	// If typ is not *types.Named, process its underlying structure.
+	underlying := typ.Underlying()
+	switch t := underlying.(type) {
+	case *types.Basic:
+		tsTypeName, _ := GoBuiltinToTypescript(t.Name())
+		if tsTypeName == "" {
+			tsTypeName = t.Name() // Fallback
+		}
+		c.tsw.WriteLiterallyf("{ kind: $.TypeKind.Basic, name: %q }", tsTypeName)
+	// Note: The original 'case *types.Named:' here for 'underlying' is intentionally omitted.
+	// If typ.Underlying() is *types.Named (e.g. type T1 MyInt; type T2 T1;),
+	// then writeTypeInfoObject(typ.Underlying()) would be called in some contexts,
+	// and that call would handle it via the top-level *types.Named check.
+	case *types.Pointer:
+		c.tsw.WriteLiterally("{ kind: $.TypeKind.Pointer, elemType: ")
+		c.writeTypeInfoObject(t.Elem()) // Recursive call
+		c.tsw.WriteLiterally(" }")
+	case *types.Slice:
+		c.tsw.WriteLiterally("{ kind: $.TypeKind.Slice, elemType: ")
+		c.writeTypeInfoObject(t.Elem()) // Recursive call
+		c.tsw.WriteLiterally(" }")
+	case *types.Array:
+		c.tsw.WriteLiterallyf("{ kind: $.TypeKind.Array, length: %d, elemType: ", t.Len())
+		c.writeTypeInfoObject(t.Elem()) // Recursive call
+		c.tsw.WriteLiterally(" }")
+	case *types.Map:
+		c.tsw.WriteLiterally("{ kind: $.TypeKind.Map, keyType: ")
+		c.writeTypeInfoObject(t.Key()) // Recursive call
+		c.tsw.WriteLiterally(", elemType: ")
+		c.writeTypeInfoObject(t.Elem()) // Recursive call
+		c.tsw.WriteLiterally(" }")
+	case *types.Chan:
+		dir := "both"
+		if t.Dir() == types.SendOnly {
+			dir = "send"
+		} else if t.Dir() == types.RecvOnly {
+			dir = "receive"
+		}
+		c.tsw.WriteLiterallyf("{ kind: $.TypeKind.Channel, direction: %q, elemType: ", dir)
+		c.writeTypeInfoObject(t.Elem()) // Recursive call
+		c.tsw.WriteLiterally(" }")
+	case *types.Interface: // Anonymous interface or underlying of a non-named type alias
+		c.tsw.WriteLiterally("{ kind: $.TypeKind.Interface, methods: [")
+		var methods []*types.Func
+		for i := 0; i < t.NumExplicitMethods(); i++ {
+			methods = append(methods, t.ExplicitMethod(i))
+		}
+		// TODO: Handle embedded methods for anonymous interfaces if needed.
+		c.writeMethodSignatures(methods) // Calls writeMethodSignatures -> writeTypeInfoObject
+		c.tsw.WriteLiterally("] }")
+	case *types.Signature: // Anonymous func type or underlying of a non-named type alias
+		c.tsw.WriteLiterally("{ kind: $.TypeKind.Function, params: [")
+		for i := 0; i < t.Params().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.writeTypeInfoObject(t.Params().At(i).Type()) // Recursive call
+		}
+		c.tsw.WriteLiterally("], results: [")
+		for i := 0; i < t.Results().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.writeTypeInfoObject(t.Results().At(i).Type()) // Recursive call
+		}
+		c.tsw.WriteLiterally("] }")
+	case *types.Struct: // Anonymous struct or underlying of a non-named type alias
+		c.tsw.WriteLiterally("{ kind: $.TypeKind.Struct, fields: {")
+		for i := 0; i < t.NumFields(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			field := t.Field(i)
+			c.tsw.WriteLiterallyf("%q: ", field.Name())
+			c.writeTypeInfoObject(field.Type()) // Recursive call
+		}
+		c.tsw.WriteLiterally("}, methods: [] }") // Anonymous structs don't have methods in this context
+	default:
+		// Fallback, e.g. for types whose underlying isn't one of the above like *types.Tuple or other complex cases.
+		c.tsw.WriteLiterallyf("{ kind: $.TypeKind.Basic, name: %q }", typ.String()) // Fallback using the type's string representation
+	}
+}
+
+// writeMethodSignatures writes an array of TypeScript MethodSignature objects.
+func (c *GoToTSCompiler) writeMethodSignatures(methods []*types.Func) {
+	firstMethod := true
+	for _, method := range methods {
+		if !firstMethod {
+			c.tsw.WriteLiterally(", ")
+		}
+		firstMethod = false
+
+		sig := method.Type().(*types.Signature)
+		c.tsw.WriteLiterallyf("{ name: %q, args: [", method.Name())
+		for i := 0; i < sig.Params().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			param := sig.Params().At(i)
+			c.tsw.WriteLiterallyf("{ name: %q, type: ", param.Name())
+			c.writeTypeInfoObject(param.Type())
+			c.tsw.WriteLiterally(" }")
+		}
+		c.tsw.WriteLiterally("], returns: [")
+		for i := 0; i < sig.Results().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			result := sig.Results().At(i)
+			// Return parameters in Go often don't have names that are relevant for TS signature matching
+			c.tsw.WriteLiterally("{ type: ")
+			c.writeTypeInfoObject(result.Type())
+			c.tsw.WriteLiterally(" }")
+		}
+		c.tsw.WriteLiterally("] }")
+	}
+}