gotranspiler

type DispatchTarget int

type ExportedFunc struct {
	GoName  string // PascalCase Go name (e.g., "Fibonacci")
	JSName  string // camelCase JS name (e.g., "fibonacci")
	Generic bool   // True if the function has type parameters
}

type GoDecl interface {
	// contains filtered or unexported methods
}

type GoExpr interface {
	ExprType() GoTypeInfo
	// contains filtered or unexported methods
}

type GoFile struct {
	Package string
	Decls   []GoDecl
	Stmts   []GoStmt // package-level init statements (rare, for var declarations)
}

type GoStmt interface {
	// contains filtered or unexported methods
}

type GoTypeCategory int

type GoTypeInfo struct {
	Category GoTypeCategory
	GoStr    string // Full Go type string: "[]float64", "*web.Response", etc.
	ElemType string // For Slice: element type; for Map: value type; for Promise: inner type
	KeyType  string // For Map: key type
	Name     string // For Pointer/Interface: the type name without *
}

type IRAddrOf struct {
	Expr GoExpr
	// contains filtered or unexported fields
}

type IRArrayMethodCall struct {
	HelperFunc string   // "Map", "Filter", "Reduce", "Find", "ForEach", etc.
	Array      GoExpr   // the array expression
	Callback   GoExpr   // the callback function (IRFuncLit)
	ExtraArgs  []GoExpr // extra args (e.g., initial value for Reduce)
	ElemType   string   // Go element type of the array
	// contains filtered or unexported fields
}

type IRAssign struct {
	Targets []GoExpr
	Op      string // "=", "+=", "-=", etc.
	Values  []GoExpr
	// contains filtered or unexported fields
}

type IRAwait struct {
	Expr GoExpr // the promise expression
	// contains filtered or unexported fields
}

type IRBinaryOp struct {
	Op    string // Go operator: "+", "-", "==", "!=", "&&", "||", etc.
	Left  GoExpr
	Right GoExpr
	// contains filtered or unexported fields
}

type IRBlock struct {
	Stmts []GoStmt
	Bare  bool // if true, emit statements without surrounding braces
	// contains filtered or unexported fields
}

type IRBreak struct {
	Label string // empty for unlabeled break
	// contains filtered or unexported fields
}

type IRBuilder struct {
	// contains filtered or unexported fields
}

type IRCall struct {
	Func GoExpr // the function expression
	Args []GoExpr
	// contains filtered or unexported fields
}

type IRCase struct {
	Exprs []GoExpr // empty = default case
	Body  []GoStmt
}

type IRCompositeLit struct {
	TypeStr  string       // Go type string: "&MyStruct", "[]float64", "map[string]any"
	Elements []IRKeyValue // field/key-value pairs, or positional elements (Key empty)
	// contains filtered or unexported fields
}

type IRConstDecl struct {
	Name  string
	Value GoExpr // may be nil (uses iota)
}

type IRConstGroupDecl struct {
	TypeName string // the type name (for typed constants)
	Consts   []IRConstDecl
	// contains filtered or unexported fields
}

type IRContinue struct {
	Label string
	// contains filtered or unexported fields
}

type IRDefer struct {
	Call GoExpr // the deferred function call
	// contains filtered or unexported fields
}

type IRDeref struct {
	Expr GoExpr
	// contains filtered or unexported fields
}

type IREmitter struct {
	// contains filtered or unexported fields
}

type IREnumDecl struct {
	Name       string
	BaseType   string // "float64", "string", or "int"
	Members    []IREnumMember
	IsExported bool
	// contains filtered or unexported fields
}

type IREnumMember struct {
	Name  string
	Value GoExpr // the constant value (may be nil for iota)
}

type IRExprStmt struct {
	Expr GoExpr
	// contains filtered or unexported fields
}

type IRFieldAccess struct {
	Object         GoExpr
	Field          string
	NeedsAssertion bool       // true if obj is any and needs .(Type)
	AssertType     GoTypeInfo // the type to assert to (when NeedsAssertion)
	// contains filtered or unexported fields
}

type IRFor struct {
	Init GoStmt // may be nil
	Cond GoExpr // may be nil (infinite loop)
	Post GoStmt // may be nil
	Body []GoStmt
	// contains filtered or unexported fields
}

