goscript 0.0.84 → 0.1.1

package/compiler/expr-type.go

@@ -1,442 +0,0 @@
-package compiler
-
-import (
-	"go/ast"
-	"go/types"
-)
-
-// WriteTypeExpr translates a Go abstract syntax tree (AST) expression (`ast.Expr`)
-// that represents a type into its TypeScript type equivalent using type information.
-//
-// It handles various Go type expressions:
-// - Basic types (e.g., int, string, bool) -> TypeScript primitives (number, string, boolean)
-// - Named types -> TypeScript class/interface names
-// - Pointer types (`*T`) -> `$.VarRef<T_ts> | null`
-// - Slice types (`[]T`) -> `$.Slice<T_ts>`
-// - Array types (`[N]T`) -> `T_ts[]`
-// - Map types (`map[K]V`) -> `Map<K_ts, V_ts>`
-// - Channel types (`chan T`) -> `$.Channel<T_ts>`
-// - Struct types -> TypeScript object types or class names
-// - Interface types -> TypeScript interface types or "any"
-// - Function types -> TypeScript function signatures
-func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
-	// Handle qualified generic type references (e.g., pkg.Type[T]) preserving the package alias.
-	if indexExpr, ok := a.(*ast.IndexExpr); ok {
-		if selectorExpr, ok := indexExpr.X.(*ast.SelectorExpr); ok {
-			if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {
-				if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
-					if _, isPkg := obj.(*types.PkgName); isPkg {
-						c.tsw.WriteLiterally(pkgIdent.Name)
-						c.tsw.WriteLiterally(".")
-						c.tsw.WriteLiterally(selectorExpr.Sel.Name)
-						c.tsw.WriteLiterally("<")
-						c.WriteTypeExpr(indexExpr.Index)
-						c.tsw.WriteLiterally(">")
-						return
-					}
-				}
-			}
-		}
-	}
-
-	if indexListExpr, ok := a.(*ast.IndexListExpr); ok {
-		if selectorExpr, ok := indexListExpr.X.(*ast.SelectorExpr); ok {
-			if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {
-				if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
-					if _, isPkg := obj.(*types.PkgName); isPkg {
-						c.tsw.WriteLiterally(pkgIdent.Name)
-						c.tsw.WriteLiterally(".")
-						c.tsw.WriteLiterally(selectorExpr.Sel.Name)
-						c.tsw.WriteLiterally("<")
-						for i, index := range indexListExpr.Indices {
-							if i > 0 {
-								c.tsw.WriteLiterally(", ")
-							}
-							c.WriteTypeExpr(index)
-						}
-						c.tsw.WriteLiterally(">")
-						return
-					}
-				}
-			}
-		}
-	}
-
-	// Handle selector expressions (e.g., os.FileInfo) specially to preserve qualified names
-	if selectorExpr, ok := a.(*ast.SelectorExpr); ok {
-		if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {
-			// Check if this is a package selector (e.g., os.FileInfo)
-			if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
-				if _, isPkg := obj.(*types.PkgName); isPkg {
-					// This is a package.Type reference
-					typ := c.pkg.TypesInfo.TypeOf(a)
-
-					// Check if this is an interface type and add null | prefix
-					if typ != nil {
-						if _, isInterface := typ.Underlying().(*types.Interface); isInterface {
-							c.tsw.WriteLiterally("null | ")
-						}
-					}
-
-					// Write the qualified name
-					c.tsw.WriteLiterally(pkgIdent.Name)
-					c.tsw.WriteLiterally(".")
-					c.tsw.WriteLiterally(selectorExpr.Sel.Name)
-
-					// Check if this is a function type and add | null
-					if typ != nil {
-						if namedType, isNamed := typ.(*types.Named); isNamed {
-							if _, isSignature := namedType.Underlying().(*types.Signature); isSignature {
-								c.tsw.WriteLiterally(" | null")
-							}
-						}
-					}
-					return
-				}
-			}
-		}
-	}
-
-	// Handle array/slice types to preserve qualified names in element types
-	if arrayType, ok := a.(*ast.ArrayType); ok {
-		if arrayType.Len == nil {
-			// Slice type: []T -> $.Slice<T>
-			// Check if it's a []byte slice first
-			if ident, ok := arrayType.Elt.(*ast.Ident); ok && ident.Name == "byte" {
-				c.tsw.WriteLiterally("$.Bytes")
-				return
-			}
-			c.tsw.WriteLiterally("$.Slice<")
-			c.WriteTypeExpr(arrayType.Elt) // Recursively handle element type preserving qualified names
-			c.tsw.WriteLiterally(">")
-		} else {
-			// Array type: [N]T -> T[]
-			c.WriteTypeExpr(arrayType.Elt) // Recursively handle element type preserving qualified names
-			c.tsw.WriteLiterally("[]")
-		}
-		return
-	}
-
-	// Get type information for the expression and use WriteGoType
-	typ := c.pkg.TypesInfo.TypeOf(a)
-	c.WriteGoType(typ, GoTypeContextGeneral)
-}
-
-// writeTypeDescription writes the TypeInfo for a type expr.
-func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
-	switch t := typeExpr.(type) {
-	case *ast.Ident:
-		// Resolve the identifier to its type
-		goType := c.pkg.TypesInfo.TypeOf(t)
-		if goType != nil {
-			if namedType, isNamed := goType.(*types.Named); isNamed {
-				if sig, isFuncSig := namedType.Underlying().(*types.Signature); isFuncSig {
-					// It's a named function type (e.g. type MyFunc func())
-					c.tsw.WriteLiterally("{")
-					c.tsw.WriteLiterally("kind: $.TypeKind.Function, ")
-					c.tsw.WriteLiterallyf("name: '%s'", namedType.Obj().Name()) // Use the original defined name
-
-					// Add params if present
-					if sig.Params() != nil && sig.Params().Len() > 0 {
-						c.tsw.WriteLiterally(", params: [")
-						for i := 0; i < sig.Params().Len(); i++ {
-							if i > 0 {
-								c.tsw.WriteLiterally(", ")
-							}
-							paramVar := sig.Params().At(i)
-							c.writeTypeInfoObject(paramVar.Type())
-						}
-						c.tsw.WriteLiterally("]")
-					} else {
-						c.tsw.WriteLiterally(", params: []")
-					}
-
-					// Add results if present
-					if sig.Results() != nil && sig.Results().Len() > 0 {
-						c.tsw.WriteLiterally(", results: [")
-						for i := 0; i < sig.Results().Len(); i++ {
-							if i > 0 {
-								c.tsw.WriteLiterally(", ")
-							}
-							resultVar := sig.Results().At(i)
-							c.writeTypeInfoObject(resultVar.Type())
-						}
-						c.tsw.WriteLiterally("]")
-					} else {
-						c.tsw.WriteLiterally(", results: []")
-					}
-
-					c.tsw.WriteLiterally("}")
-					return
-				}
-			}
-		}
-
-		if isPrimitiveType(t.Name) {
-			if tsType, ok := GoBuiltinToTypescript(t.Name); ok {
-				c.tsw.WriteLiterally("{")
-				c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
-				c.tsw.WriteLiterallyf("name: '%s'", tsType)
-				c.tsw.WriteLiterally("}")
-			} else {
-				// Fallback for other primitive types
-				c.tsw.WriteLiterally("{")
-				c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
-				c.tsw.WriteLiterallyf("name: '%s'", t.Name)
-				c.tsw.WriteLiterally("}")
-			}
-		} else {
-			// For named types, use the fully qualified name with package path
-			if goType != nil {
-				if namedType, isNamed := goType.(*types.Named); isNamed {
-					typeName := namedType.Obj().Name()
-					if pkg := namedType.Obj().Pkg(); pkg != nil {
-						pkgPath := pkg.Path()
-						pkgName := pkg.Name()
-						if pkgPath != "" && pkgName != "main" {
-							typeName = pkgPath + "." + typeName
-						} else if pkgName == "main" {
-							typeName = "main." + typeName
-						}
-					}
-					c.tsw.WriteLiterallyf("'%s'", typeName)
-					return
-				}
-			}
-			// Fallback to short name if type info unavailable
-			c.tsw.WriteLiterallyf("'%s'", t.Name)
-		}
-	case *ast.SelectorExpr:
-		if ident, ok := t.X.(*ast.Ident); ok {
-			// Use type info to get the actual package path
-			goType := c.pkg.TypesInfo.TypeOf(t)
-			if goType != nil {
-				if namedType, isNamed := goType.(*types.Named); isNamed {
-					typeName := namedType.Obj().Name()
-					if pkg := namedType.Obj().Pkg(); pkg != nil {
-						pkgPath := pkg.Path()
-						pkgName := pkg.Name()
-						if pkgPath != "" && pkgName != "main" {
-							typeName = pkgPath + "." + typeName
-						} else if pkgName == "main" {
-							typeName = "main." + typeName
-						}
-					}
-					c.tsw.WriteLiterallyf("'%s'", typeName)
-					return
-				}
-			}
-			// Fallback to using the identifier name (package alias)
-			c.tsw.WriteLiterallyf("'%s.%s'", ident.Name, t.Sel.Name)
-		}
-	case *ast.ArrayType:
-		typeKind := "$.TypeKind.Slice"
-		if t.Len != nil {
-			typeKind = "$.TypeKind.Array"
-		}
-
-		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterallyf("kind: %s, ", typeKind)
-		c.tsw.WriteLiterally("elemType: ")
-		c.writeTypeDescription(t.Elt)
-		c.tsw.WriteLiterally("}")
-	case *ast.StructType:
-		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterally("kind: $.TypeKind.Struct, ")
-
-		// Add field names and types to the struct type info
-		if t.Fields != nil && t.Fields.List != nil {
-			c.tsw.WriteLiterally("fields: {")
-
-			hasFields := false
-			for _, field := range t.Fields.List {
-				if len(field.Names) > 0 {
-					for _, name := range field.Names {
-						if hasFields {
-							c.tsw.WriteLiterally(", ")
-						}
-						c.tsw.WriteLiterallyf("'%s': ", name.Name)
-						c.writeTypeDescription(field.Type)
-						hasFields = true
-					}
-				}
-			}
-
-			c.tsw.WriteLiterally("}, ")
-		} else {
-			c.tsw.WriteLiterally("fields: {}, ")
-		}
-
-		c.tsw.WriteLiterally("methods: []")
-
-		c.tsw.WriteLiterally("}")
-	case *ast.MapType:
-		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterally("kind: $.TypeKind.Map, ")
-		c.tsw.WriteLiterally("keyType: ")
-		c.writeTypeDescription(t.Key)
-		c.tsw.WriteLiterally(", ")
-		c.tsw.WriteLiterally("elemType: ")
-		c.writeTypeDescription(t.Value)
-		c.tsw.WriteLiterally("}")
-	case *ast.StarExpr:
-		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterally("kind: $.TypeKind.Pointer, ")
-		c.tsw.WriteLiterally("elemType: ")
-		c.writeTypeDescription(t.X)
-		c.tsw.WriteLiterally("}")
-	case *ast.FuncType:
-		// For function types, create a type descriptor object with params and results
-		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterally("kind: $.TypeKind.Function")
-
-		// Add name if this is a named function type
-		// For an anonymous ast.FuncType, typeExpr is the ast.FuncType itself.
-		// We need to check if the type information associated with this AST node
-		// points to a *types.Named type.
-		resolvedGoType := c.pkg.TypesInfo.TypeOf(typeExpr)
-		if resolvedGoType != nil {
-			if named, ok := resolvedGoType.(*types.Named); ok {
-				// Ensure it's actually a function type that's named
-				if _, isFuncSig := named.Underlying().(*types.Signature); isFuncSig {
-					c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
-				}
-			}
-		}
-
-		// Add params if present
-		if t.Params != nil && len(t.Params.List) > 0 {
-			c.tsw.WriteLiterally(", params: [")
-			for i, param := range t.Params.List {
-				if i > 0 {
-					c.tsw.WriteLiterally(", ")
-				}
-				c.writeTypeDescription(param.Type)
-			}
-			c.tsw.WriteLiterally("]")
-		}
-
-		// Add results if present
-		if t.Results != nil && len(t.Results.List) > 0 {
-			c.tsw.WriteLiterally(", results: [")
-			for i, result := range t.Results.List {
-				if i > 0 {
-					c.tsw.WriteLiterally(", ")
-				}
-				c.writeTypeDescription(result.Type)
-			}
-			c.tsw.WriteLiterally("]")
-		}
-
-		c.tsw.WriteLiterally("}")
-		return
-	case *ast.ChanType:
-		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterally("kind: $.TypeKind.Channel, ")
-		c.tsw.WriteLiterally("elemType: ")
-
-		// Add element type
-		if ident, ok := t.Value.(*ast.Ident); ok && isPrimitiveType(ident.Name) {
-			if tsType, ok := GoBuiltinToTypescript(ident.Name); ok {
-				c.tsw.WriteLiterallyf("'%s'", tsType)
-			} else {
-				c.tsw.WriteLiterallyf("'%s'", ident.Name) // Fallback
-			}
-		} else {
-			c.writeTypeDescription(t.Value)
-		}
-
-		// Add direction
-		c.tsw.WriteLiterally(", direction: ")
-		switch t.Dir {
-		case ast.SEND:
-			c.tsw.WriteLiterally("'send'")
-		case ast.RECV:
-			c.tsw.WriteLiterally("'receive'")
-		case ast.SEND | ast.RECV: // bidirectional
-			c.tsw.WriteLiterally("'both'")
-		default:
-			// This should not happen, but just in case
-			c.tsw.WriteLiterally("'both'")
-		}
-
-		c.tsw.WriteLiterally("}")
-	case *ast.InterfaceType:
-		// Handle inline interface types like interface{ Method() string }
-		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterally("kind: $.TypeKind.Interface, ")
-		c.tsw.WriteLiterally("methods: [")
-
-		// Add method signatures for each method in the interface
-		if t.Methods != nil && t.Methods.List != nil {
-			hasMethod := false
-			for _, field := range t.Methods.List {
-				// Only process method declarations (not embedded interfaces)
-				if len(field.Names) > 0 {
-					for _, methodName := range field.Names {
-						if hasMethod {
-							c.tsw.WriteLiterally(", ")
-						}
-						hasMethod = true
-
-						// Write method signature in the same format as writeMethodSignatures
-						c.tsw.WriteLiterallyf("{ name: '%s', args: [", methodName.Name)
-
-						// Get the function type for this method
-						if funcType, ok := field.Type.(*ast.FuncType); ok {
-							// Add parameters
-							if funcType.Params != nil && funcType.Params.List != nil {
-								paramIndex := 0
-								for _, param := range funcType.Params.List {
-									// Each parameter field can declare multiple variables of the same type
-									if len(param.Names) > 0 {
-										for _, paramName := range param.Names {
-											if paramIndex > 0 {
-												c.tsw.WriteLiterally(", ")
-											}
-											c.tsw.WriteLiterallyf("{ name: '%s', type: ", paramName.Name)
-											c.writeTypeDescription(param.Type)
-											c.tsw.WriteLiterally(" }")
-											paramIndex++
-										}
-									} else {
-										// No names, create a generic parameter name
-										if paramIndex > 0 {
-											c.tsw.WriteLiterally(", ")
-										}
-										c.tsw.WriteLiterallyf("{ name: '_p%d', type: ", paramIndex)
-										c.writeTypeDescription(param.Type)
-										c.tsw.WriteLiterally(" }")
-										paramIndex++
-									}
-								}
-							}
-
-							c.tsw.WriteLiterally("], returns: [")
-
-							// Add return types
-							if funcType.Results != nil && funcType.Results.List != nil {
-								for i, result := range funcType.Results.List {
-									if i > 0 {
-										c.tsw.WriteLiterally(", ")
-									}
-									c.tsw.WriteLiterally("{ type: ")
-									c.writeTypeDescription(result.Type)
-									c.tsw.WriteLiterally(" }")
-								}
-							}
-
-							c.tsw.WriteLiterally("] }")
-						}
-					}
-				}
-			}
-		}
-
-		c.tsw.WriteLiterally("]")
-		c.tsw.WriteLiterally("}")
-	default:
-		// For other types, use the string representation
-		c.tsw.WriteLiterallyf("'%s'", c.getTypeNameString(typeExpr))
-	}
-}

