goscript 0.0.58 → 0.0.60

package/compiler/expr-call.go

@@ -169,7 +169,7 @@ func (c *GoToTSCompiler) writeCallArguments(exp *ast.CallExpr) error {
 func (c *GoToTSCompiler) writeArgumentWithTypeHandling(arg ast.Expr, funcSig *types.Signature, argIndex int) error {
 	if funcSig != nil && argIndex < funcSig.Params().Len() {
 		paramType := funcSig.Params().At(argIndex).Type()
-		isWrapper := c.analysis.IsNamedBasicType(paramType)
+		isWrapper := c.isWrapperType(paramType)
 
 		if isWrapper {
 			// For wrapper types (now type aliases), no auto-wrapping is needed
@@ -202,7 +202,52 @@ func (c *GoToTSCompiler) writeArgumentWithTypeHandling(arg ast.Expr, funcSig *ty
 	return nil
 }
 
+// resolveImportAlias returns the import alias for a given package
+// This is the single source of truth for import alias resolution
+func (c *GoToTSCompiler) resolveImportAlias(pkg *types.Package) (alias string, found bool) {
+	if c.analysis == nil || pkg == nil {
+		return "", false
+	}
+
+	pkgName := pkg.Name()
+
+	// Try to match by the actual package name
+	if _, exists := c.analysis.Imports[pkgName]; exists {
+		return pkgName, true
+	}
+
+	return "", false
+}
+
+// getQualifiedTypeName returns the qualified type name for a Named or Alias type
+// Returns empty string if the type is not Named or Alias, or has no valid object
+func (c *GoToTSCompiler) getQualifiedTypeName(t types.Type) string {
+	var obj *types.TypeName
+
+	if namedType, ok := t.(*types.Named); ok {
+		obj = namedType.Obj()
+	} else if aliasType, ok := t.(*types.Alias); ok {
+		obj = aliasType.Obj()
+	}
+
+	if obj == nil || obj.Pkg() == nil {
+		return ""
+	}
+
+	if obj.Pkg() != c.pkg.Types {
+		// Imported type
+		if alias, found := c.resolveImportAlias(obj.Pkg()); found {
+			return alias + "." + obj.Name()
+		}
+		return obj.Name()
+	}
+
+	// Local type
+	return obj.Name()
+}
+
 // getImportAlias returns the import alias for a given package path
+// Deprecated: use resolveImportAlias instead for better type safety
 func (c *GoToTSCompiler) getImportAlias(pkgPath string) string {
 	if c.analysis == nil {
 		return ""
@@ -234,7 +279,7 @@ func (c *GoToTSCompiler) getImportAlias(pkgPath string) string {
 func (c *GoToTSCompiler) writeAutoWrappedArgument(arg ast.Expr, expectedType types.Type) error {
 	// For wrapper types (now type aliases), no auto-wrapping is needed
 	// Just use type casting if the types don't match exactly
-	if c.analysis.IsNamedBasicType(expectedType) {
+	if c.isWrapperType(expectedType) {
 		argType := c.pkg.TypesInfo.TypeOf(arg)
 
 		// Only add type casting if needed
@@ -272,73 +317,12 @@ func (c *GoToTSCompiler) writeWrapperTypeMethodCall(exp *ast.CallExpr, selectorE
 	}
 
 	// Check if this is a wrapper type using the analysis
-	isWrapperType := c.analysis.IsNamedBasicType(baseType)
-
-	// Special handling for type aliases to basic types that might have wrapper functions
-	// Even if IsNamedBasicType returns false, we should check for known wrapper type patterns
-	var typeName string
-	if !isWrapperType {
-		// Check if this is a type alias to a basic type that might have wrapper methods
-		if aliasType, ok := baseType.(*types.Alias); ok {
-			if aliasType.Obj() != nil && aliasType.Obj().Pkg() != nil {
-				// Check if the underlying type is a basic type
-				underlying := aliasType.Underlying()
-				if _, isBasic := underlying.(*types.Basic); isBasic {
-					// This is a type alias to a basic type - treat it as a potential wrapper type
-					isWrapperType = true
-					if aliasType.Obj().Pkg() != c.pkg.Types {
-						// Imported type alias like os.FileMode
-						if importAlias := c.getImportAlias(aliasType.Obj().Pkg().Path()); importAlias != "" {
-							typeName = importAlias + "." + aliasType.Obj().Name()
-						} else {
-							typeName = aliasType.Obj().Name()
-						}
-					} else {
-						// Local type alias
-						typeName = aliasType.Obj().Name()
-					}
-				}
-			}
-		}
-	}
-
-	if !isWrapperType {
+	if !c.isWrapperType(baseType) {
 		return false, nil
 	}
 
-	// Get the type name for the function call if not already set
-	if typeName == "" {
-		if namedType, ok := baseType.(*types.Named); ok {
-			if obj := namedType.Obj(); obj != nil {
-				if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
-					// Imported type like os.FileMode
-					if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
-						typeName = importAlias + "." + obj.Name()
-					} else {
-						typeName = obj.Name()
-					}
-				} else {
-					// Local type
-					typeName = obj.Name()
-				}
-			}
-		} else if aliasType, ok := baseType.(*types.Alias); ok {
-			if obj := aliasType.Obj(); obj != nil {
-				if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
-					// Imported type alias
-					if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
-						typeName = importAlias + "." + obj.Name()
-					} else {
-						typeName = obj.Name()
-					}
-				} else {
-					// Local type alias
-					typeName = obj.Name()
-				}
-			}
-		}
-	}
-
+	// Get the qualified type name for the function call
+	typeName := c.getQualifiedTypeName(baseType)
 	if typeName == "" {
 		return false, nil
 	}
@@ -369,9 +353,26 @@ func (c *GoToTSCompiler) writeWrapperTypeMethodCall(exp *ast.CallExpr, selectorE
 	}
 
 	if receiverNeedsVarRef {
-		// For pointer receivers, we need to pass the VarRef
-		// Convert p.field to p._fields.field
-		if selExpr, ok := selectorExpr.X.(*ast.SelectorExpr); ok {
+		// For pointer receivers, we need to pass the VarRef (not the value)
+		// Check if the receiver expression is an identifier that's already a VarRef
+		if ident, ok := selectorExpr.X.(*ast.Ident); ok {
+			if obj := c.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+				if c.analysis != nil && c.analysis.NeedsVarRef(obj) {
+					// This variable is already a VarRef, pass it directly
+					c.tsw.WriteLiterally(ident.Name)
+				} else {
+					// Not a VarRef, write the value expression
+					if err := c.WriteValueExpr(selectorExpr.X); err != nil {
+						return true, fmt.Errorf("failed to write wrapper type method receiver: %w", err)
+					}
+				}
+			} else {
+				if err := c.WriteValueExpr(selectorExpr.X); err != nil {
+					return true, fmt.Errorf("failed to write wrapper type method receiver: %w", err)
+				}
+			}
+		} else if selExpr, ok := selectorExpr.X.(*ast.SelectorExpr); ok {
+			// Convert p.field to p._fields.field for struct field access
 			if baseIdent, ok := selExpr.X.(*ast.Ident); ok {
 				c.tsw.WriteLiterally(baseIdent.Name)
 				c.tsw.WriteLiterally("._fields.")

package/compiler/expr-selector.go

@@ -130,30 +130,9 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 	// In Go, accessing fields or calling methods on nil pointers/interfaces panics, so we should throw in TypeScript
 	baseType := c.pkg.TypesInfo.TypeOf(exp.X)
 
-	// Special case: Check if this is a method receiver alias (e.g., `b` in `const b = this`)
-	// In this case, we should use regular field access instead of pointer access
-	isMethodReceiverAlias := false
-	if baseIdent, ok := exp.X.(*ast.Ident); ok {
-		// Check if this identifier refers to a method receiver
-		// Method receivers are typically named variables that alias `this`
-		if obj := c.pkg.TypesInfo.ObjectOf(baseIdent); obj != nil {
-			if varObj, ok := obj.(*types.Var); ok {
-				// Check if this is a local variable in a method context
-				// Method receiver aliases are local variables with pointer types that represent `this`
-				if _, isPtr := varObj.Type().(*types.Pointer); isPtr {
-					// Additional check: only consider it a method receiver alias if the variable name
-					// suggests it's an alias (single letter names are common for aliases like `b`, `r`, etc.)
-					// and it's not a common variable name like `f` which is often used for regular variables
-					varName := baseIdent.Name
-					if len(varName) == 1 && varName != "f" {
-						// This is likely a method receiver alias like `const b = this`
-						// We should treat it as a regular object access, not a pointer access
-						isMethodReceiverAlias = true
-					}
-				}
-			}
-		}
-	}
+	// Check if this is a method receiver alias (e.g., `c` in `const c = this`)
+	// Use proper AST/types analysis instead of heuristics
+	isMethodReceiverAlias := c.isReceiverAlias(exp.X)
 
 	if baseType != nil && !isMethodReceiverAlias {
 		// Check if the base is a pointer type
@@ -274,3 +253,21 @@ func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *type
 
 	return nil
 }
+
+// isReceiverAlias detects if a variable is likely a receiver alias (e.g., const c = this)
+// These variables are guaranteed to be non-null and don't need null assertions
+func (c *GoToTSCompiler) isReceiverAlias(expr ast.Expr) bool {
+	// Only check identifiers - receiver aliases are always identifiers
+	ident, ok := expr.(*ast.Ident)
+	if !ok {
+		return false
+	}
+
+	// If analysis marked this identifier with a mapping, treat it as a receiver alias
+	if mapped := c.analysis.GetIdentifierMapping(ident); mapped != "" {
+		return true
+	}
+
+	// Fallback conservative behavior
+	return false
+}

package/compiler/expr.go

@@ -19,7 +19,7 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 			// Check if the index is a type expression (identifier that refers to a type)
 			if indexIdent, isIdent := exp.Index.(*ast.Ident); isIdent {
 				// Check if this identifier refers to a type
-				if obj := c.pkg.TypesInfo.Uses[indexIdent]; obj != nil {
+				if obj := c.objectOfIdent(indexIdent); obj != nil {
 					if _, isTypeName := obj.(*types.TypeName); isTypeName {
 						// This is a generic function instantiation: f[T] -> f<T>
 						if err := c.WriteValueExpr(exp.X); err != nil {
@@ -57,7 +57,7 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 		}
 
 		// Check if it's a string type
-		if basicType, isBasic := underlyingType.(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
+		if c.isStringType(tv.Type) {
 			c.tsw.WriteLiterally("$.indexString(")
 			if err := c.WriteValueExpr(exp.X); err != nil {
 				return err
@@ -279,21 +279,6 @@ func (c *GoToTSCompiler) getFinalUnderlyingType(t types.Type) (types.Type, bool)
 	}
 }
 
-// isNamedNumericType checks if a given type is a named type with an underlying numeric type.
-func (c *GoToTSCompiler) isNamedNumericType(t types.Type) bool {
-	finalType, wasNamed := c.getFinalUnderlyingType(t)
-	if !wasNamed {
-		return false
-	}
-
-	if basicType, isBasic := finalType.(*types.Basic); isBasic {
-		info := basicType.Info()
-		return (info&types.IsInteger) != 0 || (info&types.IsFloat) != 0
-	}
-
-	return false
-}
-
 // WriteBinaryExpr translates a Go binary expression (`ast.BinaryExpr`) into its
 // TypeScript equivalent.
 // It handles several cases:
@@ -628,9 +613,7 @@ func (c *GoToTSCompiler) WriteSliceExpr(exp *ast.SliceExpr) error {
 	isString := false
 	isTypeParam := false
 	if tv != nil {
-		if basicType, isBasic := tv.Underlying().(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
-			isString = true
-		}
+		isString = c.isStringType(tv)
 		if _, isTP := tv.(*types.TypeParam); isTP {
 			isTypeParam = true
 		}
@@ -755,43 +738,3 @@ func (c *GoToTSCompiler) WriteKeyValueExpr(exp *ast.KeyValueExpr) error {
 	}
 	return nil
 }
-
-// hasMapConstraint checks if an interface constraint includes map types
-// For constraints like ~map[K]V, this returns true
-func hasMapConstraint(iface *types.Interface) bool {
-	// Check if the interface has type terms that include map types
-	for i := 0; i < iface.NumEmbeddeds(); i++ {
-		embedded := iface.EmbeddedType(i)
-		if union, ok := embedded.(*types.Union); ok {
-			for j := 0; j < union.Len(); j++ {
-				term := union.Term(j)
-				if _, isMap := term.Type().Underlying().(*types.Map); isMap {
-					return true
-				}
-			}
-		} else if _, isMap := embedded.Underlying().(*types.Map); isMap {
-			return true
-		}
-	}
-	return false
-}
-
-// getMapValueTypeFromConstraint extracts the value type from a map constraint
-// For constraints like ~map[K]V, this returns V
-func getMapValueTypeFromConstraint(iface *types.Interface) types.Type {
-	// Check if the interface has type terms that include map types
-	for i := 0; i < iface.NumEmbeddeds(); i++ {
-		embedded := iface.EmbeddedType(i)
-		if union, ok := embedded.(*types.Union); ok {
-			for j := 0; j < union.Len(); j++ {
-				term := union.Term(j)
-				if mapType, isMap := term.Type().Underlying().(*types.Map); isMap {
-					return mapType.Elem()
-				}
-			}
-		} else if mapType, isMap := embedded.Underlying().(*types.Map); isMap {
-			return mapType.Elem()
-		}
-	}
-	return nil
-}

package/compiler/protobuf.go

@@ -12,29 +12,37 @@ import (
 	"golang.org/x/tools/go/packages"
 )
 
-// isProtobufType checks if a given type is a protobuf type by examining its package and name
-func (c *GoToTSCompiler) isProtobufType(typ types.Type) bool {
-	if namedType, ok := typ.(*types.Named); ok {
-		obj := namedType.Obj()
-		if obj != nil && obj.Pkg() != nil {
-			// Check if the type is defined in the current package and has a corresponding .pb.ts file
-			if obj.Pkg() == c.pkg.Types {
-				// Check if there's a .pb.ts file in the package that exports this type
-				// For now, we'll use a simple heuristic: if the type name ends with "Msg"
-				// and there's a .pb.ts file in the package, assume it's a protobuf type
-				typeName := obj.Name()
-				if strings.HasSuffix(typeName, "Msg") {
-					// Check if there are any .pb.ts files in this package
-					for _, fileName := range c.pkg.CompiledGoFiles {
-						if strings.HasSuffix(fileName, ".pb.go") {
-							return true
-						}
-					}
-				}
-			}
+// getProtobufMessageInterface attempts to find the protobuf-go-lite Message interface
+// from the loaded packages in analysis. Returns nil if not found.
+func (c *GoToTSCompiler) getProtobufMessageInterface() *types.Interface {
+	if c.analysis == nil || c.analysis.AllPackages == nil {
+		return nil
+	}
+	pkg := c.analysis.AllPackages["github.com/aperturerobotics/protobuf-go-lite"]
+	if pkg == nil || pkg.Types == nil {
+		return nil
+	}
+	obj := pkg.Types.Scope().Lookup("Message")
+	if obj == nil {
+		return nil
+	}
+	if tn, ok := obj.(*types.TypeName); ok {
+		if iface, ok := tn.Type().Underlying().(*types.Interface); ok {
+			return iface
 		}
 	}
-	return false
+	return nil
+}
+
+// typeHasMethods returns true if the given type's method set contains all the specified names.
+func (c *GoToTSCompiler) typeHasMethods(t types.Type, names ...string) bool {
+	mset := types.NewMethodSet(t)
+	for _, name := range names {
+		if mset.Lookup(nil, name) == nil {
+			return false
+		}
+	}
+	return true
 }
 
 // convertProtobufFieldName converts Go PascalCase field names to TypeScript camelCase
@@ -44,9 +52,11 @@ func (c *GoToTSCompiler) convertProtobufFieldName(goFieldName string) string {
 		return goFieldName
 	}
 
-	// Convert first character to lowercase
+	// Convert first character to lowercase if ASCII uppercase
 	runes := []rune(goFieldName)
-	runes[0] = runes[0] + ('a' - 'A')
+	if runes[0] >= 'A' && runes[0] <= 'Z' {
+		runes[0] = runes[0] + ('a' - 'A')
+	}
 	return string(runes)
 }
 
@@ -119,18 +129,104 @@ func (c *PackageCompiler) copyProtobufTSFile(sourcePath, fileName string) error
 
 // writeProtobufExports writes exports for a protobuf file to the index.ts file
 func (c *PackageCompiler) writeProtobufExports(indexFile *os.File, fileName string) error {
-	// For protobuf files, we know they typically export message types
-	// For now, we'll use a simple heuristic: export all types that end with "Msg"
-	// In a full implementation, we would parse the .pb.ts file to extract actual exports
-
-	// For the protobuf_lite_ts test, we know it exports ExampleMsg
-	// This is a simplified approach - in production, we'd parse the .pb.ts file
-	exportLine := fmt.Sprintf("export { ExampleMsg, protobufPackage } from \"./%s.js\"\n", fileName)
-	if _, err := indexFile.WriteString(exportLine); err != nil {
+	// For protobuf files, try to parse the copied .pb.ts file in the output directory
+	// to discover exported symbols and re-export them from the index. This avoids
+	// hard-coding names like ExampleMsg and protobufPackage.
+
+	pbTsPath := filepath.Join(c.outputPath, fileName+".ts")
+	content, err := os.ReadFile(pbTsPath)
+	if err != nil {
 		return err
 	}
 
-	return nil
+	// Very simple export discovery: capture names from
+	//  - export const Name
+	//  - export interface Name
+	//  - export class Name
+	//  - export function Name
+	// We avoid type-only exports for now.
+	var exports []string
+	lines := strings.Split(string(content), "\n")
+	for _, ln := range lines {
+		l := strings.TrimSpace(ln)
+		if strings.HasPrefix(l, "export const ") {
+			rest := strings.TrimPrefix(l, "export const ")
+			name := takeIdent(rest)
+			if name != "" {
+				exports = append(exports, name)
+			}
+			continue
+		}
+		if strings.HasPrefix(l, "export interface ") {
+			rest := strings.TrimPrefix(l, "export interface ")
+			name := takeIdent(rest)
+			if name != "" {
+				exports = append(exports, name)
+			}
+			continue
+		}
+		if strings.HasPrefix(l, "export class ") {
+			rest := strings.TrimPrefix(l, "export class ")
+			name := takeIdent(rest)
+			if name != "" {
+				exports = append(exports, name)
+			}
+			continue
+		}
+		if strings.HasPrefix(l, "export function ") {
+			rest := strings.TrimPrefix(l, "export function ")
+			name := takeIdent(rest)
+			if name != "" {
+				exports = append(exports, name)
+			}
+			continue
+		}
+	}
+
+	// If nothing found, fallback to default
+	if len(exports) == 0 {
+		return fmt.Errorf("no exported symbols discovered in %s.ts while generating protobuf exports", fileName)
+	}
+
+	// Deduplicate while preserving order
+	seen := map[string]bool{}
+	uniq := make([]string, 0, len(exports))
+	for _, n := range exports {
+		if !seen[n] {
+			seen[n] = true
+			uniq = append(uniq, n)
+		}
+	}
+
+	exportLine := fmt.Sprintf("export { %s } from \"./%s.js\"\n", strings.Join(uniq, ", "), fileName)
+	_, err = indexFile.WriteString(exportLine)
+	return err
+}
+
+// takeIdent extracts a leading identifier token from the beginning of s.
+// Returns an empty string if no valid identifier is found.
+func takeIdent(s string) string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return ""
+	}
+	// Identifier: letter or _ followed by letters, digits, or _
+	var b strings.Builder
+	for i, r := range s {
+		if i == 0 {
+			if !(r == '_' || r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z') {
+				break
+			}
+			b.WriteRune(r)
+			continue
+		}
+		if r == '_' || r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z' || r >= '0' && r <= '9' {
+			b.WriteRune(r)
+			continue
+		}
+		break
+	}
+	return b.String()
 }
 
 // addProtobufImports adds imports for protobuf types when .pb.ts files are present in the package
@@ -146,11 +242,59 @@ func (c *FileCompiler) addProtobufImports() error {
 			pbTsPath := filepath.Join(packageDir, pbTsFileName)
 
 			if _, err := os.Stat(pbTsPath); err == nil {
-				// .pb.ts file exists, add imports for protobuf types
+				// .pb.ts file exists, parse it for exports and add imports accordingly
 				pbBaseName := strings.TrimSuffix(baseFileName, ".pb.go")
-				c.codeWriter.WriteLinef("import { ExampleMsg } from \"./%s.pb.js\";", pbBaseName)
-				// Note: This is a simplified approach - in a full implementation,
-				// we would parse the .pb.ts file to extract all exported types
+
+				content, rerr := os.ReadFile(pbTsPath)
+				if rerr != nil {
+					return fmt.Errorf("failed to read %s for protobuf imports: %w", pbTsPath, rerr)
+				}
+
+				// Discover exported identifiers (const/interface/class/function)
+				var exports []string
+				for _, ln := range strings.Split(string(content), "\n") {
+					l := strings.TrimSpace(ln)
+					if strings.HasPrefix(l, "export const ") {
+						if name := takeIdent(strings.TrimPrefix(l, "export const ")); name != "" {
+							exports = append(exports, name)
+						}
+						continue
+					}
+					if strings.HasPrefix(l, "export interface ") {
+						if name := takeIdent(strings.TrimPrefix(l, "export interface ")); name != "" {
+							exports = append(exports, name)
+						}
+						continue
+					}
+					if strings.HasPrefix(l, "export class ") {
+						if name := takeIdent(strings.TrimPrefix(l, "export class ")); name != "" {
+							exports = append(exports, name)
+						}
+						continue
+					}
+					if strings.HasPrefix(l, "export function ") {
+						if name := takeIdent(strings.TrimPrefix(l, "export function ")); name != "" {
+							exports = append(exports, name)
+						}
+						continue
+					}
+				}
+
+				if len(exports) == 0 {
+					return fmt.Errorf("no exported symbols discovered in %s for protobuf imports", pbTsPath)
+				}
+
+				// Deduplicate
+				seen := map[string]bool{}
+				uniq := make([]string, 0, len(exports))
+				for _, n := range exports {
+					if !seen[n] {
+						seen[n] = true
+						uniq = append(uniq, n)
+					}
+				}
+
+				c.codeWriter.WriteLinef("import { %s } from \"./%s.pb.js\";", strings.Join(uniq, ", "), pbBaseName)
 				break
 			}
 		}