type IRFuncDecl struct {
	Name       string
	TypeParams []IRTypeParam // generic type parameters
	Params     []IRParam
	RetType    GoTypeInfo
	Body       []GoStmt
	Receiver   *IRReceiver // non-nil for methods
	IsAsync    bool        // wraps body in promise.New
	IsExported bool
	// contains filtered or unexported fields
}

type IRFuncLit struct {
	Params  []IRParam
	RetType GoTypeInfo
	Body    []GoStmt
	IsAsync bool // wraps body in promise.New[T](func(__resolve, __reject) { ... })
	// contains filtered or unexported fields
}

type IRGo struct {
	Call GoExpr
	// contains filtered or unexported fields
}

type IRIdent struct {
	Name    string // Go identifier name (already converted via goVarName/goExportedName)
	PkgName string // package qualifier, empty for local (e.g., "strings", "web")
	// contains filtered or unexported fields
}

type IRIf struct {
	Cond GoExpr
	Body []GoStmt
	Else []GoStmt // may be empty; single IRIf element = else if
	// contains filtered or unexported fields
}

type IRImportDecl struct {
	Path  string // import path
	Alias string // alias (empty for default)
	// contains filtered or unexported fields
}

type IRIncDec struct {
	Expr GoExpr
	Op   string // "++" or "--"
	// contains filtered or unexported fields
}

type IRIndexAccess struct {
	Object GoExpr
	Index  GoExpr
	// contains filtered or unexported fields
}

type IRInstanceOf struct {
	Expr     GoExpr
	TypeName string // Go type name to check against
	// contains filtered or unexported fields
}

type IRInterfaceDecl struct {
	Name       string
	TypeParams []IRTypeParam
	Methods    []IRMethodSig
	Embedded   []string // embedded interface names
	IsExported bool
	// contains filtered or unexported fields
}

type IRJSRTCall struct {
	Pattern string   // "Get", "Set", "Call", "TypeOf", etc.
	Object  GoExpr   // the object (may be nil for global operations)
	Field   string   // field/method name
	Args    []GoExpr // arguments
	// contains filtered or unexported fields
}

type IRKeyValue struct {
	Key   string // field name or map key (empty for positional elements)
	Value GoExpr
}

type IRLabeled struct {
	Label string
	Stmt  GoStmt
	// contains filtered or unexported fields
}

type IRLiteral struct {
	Value string // Go literal text: `"hello"`, "42", "true", "nil"
	// contains filtered or unexported fields
}

type IRMakeCall struct {
	TypeStr string // Go type: "[]float64", "map[string]any", "chan int"
	Len     GoExpr // length (may be nil)
	Cap     GoExpr // capacity (may be nil)
	// contains filtered or unexported fields
}

type IRMethodCall struct {
	Strategy DispatchTarget
	Object   GoExpr
	Method   string
	Args     []GoExpr
	// Array/string method-specific fields
	ElemGoType string // element type for array helpers (e.g., "float64")
	// contains filtered or unexported fields
}

type IRMethodSig struct {
	Name       string
	Params     []IRParam
	RetType    GoTypeInfo
	IsExported bool
}

type IRMultiValue struct {
	Exprs []GoExpr
	// contains filtered or unexported fields
}

type IRMultiVarDecl struct {
	Names []string
	Types []GoTypeInfo
	Init  GoExpr // the expression producing multiple values
	// contains filtered or unexported fields
}

type IRNewExpr struct {
	TypeName string       // Go type name (without *)
	Args     []IRKeyValue // constructor arguments as field assignments
	// contains filtered or unexported fields
}

type IRNilCheck struct {
	Expr GoExpr // expression to check for nil
	Then GoExpr // result if not nil
	Else GoExpr // result if nil (usually IRLiteral{Value:"nil"})
	// contains filtered or unexported fields
}

type IRParam struct {
	Name   string
	Typ    GoTypeInfo
	IsRest bool // ...args → variadic
}

type IRPromiseNew struct {
	InnerType GoTypeInfo // T in Promise[T]
	Body      []GoStmt   // statements inside the promise callback
	// contains filtered or unexported fields
}

type IRRange struct {
	Key   string // "_" if unused
	Value string // "_" if unused, empty if no value binding
	Over  GoExpr
	Body  []GoStmt
	// contains filtered or unexported fields
}

type IRRawDecl struct {
	Code string
	// contains filtered or unexported fields
}

type IRRawExpr struct {
	Code string
	// contains filtered or unexported fields
}

