refactor: remove wrapper types for named basic types

Signed-off-by: Christian Stewart <[email protected]>

Author: paralin

compiler/analysis.go

@@ -115,6 +115,10 @@ type Analysis struct {
 
 	// PackageMetadata holds package-level metadata
 	PackageMetadata map[string]interface{}
+
+	// WrapperTypes tracks types that should be implemented as wrapper classes
+	// This includes both local types with methods and imported types that are known wrapper types
+	WrapperTypes map[types.Type]bool
 }
 
 // PackageAnalysis holds cross-file analysis data for a package
@@ -147,6 +151,7 @@ func NewAnalysis() *Analysis {
 		ReflectedFunctions:  make(map[ast.Node]*ReflectedFunctionInfo),
 		FunctionAssignments: make(map[types.Object]ast.Node),
 		PackageMetadata:     make(map[string]interface{}),
+		WrapperTypes:        make(map[types.Type]bool),
 	}
 }
 
@@ -1581,3 +1586,91 @@ func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map
 		// For now, we'll ignore them as they're less common in shadowing scenarios
 	}
 }
+
+// IsWrapperType returns whether the given type should be implemented as a wrapper class
+// This includes both local types with methods and imported types that are known wrapper types
+func (a *Analysis) IsWrapperType(t types.Type) bool {
+	if t == nil {
+		return false
+	}
+
+	// Check if we've already determined this type is a wrapper type
+	if isWrapper, exists := a.WrapperTypes[t]; exists {
+		return isWrapper
+	}
+
+	// For named types, check if they have methods
+	if namedType, ok := t.(*types.Named); ok {
+		// Exclude struct types - they should remain as classes, not wrapper types
+		if _, isStruct := namedType.Underlying().(*types.Struct); isStruct {
+			a.WrapperTypes[t] = false
+			return false
+		}
+
+		// Exclude interface types
+		if _, isInterface := namedType.Underlying().(*types.Interface); isInterface {
+			a.WrapperTypes[t] = false
+			return false
+		}
+
+		// Check for common wrapper type patterns from standard library FIRST
+		// This is important for imported types that we can't analyze methods for
+		if obj := namedType.Obj(); obj != nil && obj.Pkg() != nil {
+			pkgPath := obj.Pkg().Path()
+			typeName := obj.Name()
+
+			// Known wrapper types from standard library
+			isKnownWrapper := false
+			switch pkgPath {
+			case "os":
+				isKnownWrapper = typeName == "FileMode"
+			case "time":
+				isKnownWrapper = typeName == "Duration"
+			case "syscall":
+				// Many syscall types are wrappers
+				isKnownWrapper = true
+			}
+
+			if isKnownWrapper {
+				a.WrapperTypes[t] = true
+				return true
+			}
+		}
+
+		// Check if this type has methods defined on it (for local types)
+		if namedType.NumMethods() > 0 {
+			a.WrapperTypes[t] = true
+			return true
+		}
+	}
+
+	// Handle type aliases (Go 1.9+)
+	if aliasType, ok := t.(*types.Alias); ok {
+		// Get the underlying type and check if it's a known wrapper type
+		if obj := aliasType.Obj(); obj != nil && obj.Pkg() != nil {
+			pkgPath := obj.Pkg().Path()
+			typeName := obj.Name()
+
+			// Known wrapper types from standard library
+			isKnownWrapper := false
+			switch pkgPath {
+			case "os":
+				isKnownWrapper = typeName == "FileMode"
+			case "time":
+				isKnownWrapper = typeName == "Duration"
+			case "syscall":
+				// Many syscall types are wrappers
+				isKnownWrapper = true
+			}
+
+			if isKnownWrapper {
+				a.WrapperTypes[t] = true
+				return true
+			}
+		}
+	}
+
+	// Cache negative result
+	a.WrapperTypes[t] = false
+	return false
+}

compiler/analysis_test.go

@@ -5,6 +5,7 @@ import (
 	"go/parser"
 	"go/token"
 	"go/types"
+	"os"
 	"testing"
 
 	"golang.org/x/tools/go/packages"
@@ -232,3 +233,81 @@ func main() {
 		t.Log("")
 	}
 }
