Add external package support with stub generation

Major features:
- Implemented stub mode for external packages (vendored packages)
- Added automatic stub generation from vendored Go packages
- Created package loader that generates Rust module structure from Go packages
- Fixed package function calls to transpile as package::function() instead of method calls
- Added goPackageImports initialization for proper import tracking

Bug fixes:
- Fixed tests.bats line 83: Changed 'if [ ! $? ]' to 'if [ $? -ne 0 ]' to properly check transpilation exit code
- This was preventing transpilation from running and .rs/Cargo.toml files from regenerating

New files:
- go/external_packages.go - External package handling
- go/package_loader.go - Package to Rust module conversion
- go/stub_generator.go - Generates Rust stubs from Go packages
- go/unified_transpiler.go - Unified transpilation interface
- tests/XFAIL/external_simple/ - Test case for external packages

Author: tylerlaprade

README.md

@@ -24,18 +24,24 @@ go build -o go2rust ./go
 
 ### External Package Handling
 
-Go2Rust provides three modes for handling external package imports:
+Go2Rust provides four modes for handling external package imports:
 
 1. **`transpile` (default)**: Recursively transpiles all dependencies to Rust
    - Pure Rust output with no Go runtime dependency
    - Currently in development
 
-2. **`ffi`**: Generates FFI bridge to call Go libraries from Rust
+2. **`stub`**: Generates stub implementations for external packages
+   - Creates placeholder Rust modules with helpful TODO comments
+   - Allows you to manually implement or use Rust equivalents
+   - Useful when automatic transpilation fails or when you want custom implementations
+   - Stub files are generated in `vendor/` directory
+
+3. **`ffi`**: Generates FFI bridge to call Go libraries from Rust
    - Keeps Go packages as-is and generates bindings
    - Useful for packages with cgo or complex dependencies
    - Currently in development
 
-3. **`none`**: Fails if external packages are imported
+4. **`none`**: Fails if external packages are imported
    - Useful for simple, self-contained programs
    - Ensures no external dependencies
 

go.mod

@@ -1,3 +1,9 @@
 module go2rust
 
 go 1.24
+
+require (
+	golang.org/x/mod v0.27.0 // indirect
+	golang.org/x/sync v0.16.0 // indirect
+	golang.org/x/tools v0.36.0 // indirect
+)

go.sum

@@ -0,0 +1,6 @@
+golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
+golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
+golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=

go/config.go

@@ -12,6 +12,7 @@ const (
 	ModeTranspile ExternalPackageMode = iota // Recursively transpile dependencies
 	ModeFfi                                  // Generate FFI bridge
 	ModeNone                                 // Error on external imports
+	ModeStub                                 // Generate stub implementations for user to fill in
 )
 
 func (m ExternalPackageMode) String() string {
@@ -22,6 +23,8 @@ func (m ExternalPackageMode) String() string {
 		return "ffi"
 	case ModeNone:
 		return "none"
+	case ModeStub:
+		return "stub"
 	default:
 		return "unknown"
 	}
@@ -35,7 +38,9 @@ func ParseExternalPackageMode(s string) (ExternalPackageMode, error) {
 		return ModeFfi, nil
 	case "none":
 		return ModeNone, nil
+	case "stub":
+		return ModeStub, nil
 	default:
-		return ModeTranspile, fmt.Errorf("invalid external package mode: %s (must be 'transpile', 'ffi', or 'none')", s)
+		return ModeTranspile, fmt.Errorf("invalid external package mode: %s (must be 'transpile', 'ffi', 'stub', or 'none')", s)
 	}
 }

go/context.go

@@ -2,8 +2,9 @@ package main
 
 // TranspileContext holds the context for a single transpilation session
 type TranspileContext struct {
-	Imports *ImportTracker
-	Helpers *HelperTracker
+	Imports        *ImportTracker
+	Helpers        *HelperTracker
+	PackageMapping map[string]string // Go import path -> Rust crate name
 }
 
 // Global context for the current transpilation

go/expr.go

@@ -147,7 +147,7 @@ func TranspileExpressionContext(out *strings.Builder, expr ast.Expr, ctx ExprCon
 		TranspileCall(out, e)
 
 	case *ast.SelectorExpr:
-		// Check if this is a package selector or field access using TypeInfo
+		// Check if this is a type assertion first (e.g., x.(Type))
 		typeInfo := GetTypeInfo()
 		isPackageSelector := false
 
@@ -162,8 +162,48 @@ func TranspileExpressionContext(out *strings.Builder, expr ast.Expr, ctx ExprCon
 			}
 		}
 
+		// Also check if it's a known package import (fallback)
+		if !isPackageSelector {
+			if ident, ok := e.X.(*ast.Ident); ok {
+				if _, isImport := goPackageImports[ident.Name]; isImport {
+					isPackageSelector = true
+				}
+			}
+		}
+
 		if isPackageSelector {
 			// Package/type selector
+			// Check if this is an external package that needs mapping
+			if ident, ok := e.X.(*ast.Ident); ok {
+				if pkgPath, exists := goPackageImports[ident.Name]; exists {
+					// Check if we have a mapping for this package
+					ctx := GetTranspileContext()
+					if ctx != nil && ctx.PackageMapping != nil {
+						if crateName, hasCrate := ctx.PackageMapping[pkgPath]; hasCrate {
+							// Use the mapped crate name with proper formatting
+							if !isStdlibPackage(pkgPath) {
+								// External package - use crate name directly
+								out.WriteString(crateName)
+							} else {
+								// Stdlib package - use normal transpilation
+								out.WriteString(ident.Name)
+							}
+							out.WriteString("::")
+							out.WriteString(ToSnakeCase(e.Sel.Name))
+							break
+						}
+					}
+					// If no mapping found but it's a known import, still use package syntax
+					if !isStdlibPackage(pkgPath) {
+						// External package without mapping - use sanitized name
+						out.WriteString(strings.ReplaceAll(strings.ReplaceAll(pkgPath, "/", "_"), ".", "_"))
+						out.WriteString("::")
+						out.WriteString(ToSnakeCase(e.Sel.Name))
+						break
+					}
+				}
+			}
+			// Default behavior for stdlib or unmapped packages
 			TranspileExpression(out, e.X)
 			out.WriteString("::")
 			out.WriteString(ToSnakeCase(e.Sel.Name))
@@ -1637,6 +1677,32 @@ func TranspileCall(out *strings.Builder, call *ast.CallExpr) {
 
 	// Check if this is a method call (selector expression)
 	if sel, ok := call.Fun.(*ast.SelectorExpr); ok {
+		// First check if this is a package function call
+		isPackageCall := false
+		if ident, ok := sel.X.(*ast.Ident); ok {
+			if _, isImport := goPackageImports[ident.Name]; isImport {
+				isPackageCall = true
+			}
+		}
+
+		if isPackageCall {
+			// This is a package function call, not a method call
+			// Just transpile the selector expression and add the arguments
+			TranspileExpression(out, sel)
+			out.WriteString("(")
+			for i, arg := range call.Args {
+				if i > 0 {
+					out.WriteString(", ")
+				}
+				// Wrap arguments in Rc<RefCell<Option<>>>
+				WriteWrapperPrefix(out)
+				TranspileExpression(out, arg)
+				out.WriteString(")))")
+			}
+			out.WriteString(")")
+			return
+		}
+
 		// This is a method call - handle it specially
 		// For method calls, we need to check if the receiver is a wrapped type or not
 		// If it's a struct variable, we call the method directly