goscript 0.0.2

package/compiler/compiler.go

@@ -0,0 +1,81 @@
+package compiler
+
+import (
+	"context"
+	"os"
+
+	"github.com/sirupsen/logrus"
+	"golang.org/x/tools/go/packages"
+)
+
+// Compiler is the root compiler for a project.
+type Compiler struct {
+	le     *logrus.Entry
+	config Config
+	opts   packages.Config
+}
+
+// NewCompiler builds a new Compiler
+// opts can be nil
+func NewCompiler(conf *Config, le *logrus.Entry, opts *packages.Config) (*Compiler, error) {
+	if err := conf.Validate(); err != nil {
+		return nil, err
+	}
+
+	if opts == nil {
+		opts = &packages.Config{Env: os.Environ()}
+	}
+	// opts.Logf = c.le.Debugf
+	opts.Tests = false
+	opts.Env = append(opts.Env, "GOOS=js", "GOARCH=wasm")
+	opts.Dir = conf.Dir
+
+	// NeedName adds Name and PkgPath.
+	// NeedFiles adds GoFiles and OtherFiles.
+	// NeedCompiledGoFiles adds CompiledGoFiles.
+	// NeedImports adds Imports. If NeedDeps is not set, the Imports field will contain
+	// "placeholder" Packages with only the ID set.
+	// NeedDeps adds the fields requested by the LoadMode in the packages in Imports.
+	// NeedExportsFile adds ExportsFile.
+	// NeedTypes adds Types, Fset, and IllTyped.
+	// NeedSyntax adds Syntax.
+	// NeedTypesInfo adds TypesInfo.
+	// NeedTypesSizes adds TypesSizes.
+	// TODO: disable these if not needed
+	opts.Mode |= packages.NeedName |
+		packages.NeedFiles |
+		packages.NeedCompiledGoFiles |
+		packages.NeedImports |
+		packages.NeedDeps |
+		packages.NeedExportFile |
+		packages.NeedTypes |
+		packages.NeedSyntax |
+		packages.NeedTypesInfo |
+		packages.NeedTypesSizes
+
+	return &Compiler{config: *conf, le: le, opts: *opts}, nil
+}
+
+// CompilePackages attempts to build packages.
+func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) error {
+	opts := c.opts
+	opts.Context = ctx
+
+	pkgs, err := packages.Load(&opts, patterns...)
+	if err != nil {
+		return err
+	}
+
+	for _, pkg := range pkgs {
+		pkgCompiler, err := NewPackageCompiler(c.le, &c.config, pkg)
+		if err != nil {
+			return err
+		}
+
+		if err := pkgCompiler.Compile(ctx); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

package/compiler/config.go

@@ -0,0 +1,32 @@
+package compiler
+
+import (
+	"go/token"
+
+	"github.com/pkg/errors"
+)
+
+// Config is the configuration for the compiler
+// Dir is the working directory for the compiler. If empty, uses the current working directory.
+type Config struct {
+	fset *token.FileSet
+
+	// Dir is the working directory for the compiler. If empty, uses the current working directory.
+	Dir string
+	// OutputPathRoot is the output path root.
+	OutputPathRoot string
+}
+
+// Validate checks the config.
+func (c *Config) Validate() error {
+	if c.fset == nil {
+		c.fset = token.NewFileSet()
+	}
+	if c == nil {
+		return errors.New("config cannot be nil")
+	}
+	if c.OutputPathRoot == "" {
+		return errors.New("output path root must be specified")
+	}
+	return nil
+}

package/compiler/context.go

@@ -0,0 +1,9 @@
+package compiler
+
+// CompilerContext is the context for the compiler.
+type CompilerContext struct {
+	// GoPackage is the name of the go package to compile
+	GoPackage string
+	// ComputedTsPackage is the path to the typescript package for this Go package.
+	ComputedTsPackage string
+}

package/compiler/file_compiler.go

@@ -0,0 +1,80 @@
+package compiler
+
+import (
+	"context"
+	"fmt"
+	"go/ast"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// fileImport is an import in a file.
+type fileImport struct {
+	importPath string
+	importVars map[string]struct{}
+}
+
+// FileCompiler is the root compiler for a file.
+type FileCompiler struct {
+	compilerConfig *Config
+	codeWriter     *TSCodeWriter
+	pkg            *packages.Package
+	ast            *ast.File
+	fullPath       string
+
+	imports map[string]fileImport
+}
+
+// NewFileCompiler builds a new FileCompiler
+func NewFileCompiler(
+	compilerConf *Config,
+	pkg *packages.Package,
+	astFile *ast.File,
+	fullPath string,
+) (*FileCompiler, error) {
+	return &FileCompiler{
+		compilerConfig: compilerConf,
+		pkg:            pkg,
+		ast:            astFile,
+		fullPath:       fullPath,
+
+		imports: make(map[string]fileImport),
+	}, nil
+}
+
+// Compile compiles a file.
+func (c *FileCompiler) Compile(ctx context.Context) error {
+	f := c.ast
+
+	pkgPath := c.pkg.PkgPath
+	outputFilePath := TranslateGoFilePathToTypescriptFilePath(pkgPath, filepath.Base(c.fullPath))
+	outputFilePathAbs := filepath.Join(c.compilerConfig.OutputPathRoot, outputFilePath)
+
+	if err := os.MkdirAll(filepath.Dir(outputFilePathAbs), 0o755); err != nil {
+		return err
+	}
+
+	of, err := os.OpenFile(outputFilePathAbs, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o644)
+	if err != nil {
+		return err
+	}
+	defer of.Close() //nolint:errcheck
+
+	c.codeWriter = NewTSCodeWriter(of)
+	// Create comment map
+	cmap := ast.NewCommentMap(c.pkg.Fset, f, f.Comments)
+	// Pass comment map to compiler
+	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, cmap)
+
+	// Add import for the goscript runtime using namespace import and alias
+	c.codeWriter.WriteLine("import * as goscript from \"@go/builtin\";")
+	c.codeWriter.WriteLine("") // Add a newline after the import
+
+	if err := goWriter.WriteDecls(f.Decls); err != nil {
+		return fmt.Errorf("failed to write declarations: %w", err)
+	}
+
+	return nil
+}

package/compiler/output_path.go

@@ -0,0 +1,31 @@
+package compiler
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+)
+
+var typeScriptGoStubPrefix = "@ts/"
+
+// translateGoPathToTypescriptPath translates a go package import path to a typescript import path.
+func translateGoPathToTypescriptPath(goImportPath string) string {
+	if strings.HasPrefix(goImportPath, typeScriptGoStubPrefix) {
+		return goImportPath[len(typeScriptGoStubPrefix):]
+	}
+	return fmt.Sprintf("@go/%s", goImportPath)
+}
+
+// packageNameFromGoPath attempts to determine the package name from the last segment of the go path.
+func packageNameFromGoPath(goPkgPath string) string {
+	pts := strings.Split(goPkgPath, "/")
+	return pts[len(pts)-1]
+}
+
+// TranslateGoFilePathToTypescriptFilePath converts the go package path and typescript filename to output path within the typescript output dir
+func TranslateGoFilePathToTypescriptFilePath(goPkgPath, goCodeFilename string) string {
+	op := translateGoPathToTypescriptPath(goPkgPath)
+	baseFilename := goCodeFilename[:len(goCodeFilename)-3]
+	baseFilename = fmt.Sprintf("%s.gs.ts", baseFilename)
+	return filepath.Join(op, baseFilename)
+}

package/compiler/pkg_compiler.go

@@ -0,0 +1,73 @@
+package compiler
+
+import (
+	"context"
+	"go/ast"
+	"os"
+	"path/filepath"
+
+	"github.com/paralin/goscript/output"
+	"github.com/sirupsen/logrus"
+	"golang.org/x/tools/go/packages"
+)
+
+// PackageCompiler compiles an entire package.
+type PackageCompiler struct {
+	le           *logrus.Entry
+	compilerConf *Config
+	outputPath   string
+	pkg          *packages.Package
+}
+
+// NewPackageCompiler builds a new PackageCompiler.
+func NewPackageCompiler(
+	le *logrus.Entry,
+	compilerConf *Config,
+	pkg *packages.Package,
+) (*PackageCompiler, error) {
+	res := &PackageCompiler{
+		le:           le,
+		pkg:          pkg,
+		compilerConf: compilerConf,
+		outputPath:   output.ComputeModulePath(compilerConf.OutputPathRoot, pkg.PkgPath),
+	}
+
+	return res, nil
+}
+
+// Compile compiles the package.
+func (c *PackageCompiler) Compile(ctx context.Context) error {
+	wd := c.compilerConf.Dir
+	if wd == "" {
+		var err error
+		wd, err = os.Getwd()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Compile the files in the package one at a time
+	for i, f := range c.pkg.Syntax {
+		fileName := c.pkg.CompiledGoFiles[i]
+		relWdFileName, err := filepath.Rel(wd, fileName)
+		if err != nil {
+			return err
+		}
+
+		c.le.WithField("file", relWdFileName).Debug("compiling file")
+		if err := c.CompileFile(ctx, fileName, f); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// CompileFile compiles a file.
+func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *ast.File) error {
+	fileCompiler, err := NewFileCompiler(p.compilerConf, p.pkg, syntax, name)
+	if err != nil {
+		return err
+	}
+	return fileCompiler.Compile(ctx)
+}

package/compiler/writer.go

@@ -0,0 +1,90 @@
+package compiler
+
+import (
+	"fmt"
+	"io"
+	"strings"
+)
+
+// TSCodeWriter writes TypeScript code.
+type TSCodeWriter struct {
+	w                  io.Writer
+	indentLevel        int
+	sectionWrittenFlag bool
+	lineWritten        bool
+}
+
+// NewTSCodeWriter builds a new TypeScript code writer.
+func NewTSCodeWriter(w io.Writer) *TSCodeWriter {
+	return &TSCodeWriter{w: w}
+}
+
+// WriteLinePreamble writes the indentation.
+func (w *TSCodeWriter) WriteLinePreamble() {
+	w.sectionWrittenFlag = true
+	w.lineWritten = false
+	for range w.indentLevel {
+		w.w.Write([]byte{byte('\t')}) //nolint:errcheck
+	}
+}
+
+// WriteLine writes a line of code to the output.
+func (w *TSCodeWriter) WriteLine(line string) {
+	if w.lineWritten {
+		w.WriteLinePreamble()
+	}
+	w.w.Write([]byte(line))       //nolint:errcheck
+	w.w.Write([]byte{byte('\n')}) //nolint:errcheck
+	w.lineWritten = true
+}
+
+// WriteLinef writes a formatted line of code to the output.
+func (w *TSCodeWriter) WriteLinef(line string, args ...any) {
+	l := fmt.Sprintf(line, args...)
+	w.WriteLine(l)
+}
+
+// Indent changes the indentation level by a delta.
+func (w *TSCodeWriter) Indent(count int) {
+	w.indentLevel += count
+	if w.indentLevel < 0 {
+		w.indentLevel = 0
+	}
+}
+
+// WriteImport writes a TypeScript import.
+func (w *TSCodeWriter) WriteImport(symbolName, importPath string) {
+	w.WriteLinef("import * as %s from %q;", symbolName, importPath)
+}
+
+// WriteCommentLine writes a comment as a // line.
+func (w *TSCodeWriter) WriteCommentLine(commentText string) {
+	lines := strings.Split(commentText, "\n")
+	for _, line := range lines {
+		w.WriteLinef("// %s", line)
+	}
+}
+
+// WriteCommentInline write a comment within /* */.
+func (w *TSCodeWriter) WriteCommentInline(commentText string) {
+	w.w.Write([]byte("/* "))       //nolint:errcheck
+	w.w.Write([]byte(commentText)) //nolint:errcheck
+	w.w.Write([]byte(" */"))       //nolint:errcheck
+}
+
+// WriteLiterally writes something to the output without processing
+func (w *TSCodeWriter) WriteLiterally(literal string) {
+	w.sectionWrittenFlag = true
+	if w.lineWritten {
+		w.WriteLinePreamble()
+	}
+	w.w.Write([]byte(literal))
+}
+
+// WriteSectionTail writes the end of a section.
+func (w *TSCodeWriter) WriteSectionTail() {
+	if w.sectionWrittenFlag {
+		w.WriteLine("")
+		w.sectionWrittenFlag = false
+	}
+}

package/compliance/COMPLIANCE.md

@@ -0,0 +1,133 @@
+# GoScript Compliance Tests
+
+This document outlines the compliance tests for the GoScript compiler, verifying its ability to correctly translate various Go language features into TypeScript.
+
+## Existing Compliance Tests
+
+The following tests are currently implemented in the `/compliance/tests` directory:
+
+*   **`basic_arithmetic/`**: Verifies basic arithmetic operations (`+`, `-`, `*`, `/`, `%`).
+*   **`boolean_logic/`**: Tests boolean logic operators (`&&`, `||`, `!`) and comparisons (`==`, `!=`, `<`, `>`, `<=`, `>=`).
+*   **`composite_literal_assignment/`**: Checks the assignment of struct values created using composite literals, ensuring correct value copying.
+*   **`copy_independence/`**: Verifies that copies of struct values are independent and modifications to one do not affect others.
+*   **`function_call_result_assignment/`**: Tests assigning the result of a function returning a struct, ensuring proper value semantics (copying).
+*   **`if_statement/`**: Covers basic `if`/`else` conditional statements, including correct `} else {` formatting.
+*   **`switch_statement/`**: Verifies basic `switch` statements with integer and string tags and default cases.
+*   **`for_loop_basic/`**: Verifies basic counter-based `for` loops (`for init; cond; post {}`).
+*   **`map_support/`**: Covers map creation (`make`, literal), access, assignment, deletion, length, and iteration (`range`).
+*   **`method_call_on_pointer_receiver/`**: Verifies calling methods with pointer receivers (`*T`) on pointer variables.
+*   **`method_call_on_value_receiver/`**: Verifies calling methods with value receivers (`T`) on value variables. (Note: Go often implicitly takes the address for pointer receivers, this tests the explicit value receiver case).
+*   **`pointer_deref_multiassign/`**: Tests dereferencing a pointer during a multi-variable assignment (`:=` or `=`), including the use of the blank identifier (`_`).
+*   **`pointer_initialization/`**: Checks the initialization of pointer variables using the address-of operator (`&`) or `new()`.
+*   **`simple/`**: A basic test covering simple struct definition, field access, method calls, and `println`. (Likely overlaps with others, could be a general integration test).
+*   **`simple_deref_assignment/`**: Tests simple assignment involving pointer dereferencing (`*ptr`), ensuring value copying.
+*   **`struct_field_access/`**: Verifies accessing fields of struct values and struct pointers.
+*   **`struct_value_init_clone/`**: Checks struct initialization via composite literal (`T{...}`) (omitting `.clone()` for direct assignment) and subsequent assignment from variables (ensuring `.clone()` is used for value semantics).
+*   **`value_type_copy_behavior/`**: Focuses specifically on demonstrating that assigning struct values creates independent copies (value semantics).
+
+Each test should have only three files:
+
+1. test_name.go - the Go code to convert to TypeScript
+2. test_name.gs.ts - the generated TypeScript code, created automatically on test run
+3. expected.log - the expected output from running the .gs.ts
+
+## Covered Go Language Constructs
+
+Based on the existing tests, GoScript aims to support the following Go features:
+
+*   **Basic Types:** `int`, `string`, `bool`, `float64` (implicitly tested).
+*   **Type Conversions:** `string(rune)`
+*   **Operators:**
+    *   Arithmetic: `+`, `-`, `*`, `/`, `%`
+    *   Comparison: `==`, `!=`, `<`, `>`, `<=`, `>=`
+    *   Logical: `&&`, `||`, `!`
+*   **Control Flow:**
+    *   `if`/`else` statements.
+    *   `switch` statements.
+    *   `select` statement.
+    *   `for` loops (condition-only, basic counter-based, `range` over arrays/slices/strings).
+*   **Data Structures:**
+    *   Arrays (`[N]T`) - Including array literals and indexing.
+    *   Slices (`[]T`) - Creation using `make([]T, len)` and `make([]T, len, cap)`.
+    *   Maps (`map[K]V`) - Creation using `make`, literals, access, assignment, `delete`, `len`, `range`.
+    *   `struct` definitions (including exported/unexported fields).
+    *   Composite Literals for structs (`MyStruct{...}`).
+*   **Functions & Methods:**
+    *   Function definition (`func`).
+    *   Function Literals (`func() { ... }`)
+    *   Method definition with value receivers (`func (v T) Method()`).
+    *   Method definition with pointer receivers (`func (p *T) Method()`).
+    *   Function calls.
+    *   Method calls (on values and pointers).
+    *   `println` built-in (mapped to `console.log`).
+    *   Multiple return values (including assignment and usage with blank identifier).
+    *   Asynchronous Functions (`async`/`await` based on channel operations)
+*   **Variables & Assignment:**
+    *   Variable declaration (`var`, implicitly via `:=`).
+    *   Short variable declaration (`:=`).
+    *   Assignment (`=`).
+    *   Multi-variable assignment.
+    *   Blank identifier (`_`) in assignment.
+*   **Pointers:**
+    *   Pointer types (`*T`).
+    *   Address-of operator (`&`).
+    *   Dereference operator (`*`).
+*   **Value Semantics:** Emulation of Go's struct copy-on-assignment behavior.
+*   **Concurrency:**
+    *   Goroutines (`go func()`)
+    *   Channels (`chan T`, `make`, send `<-`, receive `<-`, buffered/unbuffered, closing)
+
+## Uncovered Go Language Constructs (Based on Go By Example)
+
+The following Go constructs, present in the "Go By Example" guide, do not appear to have dedicated compliance tests yet. This list is not exhaustive but provides a starting point for future test development.
+
+*   Interfaces (`interface{}`) - Definition tested, and type assertions (`v.(T)`) are now compliant, including interface-to-interface type assertions.
+*   **Control Flow:**
+    *   `for` loops (condition-only, infinite still uncovered)
+    *   `switch` statements (with/without expression, type switches)
+    *   `select` statement (for channel operations)
+    *   `defer` statement
+    *   `panic` / `recover`
+*   **Data Structures:**
+    *   Struct Embedding
+*   **Functions:**
+    *   Variadic functions (`...T`)
+    *   Closures
+    *   Recursion
+*   **Basic Types & Values:**
+   *   `iota` consts
+*   **Concurrency:**
+    *   Mutexes (`sync.Mutex`)
+*   **Error Handling:**
+    *   `error` interface usage
+*   **Packages & Imports:**
+    *   Import aliasing (`import alias "path"`)
+
+This list helps identify areas where GoScript's feature coverage can be expanded and verified through new compliance tests.
+
+## Ignored or Not-planned Go Language Constructs
+
+These are the not-planned features that we should NOT waste time adding yet:
+
+* complex number support (complex64, etc.)
+*   **Reflection:** (`reflect` package) - Likely out of scope for direct translation.
+*   **Testing:** (`testing` package) - Test files themselves are usually not translated.
+*   Constants (`const`) - handling of large integer constants (exceeding standard JavaScript number limits) is currently not fully compliant.
+*   Generics (Type parameters, constraints)
+*   `goto` (less common, but part of the language)
+*   **Directives:**
+    *   `//go:embed`
+*   Dot imports (`import . "path"`) - Generally discouraged.
+*   Handling standard library packages (e.g., `fmt`, `math`, `time`, `os`, `net/http`, `encoding/json`, `regexp`, etc.) - Requires runtime shims or direct translation.
+*   **Input/Output & System:**
+    *   File I/O (`os.ReadFile`, `os.WriteFile`, etc.)
+    *   Command-line arguments/flags (`os.Args`, `flag` package)
+    *   Environment variables (`os.Getenv`)
+    *   Executing processes (`os/exec`)
+    *   Signals (`os/signal`)
+    *   Context (`context`)
+*   WaitGroups (`sync.WaitGroup`)
+*   Atomic Counters (`sync/atomic`)
+*   Rate Limiting concepts
+*   Worker Pools
+*   Stateful Goroutines