fix: interface embedding

paralin · paralin · commit 3f1094da41a5 · 2025-11-05T23:55:13.000-08:00
Signed-off-by: Christian Stewart &lt;christian@aperture.us&gt;
diff --git a/AGENTS.md b/AGENTS.md
@@ -154,7 +154,7 @@ When updating design documents:
 When eliminating dead code if requested by the user:
 
 1. Receive instructions from the user
-2. Run `golangci-lint run --no-config --enable-only=unused`
+2. Run `golangci-lint run --no-config --enable-only=unused` (exactly this command)
 3. Remove any unused code in `./compiler` ignoring ./compliance
 4. Any line which is unused in `./compliance` add a `//nolint:unused` comment at the end.
 5. Rerun the golangci-lint command to ensure we got everything.
diff --git a/compiler/analysis.go b/compiler/analysis.go
@@ -1254,21 +1254,26 @@ func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
 
 			// Get the type of the embedded field
 			embeddedType := field.Type()
-			
+
 			// Handle pointer to embedded type
 			if ptr, ok := embeddedType.(*types.Pointer); ok {
 				embeddedType = ptr.Elem()
 			}
 
-			// Get named type to access methods
-			embeddedNamed, ok := embeddedType.(*types.Named)
-			if !ok {
-				continue
+			// Use method set to get all promoted methods including pointer receiver methods
+			// This matches Go's behavior where embedding T promotes both T and *T methods
+			methodSetType := embeddedType
+			if _, isPtr := embeddedType.(*types.Pointer); !isPtr {
+				if _, isInterface := embeddedType.Underlying().(*types.Interface); !isInterface {
+					methodSetType = types.NewPointer(embeddedType)
+				}
 			}
+			embeddedMethodSet := types.NewMethodSet(methodSetType)
 
-			// Scan all methods of the embedded type
-			for j := 0; j < embeddedNamed.NumMethods(); j++ {
-				method := embeddedNamed.Method(j)
+			// Scan all methods in the method set
+			for j := 0; j < embeddedMethodSet.Len(); j++ {
+				selection := embeddedMethodSet.At(j)
+				method := selection.Obj()
 				sig, ok := method.Type().(*types.Signature)
 				if !ok {
 					continue
@@ -1319,6 +1324,15 @@ func (a *Analysis) collectPackageFromType(t types.Type, currentPkg *types.Packag
 				a.collectPackageFromType(typ.TypeArgs().At(i), currentPkg, packagesToAdd)
 			}
 		}
+	case *types.Interface:
+		// For interfaces, we need to check embedded interfaces and method signatures
+		for i := 0; i < typ.NumEmbeddeds(); i++ {
+			a.collectPackageFromType(typ.EmbeddedType(i), currentPkg, packagesToAdd)
+		}
+		for i := 0; i < typ.NumExplicitMethods(); i++ {
+			method := typ.ExplicitMethod(i)
+			a.collectPackageFromType(method.Type(), currentPkg, packagesToAdd)
+		}
 	case *types.Pointer:
 		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
 	case *types.Slice:
diff --git a/compiler/compiler.go b/compiler/compiler.go
@@ -678,6 +678,8 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 
 	// Write any imports that were added during analysis (e.g., for promoted methods)
 	// but don't appear in the source AST
+	// Note: c.Analysis.Imports is package-wide, so we need to filter to only imports
+	// that are actually used in this specific file
 	writtenImports := make(map[string]bool)
 	// Track imports that will be written from the AST
 	for _, imp := range f.Imports {
@@ -693,17 +695,47 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 			}
 		}
 	}
-	// Write imports from analysis that aren't in the AST
-	var additionalImports []string
-	for pkgName := range c.Analysis.Imports {
-		if !writtenImports[pkgName] && pkgName != "$" {
-			additionalImports = append(additionalImports, pkgName)
+	// Write any imports that were added during analysis (e.g., for promoted methods)
+	// Check if this file defines any structs with embedded fields
+	fileHasEmbeddedStructs := false
+	for _, decl := range f.Decls {
+		genDecl, ok := decl.(*ast.GenDecl)
+		if !ok || genDecl.Tok != token.TYPE {
+			continue
+		}
+		for _, spec := range genDecl.Specs {
+			typeSpec, ok := spec.(*ast.TypeSpec)
+			if !ok {
+				continue
+			}
+			structType, ok := typeSpec.Type.(*ast.StructType)
+			if !ok {
+				continue
+			}
+			// Check if any field is embedded
+			for _, field := range structType.Fields.List {
+				if len(field.Names) == 0 { // Embedded field
+					fileHasEmbeddedStructs = true
+					break
+				}
+			}
+			if fileHasEmbeddedStructs {
+				break
+			}
+		}
+		if fileHasEmbeddedStructs {
+			break
 		}
 	}
-	sort.Strings(additionalImports)
-	for _, pkgName := range additionalImports {
-		fileImp := c.Analysis.Imports[pkgName]
-		c.codeWriter.WriteImport(pkgName, fileImp.importPath+"/index.js")
+
+	// If this file has embedded structs, write imports from analysis that aren't in AST
+	if fileHasEmbeddedStructs {
+		for pkgName, fileImport := range c.Analysis.Imports {
+			if !writtenImports[pkgName] {
+				c.codeWriter.WriteLinef("import * as %s from \"%s/index.js\"", pkgName, fileImport.importPath)
+				writtenImports[pkgName] = true
+			}
+		}
 	}
 
 	c.codeWriter.WriteLine("") // Add a newline after imports
diff --git a/compiler/spec-struct.go b/compiler/spec-struct.go
@@ -345,21 +345,24 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			}
 		}
 
-	// Promoted methods
-	// Use pointer to embedded type to get both value and pointer receiver methods
-	// This matches Go's behavior where embedding T promotes both T and *T methods
-	methodSetType := embeddedFieldType
-	if _, isPtr := embeddedFieldType.(*types.Pointer); !isPtr {
-		methodSetType = types.NewPointer(embeddedFieldType)
-	}
-	embeddedMethodSet := types.NewMethodSet(methodSetType)
-	for k := range embeddedMethodSet.Len() {
-		methodSelection := embeddedMethodSet.At(k)
-		method := methodSelection.Obj().(*types.Func)
-		methodName := method.Name()
-
-		// Skip if it's not a promoted method (indirect) or if it's shadowed by a direct method or an already processed promoted method
-		if len(methodSelection.Index()) == 1 && !directMethods[methodName] && !seenPromotedFields[methodName] {
+		// Promoted methods
+		// Use pointer to embedded type to get both value and pointer receiver methods
+		// This matches Go's behavior where embedding T promotes both T and *T methods
+		// Exception: For interfaces, use the interface directly as pointer-to-interface has no methods
+		methodSetType := embeddedFieldType
+		if _, isPtr := embeddedFieldType.(*types.Pointer); !isPtr {
+			if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); !isInterface {
+				methodSetType = types.NewPointer(embeddedFieldType)
+			}
+		}
+		embeddedMethodSet := types.NewMethodSet(methodSetType)
+		for k := range embeddedMethodSet.Len() {
+			methodSelection := embeddedMethodSet.At(k)
+			method := methodSelection.Obj().(*types.Func)
+			methodName := method.Name()
+
+			// Skip if it's not a promoted method (indirect) or if it's shadowed by a direct method or an already processed promoted method
+			if len(methodSelection.Index()) == 1 && !directMethods[methodName] && !seenPromotedFields[methodName] {
 				// Check for conflict with outer struct's own fields
 				conflictWithField := false
 				for k_idx := 0; k_idx < underlyingStruct.NumFields(); k_idx++ {
diff --git a/compliance/deps/encoding/json/encode.gs.ts b/compliance/deps/encoding/json/encode.gs.ts
@@ -575,6 +575,10 @@ export class jsonError {
 		return cloned
 	}
 
+	public Error(): string {
+		return this.error!.Error()
+	}
+
 	// Register this type with the runtime type system
 	static __typeInfo = $.registerStructType(
 	  'encoding/json.jsonError',
diff --git a/compliance/deps/go/scanner/errors.gs.ts b/compliance/deps/go/scanner/errors.gs.ts
@@ -1,9 +1,4 @@
 import * as $ from "@goscript/builtin/index.js"
-import * as bytes from "bytes/index.js"
-import * as filepath from "path/filepath/index.js"
-import * as strconv from "strconv/index.js"
-import * as unicode from "unicode/index.js"
-import * as utf8 from "unicode/utf8/index.js"
 
 import * as fmt from "@goscript/fmt/index.js"
 
diff --git a/compliance/deps/go/scanner/scanner.gs.ts b/compliance/deps/go/scanner/scanner.gs.ts
@@ -1,6 +1,4 @@
 import * as $ from "@goscript/builtin/index.js"
-import * as io from "@goscript/io/index.js"
-import * as sort from "@goscript/sort/index.js"
 
 import * as bytes from "@goscript/bytes/index.js"
 
diff --git a/compliance/deps/go/token/position.gs.ts b/compliance/deps/go/token/position.gs.ts
@@ -1,8 +1,5 @@
 import * as $ from "@goscript/builtin/index.js"
 import { key, tree } from "./tree.gs.js";
-import * as iter from "iter/index.js"
-import * as unicode from "unicode/index.js"
-import * as utf8 from "unicode/utf8/index.js"
 
 import * as cmp from "@goscript/cmp/index.js"
 
diff --git a/compliance/deps/go/token/serialize.gs.ts b/compliance/deps/go/token/serialize.gs.ts
@@ -1,13 +1,5 @@
 import * as $ from "@goscript/builtin/index.js"
 import { File, FileSet, lineInfo } from "./position.gs.js";
-import * as atomic from "@goscript/sync/atomic/index.js"
-import * as cmp from "@goscript/cmp/index.js"
-import * as fmt from "@goscript/fmt/index.js"
-import * as iter from "iter/index.js"
-import * as strconv from "@goscript/strconv/index.js"
-import * as sync from "@goscript/sync/index.js"
-import * as unicode from "unicode/index.js"
-import * as utf8 from "unicode/utf8/index.js"
 
 import * as slices from "@goscript/slices/index.js"
 
diff --git a/compliance/deps/go/token/token.gs.ts b/compliance/deps/go/token/token.gs.ts
@@ -1,10 +1,4 @@
 import * as $ from "@goscript/builtin/index.js"
-import * as atomic from "@goscript/sync/atomic/index.js"
-import * as cmp from "@goscript/cmp/index.js"
-import * as fmt from "@goscript/fmt/index.js"
-import * as iter from "iter/index.js"
-import * as slices from "@goscript/slices/index.js"
-import * as sync from "@goscript/sync/index.js"
 
 import * as strconv from "@goscript/strconv/index.js"
 
diff --git a/compliance/deps/go/token/tree.gs.ts b/compliance/deps/go/token/tree.gs.ts
@@ -1,12 +1,5 @@
 import * as $ from "@goscript/builtin/index.js"
 import { File } from "./position.gs.js";
-import * as atomic from "@goscript/sync/atomic/index.js"
-import * as cmp from "@goscript/cmp/index.js"
-import * as slices from "@goscript/slices/index.js"
-import * as strconv from "@goscript/strconv/index.js"
-import * as sync from "@goscript/sync/index.js"
-import * as unicode from "@goscript/unicode/index.js"
-import * as utf8 from "@goscript/unicode/utf8/index.js"
 
 import * as fmt from "@goscript/fmt/index.js"
 
diff --git a/compliance/tests/embedded_interface_null_assertion/actual.log b/compliance/tests/embedded_interface_null_assertion/actual.log
diff --git a/compliance/tests/embedded_interface_null_assertion/embedded_interface_null_assertion.gs.ts b/compliance/tests/embedded_interface_null_assertion/embedded_interface_null_assertion.gs.ts
@@ -105,6 +105,10 @@ export class MyReader {
 		return cloned
 	}
 
+	public Read(p: $.Bytes): [number, $.GoError] {
+		return this.Reader!.Read(p)
+	}
+
 	// Register this type with the runtime type system
 	static __typeInfo = $.registerStructType(
 	  'main.MyReader',
diff --git a/compliance/tests/interface_embedding/actual.log b/compliance/tests/interface_embedding/actual.log
diff --git a/compliance/tests/interface_embedding/interface_embedding.gs.ts b/compliance/tests/interface_embedding/interface_embedding.gs.ts
@@ -187,6 +187,18 @@ export class qualifiedFile {
 		return cloned
 	}
 
+	public Close(): $.GoError {
+		return this.File!.Close()
+	}
+
+	public Name(): string {
+		return this.File!.Name()
+	}
+
+	public Write(data: $.Bytes): [number, $.GoError] {
+		return this.File!.Write(data)
+	}
+
 	// Register this type with the runtime type system
 	static __typeInfo = $.registerStructType(
 	  'main.qualifiedFile',
@@ -238,6 +250,38 @@ export class file {
 		return f.name
 	}
 
+	public Close(): $.GoError {
+		return this.File!.Close()
+	}
+
+	public Lock(): $.GoError {
+		return this.File!.Lock()
+	}
+
+	public Read(p: $.Bytes): [number, $.GoError] {
+		return this.File!.Read(p)
+	}
+
+	public ReadAt(p: $.Bytes, off: number): [number, $.GoError] {
+		return this.File!.ReadAt(p, off)
+	}
+
+	public Seek(offset: number, whence: number): [number, $.GoError] {
+		return this.File!.Seek(offset, whence)
+	}
+
+	public Truncate(size: number): $.GoError {
+		return this.File!.Truncate(size)
+	}
+
+	public Unlock(): $.GoError {
+		return this.File!.Unlock()
+	}
+
+	public Write(p: $.Bytes): [number, $.GoError] {
+		return this.File!.Write(p)
+	}
+
 	// Register this type with the runtime type system
 	static __typeInfo = $.registerStructType(
 	  'main.file',
diff --git a/compliance/tests/interface_subset_cast/interface_subset_cast.go b/compliance/tests/interface_subset_cast/interface_subset_cast.go
@@ -25,14 +25,14 @@ func (m MyStruct) MyString2() string {
 func main() {
 	s := MyStruct{Value1: "hello", Value2: "world"}
 	var i1 MyInterface1 = s
-	
+
 	// Cast from larger interface to smaller interface (subset)
 	var i2 MyInterface2 = i1
-	
+
 	println("i1.MyString1():", i1.MyString1())
 	println("i1.MyString2():", i1.MyString2())
 	println("i2.MyString1():", i2.MyString1())
-	
+
 	// Type assertion from larger to smaller interface
 	i3, ok := i1.(MyInterface2)
 	if ok {
diff --git a/compliance/tests/interface_subset_type_switch/interface_subset_type_switch.go b/compliance/tests/interface_subset_type_switch/interface_subset_type_switch.go
@@ -35,18 +35,18 @@ func processInterface(i any) {
 
 func main() {
 	s := MyStruct{Value1: "hello", Value2: "world"}
-	
+
 	// Test with MyInterface1
 	var i1 MyInterface1 = s
 	processInterface(i1)
-	
+
 	// Test with MyInterface2
 	var i2 MyInterface2 = s
 	processInterface(i2)
-	
+
 	// Test with concrete type
 	processInterface(s)
-	
+
 	// Type switch with subset casting
 	var i3 any = i1
 	switch v := i3.(type) {
diff --git a/compliance/tests/package_import_encoding_json/skip-test b/compliance/tests/package_import_encoding_json/skip-test
diff --git a/compliance/tests/protobuf_lite_ts/protobuf_lite_ts.gs.ts b/compliance/tests/protobuf_lite_ts/protobuf_lite_ts.gs.ts
@@ -3,13 +3,6 @@
 
 import * as $ from "@goscript/builtin/index.js"
 import { protobufPackage, ExampleMsg } from "./protobuf_lite_ts.pb.js";
-import * as base64 from "encoding/base64/index.js"
-import * as fmt from "fmt/index.js"
-import * as io from "io/index.js"
-import * as json from "github.com/aperturerobotics/protobuf-go-lite/json/index.js"
-import * as protobuf_go_lite from "github.com/aperturerobotics/protobuf-go-lite/index.js"
-import * as strconv from "strconv/index.js"
-import * as strings from "strings/index.js"
 
 export async function main(): Promise<void> {
 	let msg = ExampleMsg.create({exampleField: $.stringToBytes("hello"), exampleText: "world"})
diff --git a/compliance/tests/reflect_implements/reflect_implements.go b/compliance/tests/reflect_implements/reflect_implements.go
@@ -16,7 +16,7 @@ func main() {
 	t := reflect.TypeOf(MyType{})
 	ptr := reflect.PointerTo(t)
 	iface := reflect.TypeOf((*Stringer)(nil)).Elem()
-	
+
 	println("MyType implements Stringer:", t.Implements(iface))
 	println("*MyType implements Stringer:", ptr.Implements(iface))
 }
diff --git a/compliance/tests/slice_nil/slice_nil.go b/compliance/tests/slice_nil/slice_nil.go
@@ -3,16 +3,16 @@ package main
 func main() {
 	var s []int
 	println("s == nil:", s == nil)
-	
+
 	// Slicing nil with valid bounds should work
 	s2 := s[0:0]
 	println("s[0:0] == nil:", s2 == nil)
-	
+
 	s3 := s[:0]
 	println("s[:0] == nil:", s3 == nil)
-	
+
 	s4 := s[:]
 	println("s[:] == nil:", s4 == nil)
-	
+
 	println("slice_nil test passed")
 }
diff --git a/compliance/tests/slices_sortfunc_nil/slices_sortfunc_nil.go b/compliance/tests/slices_sortfunc_nil/slices_sortfunc_nil.go
diff --git a/compliance/tests/struct_embedding_bytes_buffer/struct_embedding_bytes_buffer.go b/compliance/tests/struct_embedding_bytes_buffer/struct_embedding_bytes_buffer.go
diff --git a/compliance/tests/type_conversion_interface_ptr_nil/type_conversion_interface_ptr_nil.go b/compliance/tests/type_conversion_interface_ptr_nil/type_conversion_interface_ptr_nil.go