type IRRawStmt struct {
	Code string
	// contains filtered or unexported fields
}

type IRReceiver struct {
	Name string // receiver variable name (e.g., "r")
	Type string // receiver type (e.g., "*MyStruct")
}

type IRRejectCall struct {
	Err GoExpr
	// contains filtered or unexported fields
}

type IRResolveCall struct {
	Value GoExpr // the value to resolve with (may be nil for void)
	// contains filtered or unexported fields
}

type IRReturn struct {
	Values []GoExpr // may be empty for bare return
	// contains filtered or unexported fields
}

type IRSend struct {
	Chan  GoExpr
	Value GoExpr
	// contains filtered or unexported fields
}

type IRSliceExpr struct {
	Object GoExpr
	Low    GoExpr // may be nil
	High   GoExpr // may be nil
	// contains filtered or unexported fields
}

type IRSprintfCall struct {
	Format string   // format string with %s/%v placeholders
	Args   []GoExpr // expressions for each placeholder
	// contains filtered or unexported fields
}

type IRStdlibCall struct {
	Package string // "strings", "fmt", "jsarray", "jsrt", "" (builtin)
	Func    string // "Contains", "Sprintf", "len", "append"
	Args    []GoExpr
	// contains filtered or unexported fields
}

type IRStmtDecl struct {
	Stmt GoStmt
	// contains filtered or unexported fields
}

type IRStructDecl struct {
	Name       string
	TypeParams []IRTypeParam
	Embedded   []string // embedded type names (base class, composed interfaces)
	Fields     []IRStructField
	IsExported bool
	// contains filtered or unexported fields
}

type IRStructField struct {
	Name       string
	Typ        GoTypeInfo
	Tag        string // struct tag (e.g., `json:"name"`)
	IsExported bool
}

type IRSwitch struct {
	Tag   GoExpr // may be nil for type switch
	Cases []IRCase
	// contains filtered or unexported fields
}

type IRTernary struct {
	Cond GoExpr
	Then GoExpr
	Else GoExpr
	// contains filtered or unexported fields
}

type IRTryCatch struct {
	TryBody     []GoStmt
	CatchVar    string   // catch parameter name (empty if unused)
	CatchBody   []GoStmt // may be empty if no catch
	FinallyBody []GoStmt // may be empty if no finally
	// contains filtered or unexported fields
}

type IRTypeAlias struct {
	Name       string
	Underlying string // Go type string
	TypeParams []IRTypeParam
	IsExported bool
	// contains filtered or unexported fields
}

type IRTypeAssertion struct {
	Expr       GoExpr
	TargetType GoTypeInfo
	Safe       bool // true for val, ok := expr.(Type) pattern
	// contains filtered or unexported fields
}

type IRTypeConversion struct {
	Expr       GoExpr
	TargetType string // Go type string
	// contains filtered or unexported fields
}

type IRTypeOf struct {
	Expr GoExpr
	// contains filtered or unexported fields
}

type IRTypeParam struct {
	Name       string // Go name (PascalCase)
	Constraint string // Go constraint: "any", "comparable", etc.
}

type IRUnaryOp struct {
	Op      string // "!", "-", "^" (bitwise NOT)
	Operand GoExpr
	Postfix bool // true for i++ / i--
	// contains filtered or unexported fields
}

type IRVarDecl struct {
	Name     string
	Typ      GoTypeInfo
	Init     GoExpr // may be nil for zero-value declarations
	IsConst  bool   // const vs var
	UseShort bool   // := vs var
	// contains filtered or unexported fields
}

type IRVarGroupDecl struct {
	Vars []IRVarDecl
	// contains filtered or unexported fields
}

type PackageAnalysis struct {
	Name         string
	Version      string
	EntryFile    string   // Resolved entry point (.ts file)
	SourceFiles  []string // All .ts source files
	IsPureTS     bool
	Dependencies []string
	GoImportPath string // Resolved Go import path for this package
}

type ProjectResult struct {
	// Files maps output file paths (relative to outDir) to Go source code.
	Files  map[string]string
	Errors []string
	// GoImports holds third-party Go module paths imported via go: prefix.
	GoImports []string
}

type TranspileResult struct {
	GoSource string // The generated Go source code
	Errors   []string
}

type Transpiler struct {
	// contains filtered or unexported fields
}

type TypeGenerator struct {
	// contains filtered or unexported fields
}