goscript 0.0.83 → 0.1.0

package/compiler/field.go

@@ -1,183 +0,0 @@
-package compiler
-
-import (
-	"go/ast"
-	"go/types"
-)
-
-// WriteFieldList translates a Go field list (`ast.FieldList`), which can represent
-// function parameters, function results, or struct fields, into its TypeScript equivalent.
-//   - If `isArguments` is true (for function parameters/results):
-//     It iterates through `a.List`, writing each field as `name: type`. Parameter
-//     names and types are written using `WriteField` and `WriteGoType` respectively.
-//     Multiple parameters are comma-separated.
-//   - If `isArguments` is false (for struct fields):
-//     It writes an opening brace `{`, indents, then writes each field definition
-//     using `WriteField`, followed by a closing brace `}`. If the field list is
-//     empty or nil, it simply writes `{}`.
-//
-// This function is a key part of generating TypeScript type signatures for functions
-// and interfaces, as well as struct type definitions.
-func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
-	if !isArguments && (a == nil || a.NumFields() == 0) {
-		c.tsw.WriteLiterally("{}")
-		return
-	}
-
-	if !isArguments && a.Opening.IsValid() {
-		c.tsw.WriteLine("{")
-		c.tsw.Indent(1)
-	}
-
-	// Check if this is a variadic function parameter list
-	isVariadic := false
-	if isArguments && a != nil && len(a.List) > 0 {
-		lastParam := a.List[len(a.List)-1]
-		if _, ok := lastParam.Type.(*ast.Ellipsis); ok {
-			isVariadic = true
-		}
-	}
-
-	if isArguments && isVariadic {
-		// Handle non-variadic parameters first
-		for i, field := range a.List[:len(a.List)-1] {
-			if i > 0 {
-				c.tsw.WriteLiterally(", ")
-			}
-
-			// Handle multiple parameter names for the same type
-			for j, name := range field.Names {
-				if j > 0 {
-					c.tsw.WriteLiterally(", ")
-				}
-				c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
-				c.tsw.WriteLiterally(": ")
-				// Use WriteTypeExpr to preserve qualified names like os.FileInfo
-				c.WriteTypeExpr(field.Type)
-			}
-		}
-
-		// Handle the variadic parameter
-		lastParam := a.List[len(a.List)-1]
-		if len(a.List) > 1 {
-			c.tsw.WriteLiterally(", ")
-		}
-
-		for i, name := range lastParam.Names {
-			if i > 0 {
-				c.tsw.WriteLiterally(", ")
-			}
-			c.tsw.WriteLiterally("...")
-			c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
-		}
-
-		c.tsw.WriteLiterally(": ")
-		if ellipsis, ok := lastParam.Type.(*ast.Ellipsis); ok {
-			// Get the actual variadic parameter type from the type checker
-			// This gives us the slice type (e.g., []interface{})
-			variadicType := c.pkg.TypesInfo.TypeOf(lastParam.Type)
-			if sliceType, isSlice := variadicType.(*types.Slice); isSlice {
-				// For variadic parameters, write the element type followed by []
-				// This handles interface{} properly by generating "any[]" instead of "null | any[]"
-				c.WriteGoType(sliceType.Elem(), GoTypeContextVariadicParam)
-				c.tsw.WriteLiterally("[]")
-			} else {
-				// Fallback to the original AST-based approach for edge cases
-				c.WriteTypeExpr(ellipsis.Elt)
-				c.tsw.WriteLiterally("[]")
-			}
-		}
-	} else {
-		// Handle regular parameter list for function declarations
-		for i, field := range a.List {
-			if i > 0 && isArguments {
-				c.tsw.WriteLiterally(", ")
-			}
-
-			if isArguments {
-				// For function parameters with multiple names, write each with its type
-				for j, name := range field.Names {
-					if j > 0 {
-						c.tsw.WriteLiterally(", ")
-					}
-					c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
-					c.tsw.WriteLiterally(": ")
-					// Use WriteTypeExpr to preserve qualified names like os.FileInfo
-					c.WriteTypeExpr(field.Type)
-				}
-			} else {
-				// For struct fields and other non-argument fields
-				c.WriteField(field, false)
-			}
-		}
-	}
-
-	if !isArguments && a.Closing.IsValid() {
-		c.tsw.Indent(-1)
-		c.tsw.WriteLine("}")
-	}
-}
-
-// WriteField translates a single Go field (`ast.Field`) from a field list
-// (e.g., in a struct type or function signature) into its TypeScript representation.
-// - If `isArguments` is false (struct field):
-//   - Documentation comments (`field.Doc`, `field.Comment`) are preserved.
-//   - If the field is anonymous (embedded), it's skipped as promotions are handled
-//     elsewhere (e.g., during struct class generation).
-//   - For named fields, it writes `public fieldName: FieldType_ts`. The field name
-//     retains its Go casing. The type is translated using `WriteGoType`.
-//   - Go struct tags (`field.Tag`) are written as a trailing comment.
-//
-// - If `isArguments` is true (function parameter):
-//   - It writes the parameter name (retaining Go casing). The type is handled
-//     by the caller (`WriteFieldList`).
-//
-// This function is used by `WriteFieldList` to process individual items within
-// parameter lists and struct field definitions.
-func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
-	if !isArguments {
-		if field.Doc != nil {
-			c.WriteDoc(field.Doc)
-		}
-		if field.Comment != nil {
-			c.WriteDoc(field.Comment)
-		}
-	}
-
-	// Check if this is an embedded field (anonymous field)
-	if len(field.Names) == 0 && !isArguments {
-		// This is an embedded field, so we're adding promotions instead of declaring it directly
-		return
-	}
-
-	for i, name := range field.Names {
-		if i > 0 && isArguments {
-			c.tsw.WriteLiterally(", ")
-		}
-
-		// argument names: keep original casing, no access modifier
-		if isArguments {
-			c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
-			// Argument type is handled in WriteFieldList, so continue
-			continue
-		} else {
-			// All struct fields are public in TypeScript, keeping original Go casing
-			c.tsw.WriteLiterally("public ")
-			c.tsw.WriteLiterally(name.Name)
-		}
-
-		// write type for struct fields (not arguments)
-		c.tsw.WriteLiterally(": ")
-		typ := c.pkg.TypesInfo.TypeOf(field.Type)
-		c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for field type
-
-		if !isArguments {
-			// write tag comment if any for struct fields
-			if field.Tag != nil {
-				c.tsw.WriteCommentLinef("tag: %s", field.Tag.Value)
-			} else {
-				c.tsw.WriteLine("") // No semicolon
-			}
-		}
-	}
-}