package/compiler/expr-value.go

@@ -1,89 +0,0 @@
-package compiler
-
-import (
-	"go/ast"
-)
-
-// WriteValueExpr translates a Go abstract syntax tree (AST) expression (`ast.Expr`)
-// that represents a value into its TypeScript value equivalent.
-// This is a central dispatch function for various expression types:
-// - Identifiers (`ast.Ident`): Delegates to `WriteIdent`, potentially adding `.value` for varrefed variables.
-// - Selector expressions (`ast.SelectorExpr`, e.g., `obj.Field` or `pkg.Var`): Delegates to `WriteSelectorExpr`.
-// - Pointer dereferences (`ast.StarExpr`, e.g., `*ptr`): Delegates to `WriteStarExpr`.
-// - Function calls (`ast.CallExpr`): Delegates to `WriteCallExpr`.
-// - Unary operations (`ast.UnaryExpr`, e.g., `!cond`, `&val`): Delegates to `WriteUnaryExpr`.
-// - Binary operations (`ast.BinaryExpr`, e.g., `a + b`): Delegates to `WriteBinaryExpr`.
-// - Basic literals (`ast.BasicLit`, e.g., `123`, `"hello"`): Delegates to `WriteBasicLit`.
-// - Composite literals (`ast.CompositeLit`, e.g., `MyStruct{}`): Delegates to `WriteCompositeLit`.
-// - Key-value expressions (`ast.KeyValueExpr`): Delegates to `WriteKeyValueExpr`.
-// - Type assertions in expression context (`ast.TypeAssertExpr`, e.g., `val.(Type)`): Delegates to `WriteTypeAssertExpr`.
-// - Index expressions (`ast.IndexExpr`):
-//   - For maps: `myMap[key]` becomes `myMap.get(key) ?? zeroValue`.
-//   - For arrays/slices: `myArray[idx]` becomes `myArray![idx]`.
-//
-// - Slice expressions (`ast.SliceExpr`, e.g., `s[low:high:max]`): Translates to `$.slice(s, low, high, max)`.
-// - Parenthesized expressions (`ast.ParenExpr`): Translates `(X)` to `(X)`.
-// - Function literals (`ast.FuncLit`): Delegates to `WriteFuncLitValue`.
-// Unhandled value expressions result in a comment.
-func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
-	switch exp := a.(type) {
-	case *ast.Ident:
-		c.WriteIdent(exp, true) // adds .value accessor
-		return nil
-	case *ast.SelectorExpr:
-		return c.WriteSelectorExpr(exp)
-	case *ast.StarExpr:
-		return c.WriteStarExpr(exp)
-	case *ast.CallExpr:
-		return c.WriteCallExpr(exp)
-	case *ast.UnaryExpr:
-		return c.WriteUnaryExpr(exp)
-	case *ast.BinaryExpr:
-		return c.WriteBinaryExpr(exp)
-	case *ast.BasicLit:
-		c.WriteBasicLit(exp)
-		return nil
-	case *ast.CompositeLit:
-		return c.WriteCompositeLit(exp)
-	case *ast.KeyValueExpr:
-		return c.WriteKeyValueExpr(exp)
-	case *ast.TypeAssertExpr:
-		// Handle type assertion in an expression context
-		return c.WriteTypeAssertExpr(exp)
-	case *ast.IndexExpr:
-		return c.WriteIndexExpr(exp)
-	case *ast.IndexListExpr:
-		// Handle generic function instantiation: f[T1, T2](args) -> f<T1, T2>(args)
-		return c.WriteIndexListExpr(exp)
-	case *ast.SliceExpr:
-		return c.WriteSliceExpr(exp)
-	case *ast.ParenExpr:
-		// Check if this is a nil pointer to struct type cast: (*struct{})(nil)
-		if starExpr, isStarExpr := exp.X.(*ast.StarExpr); isStarExpr {
-			if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
-				c.tsw.WriteLiterally("null")
-				return nil
-			}
-		}
-
-		// Check if this is a type cast with nil: (SomeType)(nil)
-		if ident, isIdent := exp.X.(*ast.Ident); isIdent && ident.Name == "nil" {
-			c.tsw.WriteLiterally("null")
-			return nil
-		}
-
-		// Translate (X) to (X)
-		// If we haven't written anything in this statement yet, prepend ;
-		c.tsw.WriteLiterally("(")
-		if err := c.WriteValueExpr(exp.X); err != nil {
-			return err
-		}
-		c.tsw.WriteLiterally(")")
-		return nil
-	case *ast.FuncLit:
-		return c.WriteFuncLitValue(exp)
-	default:
-		c.tsw.WriteCommentLinef("unhandled value expr: %T", exp)
-		return nil
-	}
-}