Detect external packages

Signed-off-by: Tyler Laprade <[email protected]>

Author: tylerlaprade

README.md

@@ -13,10 +13,32 @@ go build -o go2rust ./go
 # Transpile a Go file
 ./go2rust input.go > output.rs
 
+# Transpile with external package handling
+./go2rust --external-packages=transpile input.go  # Recursively transpile dependencies (default)
+./go2rust --external-packages=ffi input.go        # Generate FFI bridge to Go libraries
+./go2rust --external-packages=none input.go       # Error on external imports
+
 # Run tests
 ./test.sh
 ```
 
+### External Package Handling
+
+Go2Rust provides three 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
+   - 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
+   - Useful for simple, self-contained programs
+   - Ensures no external dependencies
+
 ## Example
 
 **Input (Go):**

go/config.go

@@ -1,3 +1,41 @@
 package main
 
-// This file is kept for potential future configuration needs
+import (
+	"fmt"
+	"strings"
+)
+
+// ExternalPackageMode defines how to handle external package imports
+type ExternalPackageMode int
+
+const (
+	ModeTranspile ExternalPackageMode = iota // Recursively transpile dependencies
+	ModeFfi                                  // Generate FFI bridge
+	ModeNone                                 // Error on external imports
+)
+
+func (m ExternalPackageMode) String() string {
+	switch m {
+	case ModeTranspile:
+		return "transpile"
+	case ModeFfi:
+		return "ffi"
+	case ModeNone:
+		return "none"
+	default:
+		return "unknown"
+	}
+}
+
+func ParseExternalPackageMode(s string) (ExternalPackageMode, error) {
+	switch strings.ToLower(s) {
+	case "transpile":
+		return ModeTranspile, nil
+	case "ffi":
+		return ModeFfi, nil
+	case "none":
+		return ModeNone, nil
+	default:
+		return ModeTranspile, fmt.Errorf("invalid external package mode: %s (must be 'transpile', 'ffi', or 'none')", s)
+	}
+}

go/main.go

@@ -1,21 +1,42 @@
 package main
 
 import (
+	"flag"
 	"fmt"
 	"os"
 	"path/filepath"
 	"sort"
 	"strings"
 )
 
+var (
+	externalPackagesFlag = flag.String("external-packages", "transpile", "How to handle external packages: transpile, ffi, or none")
+	helpFlag             = flag.Bool("help", false, "Show help message")
+)
+
 func main() {
-	if len(os.Args) < 2 {
-		fmt.Fprintf(os.Stderr, "Usage: %s <go-file-or-directory>...\n", os.Args[0])
+	flag.Parse()
+
+	if *helpFlag {
+		showHelp()
+		os.Exit(0)
+	}
+
+	externalMode, err := ParseExternalPackageMode(*externalPackagesFlag)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+
+	args := flag.Args()
+	if len(args) == 0 {
+		fmt.Fprintf(os.Stderr, "Usage: %s [options] <go-file-or-directory>...\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "Run '%s -help' for more information\n", os.Args[0])
 		os.Exit(1)
 	}
 
 	var goFiles []string
-	for _, arg := range os.Args[1:] {
+	for _, arg := range args {
 		files, err := collectGoFiles(arg)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error processing %s: %v\n", arg, err)
@@ -46,13 +67,32 @@ func main() {
 		os.Exit(1)
 	}
 
-	err := generator.Generate()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+	// Set the external package mode
+	generator.SetExternalPackageMode(externalMode)
+
+	genErr := generator.Generate()
+	if genErr != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", genErr)
 		os.Exit(1)
 	}
 }
 
+func showHelp() {
+	fmt.Printf("go2rust - Go to Rust transpiler\n\n")
+	fmt.Printf("Usage: %s [options] <go-file-or-directory>...\n\n", os.Args[0])
+	fmt.Printf("Options:\n")
+	fmt.Printf("  -external-packages <mode>  How to handle external packages (default: transpile)\n")
+	fmt.Printf("                             Modes:\n")
+	fmt.Printf("                               transpile - Recursively transpile all dependencies\n")
+	fmt.Printf("                               ffi       - Generate FFI bridge to Go libraries\n")
+	fmt.Printf("                               none      - Error on external imports\n")
+	fmt.Printf("  -help                      Show this help message\n\n")
+	fmt.Printf("Examples:\n")
+	fmt.Printf("  %s main.go                                    # Transpile with default settings\n", os.Args[0])
+	fmt.Printf("  %s -external-packages=ffi ./cmd/myapp        # Use FFI for external packages\n", os.Args[0])
+	fmt.Printf("  %s -external-packages=none simple.go         # Fail on external imports\n", os.Args[0])
+}
+
 func collectGoFiles(path string) ([]string, error) {
 	info, err := os.Stat(path)
 	if err != nil {

go/project.go

@@ -19,6 +19,8 @@ type ProjectGenerator struct {
 	moduleNames    []string
 	typeInfo       *TypeInfo
 	projectImports *ImportTracker // Collect imports across all files
+	externalMode   ExternalPackageMode
+	goImports      map[string][]string // package path -> list of imports
 }
 
 func NewProjectGenerator(goFiles []string) *ProjectGenerator {
@@ -29,10 +31,44 @@ func NewProjectGenerator(goFiles []string) *ProjectGenerator {
 		goFiles:        goFiles,
 		projectPath:    filepath.Dir(goFiles[0]),
 		projectImports: NewImportTracker(),
+		externalMode:   ModeTranspile, // Default to transpile mode
+		goImports:      make(map[string][]string),
 	}
 }
 
+// SetExternalPackageMode sets how external packages should be handled
+func (pg *ProjectGenerator) SetExternalPackageMode(mode ExternalPackageMode) {
+	pg.externalMode = mode
+}
+
+// checkForExternalPackages scans for external package imports when mode is 'none'
+func (pg *ProjectGenerator) checkForExternalPackages() error {
+	fileSet := token.NewFileSet()
+
+	for _, filename := range pg.goFiles {
+		file, err := parser.ParseFile(fileSet, filename, nil, parser.ImportsOnly)
+		if err != nil {
+			continue // Skip files with parse errors
+		}
+
+		for _, imp := range file.Imports {
+			path := strings.Trim(imp.Path.Value, `"`)
+			if !isStdlibPackage(path) {
+				return fmt.Errorf("external package import not allowed with --external-packages=none: %s in %s", path, filename)
+			}
+		}
+	}
+
+	return nil
+}
+
 func (pg *ProjectGenerator) Generate() error {
+	// Check for external packages first if mode is 'none'
+	if pg.externalMode == ModeNone {
+		if err := pg.checkForExternalPackages(); err != nil {
+			return err
+		}
+	}
 	fileSet := token.NewFileSet()
 
 	// Parse all files first for type checking
@@ -75,7 +111,15 @@ func (pg *ProjectGenerator) Generate() error {
 			pg.isLibrary = pg.packageName != "main"
 		}
 
-		rustCode, fileImports := Transpile(file, fileSet, pg.typeInfo)
+		rustCode, fileImports, fileExternalPkgs := Transpile(file, fileSet, pg.typeInfo)
+
+		// Track external packages found
+		for pkg := range fileExternalPkgs {
+			if pg.goImports[filename] == nil {
+				pg.goImports[filename] = []string{}
+			}
+			pg.goImports[filename] = append(pg.goImports[filename], pkg)
+		}
 
 		// Merge file imports into project imports
 		if fileImports != nil {
@@ -110,6 +154,33 @@ func (pg *ProjectGenerator) Generate() error {
 		pg.moduleNames = append(pg.moduleNames, outputName)
 	}
 
+	// Handle external packages based on mode
+	if len(pg.goImports) > 0 && pg.hasExternalPackages() {
+		switch pg.externalMode {
+		case ModeTranspile:
+			// TODO: Implement recursive transpilation
+			fmt.Fprintf(os.Stderr, "Warning: Recursive transpilation of external packages not yet implemented\n")
+			fmt.Fprintf(os.Stderr, "External packages found:\n")
+			for _, imports := range pg.goImports {
+				for _, pkg := range imports {
+					fmt.Fprintf(os.Stderr, "  - %s\n", pkg)
+				}
+			}
+		case ModeFfi:
+			// TODO: Implement FFI bridge generation
+			fmt.Fprintf(os.Stderr, "Warning: FFI bridge generation not yet implemented\n")
+			fmt.Fprintf(os.Stderr, "External packages found:\n")
+			for _, imports := range pg.goImports {
+				for _, pkg := range imports {
+					fmt.Fprintf(os.Stderr, "  - %s\n", pkg)
+				}
+			}
+		case ModeNone:
+			// This should have been caught earlier, but double-check
+			return fmt.Errorf("external packages found but mode is 'none'")
+		}
+	}
+
 	// Second pass: generate main.rs or lib.rs with module declarations
 	if pg.hasMain {
 		err := pg.generateMainRs(fileSet, astFiles)
@@ -126,6 +197,16 @@ func (pg *ProjectGenerator) Generate() error {
 	return pg.generateCargoToml()
 }
 
+// hasExternalPackages checks if any external packages were found
+func (pg *ProjectGenerator) hasExternalPackages() bool {
+	for _, imports := range pg.goImports {
+		if len(imports) > 0 {
+			return true
+		}
+	}
+	return false
+}
+
 func (pg *ProjectGenerator) hasMainFile() bool {
 	for _, file := range pg.goFiles {
 		if filepath.Base(file) == "main.go" {
@@ -162,7 +243,24 @@ func (pg *ProjectGenerator) generateMainRs(fileSet *token.FileSet, astFiles []*a
 		mainRust.WriteString("\n")
 	}
 
-	mainContent, mainImports := Transpile(file, fileSet, pg.typeInfo)
+	mainContent, mainImports, mainExternalPkgs := Transpile(file, fileSet, pg.typeInfo)
+
+	// Track external packages from main
+	mainPath := ""
+	for _, fname := range pg.goFiles {
+		if filepath.Base(fname) == "main.go" {
+			mainPath = fname
+			break
+		}
+	}
+	if mainPath != "" {
+		for pkg := range mainExternalPkgs {
+			if pg.goImports[mainPath] == nil {
+				pg.goImports[mainPath] = []string{}
+			}
+			pg.goImports[mainPath] = append(pg.goImports[mainPath], pkg)
+		}
+	}
 
 	// Merge main imports into project imports
 	if mainImports != nil {

go/transpile.go

@@ -36,6 +36,13 @@ var typeDefinitions = make(map[string]string) // maps type name to underlying ty
 // typeAliases tracks which types are type aliases
 var typeAliases = make(map[string]bool)
 
+// goPackageImports tracks imported Go packages for the current file
+// map[alias]packagePath (alias can be empty for default)
+var goPackageImports = make(map[string]string)
+
+// externalPackages tracks external (non-stdlib) package imports
+var externalPackages = make(map[string]bool)
+
 // structDefs tracks struct definitions and their fields
 type StructDef struct {
 	Fields        map[string]string // field name -> field type
@@ -55,6 +62,31 @@ type FieldAccessInfo struct {
 	FieldName    string   // The actual field name (snake_case)
 }
 
+// trackGoImport tracks a Go import statement
+func trackGoImport(packagePath string, nameIdent *ast.Ident) {
+	// Determine the alias (if any)
+	var alias string
+	if nameIdent != nil {
+		if nameIdent.Name == "_" {
+			// Blank import - ignore for now
+			return
+		}
+		alias = nameIdent.Name
+	} else {
+		// Default alias is the last component of the path
+		parts := strings.Split(packagePath, "/")
+		alias = parts[len(parts)-1]
+	}
+
+	// Track the import
+	goPackageImports[alias] = packagePath
+
+	// Check if it's an external package (not stdlib)
+	if !isStdlibPackage(packagePath) {
+		externalPackages[packagePath] = true
+	}
+}
+
 // resolveFieldAccess finds the path to access a field, considering embedded structs
 func resolveFieldAccess(structType string, fieldName string) FieldAccessInfo {
 	// Check if it's a direct field
@@ -301,11 +333,15 @@ func implementsInterface(typeMethods []*ast.FuncDecl, iface *ast.InterfaceType)
 	return true
 }
 
-func Transpile(file *ast.File, fileSet *token.FileSet, typeInfo *TypeInfo) (string, *ImportTracker) {
+func Transpile(file *ast.File, fileSet *token.FileSet, typeInfo *TypeInfo) (string, *ImportTracker, map[string]bool) {
 	// Create trackers
 	imports := NewImportTracker()
 	helpers := &HelperTracker{}
 
+	// Clear import tracking for this file
+	goPackageImports = make(map[string]string)
+	externalPackages = make(map[string]bool)
+
 	// Initialize the statement preprocessor
 	statementPreprocessor = NewStatementPreprocessor(fileSet)
 
@@ -348,6 +384,15 @@ func Transpile(file *ast.File, fileSet *token.FileSet, typeInfo *TypeInfo) (stri
 			}
 		case *ast.GenDecl:
 			switch d.Tok {
+			case token.IMPORT:
+				// Track imports for external package handling
+				for _, spec := range d.Specs {
+					if importSpec, ok := spec.(*ast.ImportSpec); ok {
+						path := strings.Trim(importSpec.Path.Value, `"`)
+						// Track this import (will be handled based on external package mode)
+						trackGoImport(path, importSpec.Name)
+					}
+				}
 			case token.TYPE:
 				for _, spec := range d.Specs {
 					if typeSpec, ok := spec.(*ast.TypeSpec); ok {
@@ -609,5 +654,5 @@ func Transpile(file *ast.File, fileSet *token.FileSet, typeInfo *TypeInfo) (stri
 	}
 	output.WriteString(body.String())
 
-	return output.String(), imports
+	return output.String(), imports, externalPackages
 }