package/compiler/gs_dependencies_test.go

@@ -1,298 +0,0 @@
-package compiler
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-
-	"github.com/sirupsen/logrus"
-)
-
-func TestReadGsPackageMetadata(t *testing.T) {
-	// Create a basic compiler configuration
-	config := &Config{
-		OutputPath: "./test_output",
-		Dir:        ".",
-	}
-
-	// Create a logger (set to warn level to reduce noise in tests)
-	logger := logrus.New()
-	logger.SetLevel(logrus.WarnLevel)
-	le := logrus.NewEntry(logger)
-
-	// Create a compiler
-	comp, err := NewCompiler(config, le, nil)
-	if err != nil {
-		t.Fatalf("Failed to create compiler: %v", err)
-	}
-
-	// Test reading metadata from the bytes package
-	metadata, err := comp.ReadGsPackageMetadata("gs/bytes")
-	if err != nil {
-		t.Fatalf("Failed to read metadata: %v", err)
-	}
-
-	// Check that we found the expected dependencies
-	if len(metadata.Dependencies) == 0 {
-		t.Errorf("Expected at least one dependency, got none")
-	}
-
-	// Check for the specific "iter" dependency
-	foundIter := slices.Contains(metadata.Dependencies, "iter")
-
-	if !foundIter {
-		t.Errorf("Expected to find 'iter' dependency, got dependencies: %v", metadata.Dependencies)
-	}
-
-	// Also check for other expected dependencies from the bytes package
-	expectedDeps := []string{"errors", "io", "iter", "unicode", "unicode/utf8", "unsafe"}
-	for _, expected := range expectedDeps {
-		found := slices.Contains(metadata.Dependencies, expected)
-		if !found {
-			t.Errorf("Expected to find dependency '%s', got dependencies: %v", expected, metadata.Dependencies)
-		}
-	}
-}
-
-func TestReadGsPackageMetadataWithAsyncMethods(t *testing.T) {
-	// Create a basic compiler configuration
-	config := &Config{
-		OutputPath: "./test_output",
-		Dir:        ".",
-	}
-
-	// Create a logger (set to warn level to reduce noise in tests)
-	logger := logrus.New()
-	logger.SetLevel(logrus.WarnLevel)
-	le := logrus.NewEntry(logger)
-
-	// Create a compiler
-	comp, err := NewCompiler(config, le, nil)
-	if err != nil {
-		t.Fatalf("Failed to create compiler: %v", err)
-	}
-
-	// Test reading metadata from the sync package (which has async methods)
-	metadata, err := comp.ReadGsPackageMetadata("gs/sync")
-	if err != nil {
-		t.Fatalf("Failed to read metadata: %v", err)
-	}
-
-	// Check that we have async methods
-	if len(metadata.AsyncMethods) == 0 {
-		t.Errorf("Expected at least one async method for sync package, got none")
-	}
-
-	// Check for specific async methods
-	expectedAsyncMethods := []string{"Mutex.Lock", "WaitGroup.Wait", "RWMutex.Lock"}
-	for _, methodName := range expectedAsyncMethods {
-		if isAsync, exists := metadata.AsyncMethods[methodName]; !exists {
-			t.Errorf("Expected to find async method '%s'", methodName)
-		} else if !isAsync {
-			t.Errorf("Expected method '%s' to be async, but it's not", methodName)
-		}
-	}
-}
-
-func TestReadGsPackageMetadataNonExistent(t *testing.T) {
-	// Create a basic compiler configuration
-	config := &Config{
-		OutputPath: "./test_output",
-		Dir:        ".",
-	}
-
-	// Create a logger (set to warn level to reduce noise in tests)
-	logger := logrus.New()
-	logger.SetLevel(logrus.WarnLevel)
-	le := logrus.NewEntry(logger)
-
-	// Create a compiler
-	comp, err := NewCompiler(config, le, nil)
-	if err != nil {
-		t.Fatalf("Failed to create compiler: %v", err)
-	}
-
-	// Test reading metadata from a non-existent package
-	metadata, err := comp.ReadGsPackageMetadata("gs/nonexistent")
-	if err != nil {
-		t.Fatalf("Expected no error for non-existent package, got: %v", err)
-	}
-
-	// Should return empty metadata for non-existent packages
-	if len(metadata.Dependencies) != 0 {
-		t.Errorf("Expected empty dependencies for non-existent package, got: %v", metadata.Dependencies)
-	}
-
-	if len(metadata.AsyncMethods) != 0 {
-		t.Errorf("Expected empty async methods for non-existent package, got: %v", metadata.AsyncMethods)
-	}
-}
-
-func TestCompilePackagesCopiesHandwrittenDependencies(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "goscript-gs-deps")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("Failed to get working directory: %v", err)
-	}
-
-	config := &Config{
-		OutputPath:         tempDir,
-		Dir:                filepath.Dir(wd),
-		AllDependencies:    true,
-		DisableEmitBuiltin: false,
-	}
-
-	logger := logrus.New()
-	logger.SetLevel(logrus.WarnLevel)
-	le := logrus.NewEntry(logger)
-
-	comp, err := NewCompiler(config, le, nil)
-	if err != nil {
-		t.Fatalf("Failed to create compiler: %v", err)
-	}
-
-	_, err = comp.CompilePackages(
-		context.Background(),
-		"github.com/aperturerobotics/goscript/tests/tests/package_import_slices",
-	)
-	if err != nil {
-		t.Fatalf("Compilation failed: %v", err)
-	}
-
-	cmpPath := filepath.Join(tempDir, "@goscript", "cmp", "index.ts")
-	if _, err := os.Stat(cmpPath); err != nil {
-		t.Fatalf("Expected handwritten dependency at %s: %v", cmpPath, err)
-	}
-}
-
-func TestCompilePackagesEmitTypeScriptImportSpecifiers(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "goscript-ts-imports")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("Failed to get working directory: %v", err)
-	}
-
-	config := &Config{
-		OutputPath:         tempDir,
-		Dir:                filepath.Dir(wd),
-		AllDependencies:    true,
-		DisableEmitBuiltin: false,
-	}
-
-	logger := logrus.New()
-	logger.SetLevel(logrus.WarnLevel)
-	le := logrus.NewEntry(logger)
-
-	comp, err := NewCompiler(config, le, nil)
-	if err != nil {
-		t.Fatalf("Failed to create compiler: %v", err)
-	}
-
-	_, err = comp.CompilePackages(
-		context.Background(),
-		"github.com/aperturerobotics/goscript/tests/tests/package_import",
-		"github.com/aperturerobotics/goscript/tests/tests/map_value_field_access_cross_file",
-	)
-	if err != nil {
-		t.Fatalf("Compilation failed: %v", err)
-	}
-
-	assertFileContains(t,
-		filepath.Join(
-			tempDir,
-			"@goscript",
-			"github.com",
-			"aperturerobotics",
-			"goscript",
-			"tests",
-			"tests",
-			"package_import",
-			"package_import.gs.ts",
-		),
-		[]string{
-			`@goscript/builtin/index.ts`,
-			`@goscript/github.com/aperturerobotics/goscript/tests/tests/package_import/subpkg/index.ts`,
-		},
-		[]string{
-			".js",
-		},
-	)
-
-	assertFileContains(t,
-		filepath.Join(
-			tempDir,
-			"@goscript",
-			"github.com",
-			"aperturerobotics",
-			"goscript",
-			"tests",
-			"tests",
-			"package_import",
-			"subpkg",
-			"index.ts",
-		),
-		[]string{
-			`"./subpkg.gs.ts"`,
-		},
-		[]string{
-			".gs.js",
-		},
-	)
-
-	assertFileContains(t,
-		filepath.Join(
-			tempDir,
-			"@goscript",
-			"github.com",
-			"aperturerobotics",
-			"goscript",
-			"tests",
-			"tests",
-			"map_value_field_access_cross_file",
-			"read.gs.ts",
-		),
-		[]string{
-			`"./types.gs.ts"`,
-			`@goscript/builtin/index.ts`,
-		},
-		[]string{
-			".gs.js",
-			"index.js",
-		},
-	)
-}
-
-func assertFileContains(t *testing.T, path string, want []string, wantAbsent []string) {
-	t.Helper()
-
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("Failed to read %s: %v", path, err)
-	}
-	text := string(data)
-
-	for _, s := range want {
-		if !strings.Contains(text, s) {
-			t.Fatalf("Expected %s to contain %q\n%s", path, s, text)
-		}
-	}
-
-	for _, s := range wantAbsent {
-		if strings.Contains(text, s) {
-			t.Fatalf("Expected %s to omit %q\n%s", path, s, text)
-		}
-	}
-}