+
+// TestWrapperTypeDetection verifies that the analysis correctly identifies wrapper types
+func TestWrapperTypeDetection(t *testing.T) {
+	// Use the actual compliance test case
+	testPath := "../compliance/tests/wrapper_type_args"
+
+	// Load the package using the packages config like the main compiler does
+	cfg := &packages.Config{
+		Mode: packages.NeedName |
+			packages.NeedFiles |
+			packages.NeedCompiledGoFiles |
+			packages.NeedImports |
+			packages.NeedDeps |
+			packages.NeedExportFile |
+			packages.NeedTypes |
+			packages.NeedSyntax |
+			packages.NeedTypesInfo |
+			packages.NeedTypesSizes,
+		Tests: false,
+		Env:   append(os.Environ(), "GOOS=js", "GOARCH=wasm"),
+	}
+
+	pkgs, err := packages.Load(cfg, testPath)
+	if err != nil {
+		t.Fatalf("Failed to load test package: %v", err)
+	}
+
+	if len(pkgs) != 1 {
+		t.Fatalf("Expected 1 package, got %d", len(pkgs))
+	}
+
+	pkg := pkgs[0]
+	if len(pkg.Errors) > 0 {
+		t.Fatalf("Package has errors: %v", pkg.Errors[0])
+	}
+
+	// Run analysis on the first file
+	if len(pkg.Syntax) == 0 {
+		t.Fatal("No syntax files found")
+	}
+
+	analysis := NewAnalysis()
+	cmap := ast.NewCommentMap(pkg.Fset, pkg.Syntax[0], pkg.Syntax[0].Comments)
+	AnalyzeFile(pkg.Syntax[0], pkg, analysis, cmap)
+
+	// Verify the WrapperTypes map was initialized
+	if analysis.WrapperTypes == nil {
+		t.Error("WrapperTypes map was not initialized")
+	}
+
+	// Test some type lookups to verify wrapper type detection works
+	// We'll check if MyMode (which has methods) is detected as a wrapper type
+	scope := pkg.Types.Scope()
+
+	// Check if MyMode is detected as a wrapper type
+	if obj := scope.Lookup("MyMode"); obj != nil {
+		if typeName, ok := obj.(*types.TypeName); ok {
+			isWrapper := analysis.IsWrapperType(typeName.Type())
+			if !isWrapper {
+				t.Errorf("MyMode should be detected as wrapper type, got %v", isWrapper)
+			}
+			t.Logf("MyMode wrapper detection: %v (correct)", isWrapper)
+		}
+	}
+
+	// Test that regular struct types are not detected as wrapper types
+	if obj := scope.Lookup("MyDir"); obj != nil {
+		if typeName, ok := obj.(*types.TypeName); ok {
+			isWrapper := analysis.IsWrapperType(typeName.Type())
+			if isWrapper {
+				t.Errorf("MyDir should not be detected as wrapper type, got %v", isWrapper)
+			}
+			t.Logf("MyDir wrapper detection: %v (correct)", isWrapper)
+		}
+	}
+
+	t.Logf("Analysis completed successfully with %d wrapper types tracked", len(analysis.WrapperTypes))
+}

compiler/expr-call-type-conversion.go

@@ -256,7 +256,17 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 						c.tsw.WriteLiterally("new ")
 						c.tsw.WriteLiterally(funIdent.String())
 						c.tsw.WriteLiterally("(")
-						if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+
+						// Use auto-wrapping for the constructor argument
+						// The constructor parameter type is the underlying type of the named type
+						// For MyMode (which is type MyMode os.FileMode), the constructor expects os.FileMode
+						constructorParamType := typeName.Type()
+						if namedType, ok := typeName.Type().(*types.Named); ok {
+							// For named types, the constructor expects the underlying type
+							constructorParamType = namedType.Underlying()
+						}
+
+						if err := c.writeAutoWrappedArgument(exp.Args[0], constructorParamType); err != nil {
 							return true, fmt.Errorf("failed to write argument for type constructor: %w", err)
 						}
 						c.tsw.WriteLiterally(")")