goscript 0.0.2 → 0.0.4

package/compliance/COMPLIANCE.md

@@ -1,133 +0,0 @@
-# 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

package/compliance/compliance.go

@@ -1,313 +0,0 @@
-package compliance
-
-import (
-	"bytes"
-	"context"
-	"fmt" // Added for Sprintf
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/paralin/goscript/compiler"
-	"github.com/sirupsen/logrus"
-)
-
-// TestCase defines a single Go-to-TypeScript compliance test.
-type TestCase struct {
-	Name           string
-	GoSource       string
-	ExpectedOutput string
-}
-
-// PrepareTempTestDir creates a temp dir, copies .go files, and writes go.mod. Returns tempDir path.
-func PrepareTempTestDir(t *testing.T, testDir string) string {
-	t.Helper()
-	tempDir, err := os.MkdirTemp("", "goscript-test-")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-
-	goModPath := filepath.Join(tempDir, "go.mod")
-	goModContent := []byte("module tempmod\n\ngo 1.24\n")
-	if err := os.WriteFile(goModPath, goModContent, 0o644); err != nil {
-		os.RemoveAll(tempDir) //nolint:errcheck
-		t.Fatalf("failed to write go.mod: %v", err)
-	}
-
-	goFiles, err := filepath.Glob(filepath.Join(testDir, "*.go"))
-	if err != nil || len(goFiles) == 0 {
-		os.RemoveAll(tempDir) //nolint:errcheck
-		t.Fatalf("no .go files found in %s", testDir)
-	}
-	for _, src := range goFiles {
-		base := filepath.Base(src)
-		dst := filepath.Join(tempDir, base)
-		data, err := os.ReadFile(src)
-		if err != nil {
-			os.RemoveAll(tempDir) //nolint:errcheck
-			t.Fatalf("failed to read %s: %v", src, err)
-		}
-		if err := os.WriteFile(dst, data, 0o644); err != nil {
-			os.RemoveAll(tempDir) //nolint:errcheck
-			t.Fatalf("failed to write %s: %v", dst, err)
-		}
-	}
-	return tempDir
-}
-
-// ReadExpectedLog reads expected.log from testDir.
-func ReadExpectedLog(t *testing.T, testDir string) string {
-	t.Helper()
-	expectedLogPath := filepath.Join(testDir, "expected.log")
-	expected, err := os.ReadFile(expectedLogPath)
-	if err != nil {
-		t.Fatalf("failed to read expected.log in %s: %v", testDir, err)
-	}
-	return string(expected)
-}
-
-func CompileGoToTypeScript(t *testing.T, testDir, tempDir, outputDir string, le *logrus.Entry) {
-	t.Helper()
-	conf := &compiler.Config{
-		Dir:            tempDir,
-		OutputPathRoot: outputDir,
-	}
-	if err := conf.Validate(); err != nil {
-		t.Fatalf("invalid compiler config: %v", err)
-	}
-
-	// Log each .go file and its mapped .gs.ts output file and contents
-	goFiles, err := filepath.Glob(filepath.Join(tempDir, "*.go"))
-	if err != nil || len(goFiles) == 0 {
-		t.Fatalf("no .go files found in %s: %v", tempDir, err)
-	}
-	for _, src := range goFiles {
-		base := filepath.Base(src)
-		out := filepath.Join(outputDir, compiler.TranslateGoFilePathToTypescriptFilePath("tempmod", base))
-		t.Logf("Compiling Go file: %s => %s", src, out)
-		if data, err := os.ReadFile(src); err == nil {
-			t.Logf("Source %s:\n%s", src, string(data))
-		} else {
-			t.Logf("could not read source %s: %v", src, err)
-		}
-	}
-
-	comp, err := compiler.NewCompiler(conf, le, nil)
-	if err != nil {
-		t.Fatalf("failed to create compiler: %v", err)
-	}
-	cmpErr := comp.CompilePackages(context.Background(), ".")
-	if cmpErr != nil {
-		t.Errorf("compilation failed: %v", err)
-	}
-
-	// Log generated TypeScript files and copy them back to testDir
-	if err := filepath.WalkDir(outputDir, func(path string, d os.DirEntry, err error) error {
-		if err != nil {
-			t.Logf("error walking path %s: %v", path, err)
-			return nil
-		}
-		if strings.HasSuffix(path, ".gs.ts") { // Look specifically for .gs.ts files
-			// Determine the destination path in the original testDir
-			relPath, err := filepath.Rel(outputDir, path)
-			if err != nil {
-				t.Logf("failed to get relative path for %s: %v", path, err)
-				return nil // Continue walking
-			}
-			// relPath is like "@go/tempmod/file.gs.ts", so extract the base file name
-			parts := strings.Split(relPath, string(filepath.Separator))
-			if len(parts) < 3 {
-				t.Logf("unexpected path structure for %s", path)
-				return nil // Continue walking
-			}
-			fileName := parts[len(parts)-1]
-			destPath := filepath.Join(testDir, fileName)
-
-			// Read the generated content
-			generatedContent, err := os.ReadFile(path)
-			if err != nil {
-				t.Logf("could not read generated file %s: %v", path, err)
-				return nil // Continue walking
-			}
-
-			// Determine the original Go file name
-			goFileName := strings.TrimSuffix(fileName, ".gs.ts") + ".go"
-
-			// Construct the comment
-			comment := fmt.Sprintf("// Generated file based on %s\n// Updated when compliance tests are re-run, DO NOT EDIT!\n\n", goFileName)
-
-			// Prepend the comment to the generated content
-			finalContent := append([]byte(comment), generatedContent...)
-
-			if err := os.WriteFile(destPath, finalContent, 0o644); err != nil {
-				t.Logf("failed to write file %s: %v", destPath, err)
-				return err
-			}
-
-			t.Logf("generated content written to %s:\n%s", destPath, string(finalContent))
-		}
-		return nil
-	}); err != nil {
-		t.Fatalf("error while walking: %v", err.Error())
-	}
-
-	if cmpErr != nil {
-		t.Fatalf("compilation failed: %v", cmpErr)
-	}
-}
-
-// WriteTypeScriptRunner writes a runner.ts file to tempDir.
-func WriteTypeScriptRunner(t *testing.T, tempDir string) string {
-	t.Helper()
-
-	// Find the Go source file in the temp directory
-	goFiles, err := filepath.Glob(filepath.Join(tempDir, "*.go"))
-	if err != nil || len(goFiles) == 0 {
-		t.Fatalf("could not find Go source file in temp dir %s: %v", tempDir, err)
-	}
-	if len(goFiles) > 1 {
-		// For simplicity, assume only one relevant Go file per test case for now.
-		t.Logf("warning: found multiple Go files in %s, using the first one: %s", tempDir, goFiles[0])
-	}
-	goSourceBase := filepath.Base(goFiles[0])
-	tsFileName := strings.TrimSuffix(goSourceBase, ".go") + ".gs.ts"
-	tsImportPath := fmt.Sprintf("./output/@go/tempmod/%s", tsFileName)
-
-	tsRunner := filepath.Join(tempDir, "runner.ts")
-	// Import the goscript runtime and the main function from the compiled code
-	runnerContent := fmt.Sprintf("import { goscript } from \"./goscript\";\nimport { main } from %q;\nmain();\n", tsImportPath) // Use dynamic path
-	if err := os.WriteFile(tsRunner, []byte(runnerContent), 0o644); err != nil {
-		t.Fatalf("failed to write runner: %v", err)
-	}
-	return tsRunner
-}
-
-// RunTypeScriptRunner runs the runner.ts file using tsx and returns its stdout.
-func RunTypeScriptRunner(t *testing.T, workspaceDir, tempDir, tsRunner string) string {
-	t.Helper()
-	cmd := exec.Command("tsx", tsRunner)
-	cmd.Dir = tempDir
-
-	// Prepend node_modules/.bin to PATH
-	nodeBinDir := filepath.Join(workspaceDir, "node_modules", ".bin")
-	currentPath := os.Getenv("PATH")
-	newPath := fmt.Sprintf("%s%c%s", nodeBinDir, os.PathListSeparator, currentPath)
-	cmd.Env = append(os.Environ(), "PATH="+newPath) // Set the modified PATH
-
-	var outBuf, errBuf bytes.Buffer
-	cmd.Stdout = io.MultiWriter(&outBuf, os.Stderr)
-	cmd.Stderr = os.Stderr // Keep stderr going to the test output for debugging
-	if err := cmd.Run(); err != nil {
-		t.Fatalf("run failed: %v\nstderr: %s", err, errBuf.String())
-	}
-	return outBuf.String()
-}
-
-// copyFile copies a file from src to dst.
-func copyFile(src, dst string) error {
-	sourceFile, err := os.Open(src)
-	if err != nil {
-		return fmt.Errorf("failed to open source file %s: %w", src, err)
-	}
-	defer sourceFile.Close() //nolint:errcheck
-
-	// Ensure destination directory exists
-	destDir := filepath.Dir(dst)
-	if err := os.MkdirAll(destDir, 0o755); err != nil {
-		return fmt.Errorf("failed to create destination directory %s: %w", destDir, err)
-	}
-
-	destFile, err := os.Create(dst)
-	if err != nil {
-		return fmt.Errorf("failed to create destination file %s: %w", dst, err)
-	}
-	defer destFile.Close() //nolint:errcheck
-
-	if _, err := io.Copy(destFile, sourceFile); err != nil {
-		return fmt.Errorf("failed to copy file content from %s to %s: %w", src, dst, err)
-	}
-
-	// Ensure data is synced to disk
-	if err := destFile.Sync(); err != nil {
-		return fmt.Errorf("failed to sync destination file %s: %w", dst, err)
-	}
-
-	return nil
-}
-
-// RunGoScriptTestDir compiles all .go files in testDir, runs the generated TypeScript, and compares output to expected.log.
-func RunGoScriptTestDir(t *testing.T, workspaceDir, testDir string) {
-	t.Helper()
-
-	// Check for expect-fail file
-	expectFailPath := filepath.Join(testDir, "expect-fail")
-	if _, err := os.Stat(expectFailPath); err == nil {
-		t.Skipf("Skipping test %s: expect-fail file found", filepath.Base(testDir))
-		return // Skip the test
-	} else if !os.IsNotExist(err) {
-		// If there was an error other than "not exists", fail the test
-		t.Fatalf("failed to check for expect-fail file in %s: %v", testDir, err)
-	}
-
-	log := logrus.New()
-	log.SetLevel(logrus.DebugLevel)
-	le := logrus.NewEntry(log)
-
-	tempDir := PrepareTempTestDir(t, testDir)
-	defer os.RemoveAll(tempDir)
-
-	// Create tsconfig.json in the temporary directory for path aliases
-	builtinTsPath := filepath.Join(workspaceDir, "builtin", "builtin.ts") // Use passed workspaceDir
-	// Ensure the path uses forward slashes for JSON compatibility, even on Windows
-	builtinTsPathForJSON := filepath.ToSlash(builtinTsPath)
-	tsconfigContent := fmt.Sprintf(`{
-	 "compilerOptions": {
-	   "baseUrl": ".",
-	   "paths": {
-	     "@go/builtin": ["%s"]
-	   }
-	 }
-}`, builtinTsPathForJSON) // Use dynamic path
-	tsconfigPath := filepath.Join(tempDir, "tsconfig.json")
-	if err := os.WriteFile(tsconfigPath, []byte(tsconfigContent), 0o644); err != nil {
-		t.Fatalf("failed to write tsconfig.json to temp dir: %v", err)
-	}
-
-	outputDir := filepath.Join(tempDir, "output")
-	CompileGoToTypeScript(t, testDir, tempDir, outputDir, le) // Pass testDir to enable copying output files back to the test directory
-
-	// Copy the goscript runtime file to the temp directory
-	// Use absolute path to avoid issues with changing working directories
-	runtimeSrc := filepath.Join(workspaceDir, "builtin", "builtin.ts") // Use passed workspaceDir
-	runtimeDst := filepath.Join(tempDir, "builtin.ts")                 // Rename to builtin.ts in temp dir
-	if err := copyFile(runtimeSrc, runtimeDst); err != nil {
-		t.Fatalf("failed to copy goscript runtime file: %v", err)
-	}
-
-	tsRunner := WriteTypeScriptRunner(t, tempDir)
-	actual := strings.TrimSpace(RunTypeScriptRunner(t, workspaceDir, tempDir, tsRunner)) // Pass workspaceDir
-
-	expectedLogPath := filepath.Join(testDir, "expected.log")
-	expected, err := os.ReadFile(expectedLogPath)
-	if os.IsNotExist(err) {
-		// If expected.log doesn't exist, write the actual output to it
-		t.Logf("expected.log not found, writing actual output to %s", expectedLogPath)
-		if writeErr := os.WriteFile(expectedLogPath, []byte(actual), 0o644); writeErr != nil {
-			t.Fatalf("failed to write expected.log: %v", writeErr)
-		}
-		// Test passes on the first run if expected.log is generated
-		t.Logf("Generated expected.log for %s", filepath.Base(testDir))
-	} else if err != nil {
-		// If there was another error reading expected.log, fail the test
-		t.Fatalf("failed to read expected.log in %s: %v", testDir, err)
-	} else {
-		// If expected.log exists, compare actual output to expected
-		exp := strings.TrimSpace(string(expected))
-		if actual != exp {
-			t.Fatalf("output mismatch\nExpected:\n%s\nActual:\n%s", exp, actual)
-		}
-	}
-}

package/compliance/compliance_test.go

@@ -1,57 +0,0 @@
-package compliance
-
-import (
-	"os"
-	"path/filepath"
-	"sync"
-	"testing"
-)
-
-func TestCompliance(t *testing.T) {
-	testsDir := "./tests"
-	dirs, err := os.ReadDir(testsDir)
-	if err != nil {
-		t.Fatalf("failed to read tests dir: %v", err)
-	}
-
-	// Get workspace directory (project root)
-	workspaceDir, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("failed to get working directory: %v", err)
-	}
-	workspaceDir = filepath.Join(workspaceDir, "..")
-
-	// First collect all test paths
-	var testPaths []string
-	for _, dir := range dirs {
-		if !dir.IsDir() {
-			continue
-		}
-		testPath := filepath.Join(testsDir, dir.Name())
-		// expectedLogPath := filepath.Join(testPath, "expected.log")
-		// if _, err := os.Stat(expectedLogPath); err != nil {
-		//	continue // skip if no expected.log
-		//}
-		goFiles, err := filepath.Glob(filepath.Join(testPath, "*.go"))
-		if err != nil || len(goFiles) == 0 {
-			t.Errorf("no .go files found in %s", testPath)
-			continue
-		}
-		testPaths = append(testPaths, testPath)
-	}
-
-	// Now run tests in parallel with goroutines
-	var wg sync.WaitGroup
-	for _, testPath := range testPaths {
-		wg.Add(1)
-		go func(path string) {
-			defer wg.Done()
-			t.Run(filepath.Base(path), func(t *testing.T) {
-				RunGoScriptTestDir(t, workspaceDir, path) // Pass workspaceDir
-			})
-		}(testPath)
-	}
-
-	// Wait for all tests to complete
-	wg.Wait()
-}

package/compliance/tests/array_literal/array_literal.go

@@ -1,15 +0,0 @@
-package main
-
-func main() {
-	// Test basic array literal
-	var a [3]int = [3]int{1, 2, 3}
-	println(a[0], a[1], a[2])
-
-	// Test array literal with inferred length
-	b := [...]string{"hello", "world"}
-	println(b[0], b[1])
-
-	// Test array literal with specific element initialization
-	c := [5]int{1: 10, 3: 30}
-	println(c[0], c[1], c[2], c[3], c[4])
-}

package/compliance/tests/array_literal/array_literal.gs.ts

@@ -1,19 +0,0 @@
-// Generated file based on array_literal.go
-// Updated when compliance tests are re-run, DO NOT EDIT!
-
-import * as goscript from "@go/builtin";
-
-export async function main(): Promise<void> {
-	// Test basic array literal
-	let a: number[] = [1, 2, 3];
-	console.log(a[0], a[1], a[2])
-	
-	// Test array literal with inferred length
-	let b = ["hello", "world"]
-	console.log(b[0], b[1])
-	
-	// Test array literal with specific element initialization
-	let c = [0, 10, 0, 30, 0]
-	console.log(c[0], c[1], c[2], c[3], c[4])
-}
-

package/compliance/tests/array_literal/expected.log

@@ -1,3 +0,0 @@
-1 2 3
-hello world
-0 10 0 30 0

package/compliance/tests/async_basic/async_basic.go

@@ -1,26 +0,0 @@
-package main
-
-// This function receives from a channel, making it async.
-func receiveFromChan(ch chan int) int {
-	val := <-ch // This operation makes the function async
-	return val
-}
-
-// This function calls an async function, making it async too.
-func caller(ch chan int) int {
-	// We expect this call to be awaited in TypeScript
-	result := receiveFromChan(ch)
-	return result + 1
-}
-
-func main() {
-	// Create a buffered channel
-	myChan := make(chan int, 1)
-	myChan <- 10 // Send a value
-
-	// Call the async caller function
-	finalResult := caller(myChan)
-	println(finalResult) // Expected output: 11
-
-	close(myChan)
-}

package/compliance/tests/async_basic/async_basic.gs.ts

@@ -1,30 +0,0 @@
-// Generated file based on async_basic.go
-// Updated when compliance tests are re-run, DO NOT EDIT!
-
-import * as goscript from "@go/builtin";
-
-// This function receives from a channel, making it async.
-async function receiveFromChan(ch: goscript.Channel<number>): Promise<number> {
-	let val = await ch.receive() // This operation makes the function async
-	return val
-}
-
-// This function calls an async function, making it async too.
-async function caller(ch: goscript.Channel<number>): Promise<number> {
-	// We expect this call to be awaited in TypeScript
-	let result = await receiveFromChan(ch)
-	return result + 1
-}
-
-export async function main(): Promise<void> {
-	// Create a buffered channel
-	let myChan = goscript.makeChannel<number>(1)
-	await myChan.send(10)
-	
-	// Call the async caller function
-	let finalResult = await caller(myChan)
-	console.log(finalResult) // Expected output: 11
-	
-	myChan.close()
-}
-

package/compliance/tests/async_basic/expected.log

@@ -1 +0,0 @@
-11

package/compliance/tests/basic_arithmetic/basic_arithmetic.go

@@ -1,15 +0,0 @@
-package main
-
-func main() {
-	// === Basic Arithmetic ===
-	add := 2 + 3
-	sub := 10 - 4
-	mul := 6 * 7
-	div := 20 / 5
-	mod := 17 % 3
-	println("Addition: Expected: 5, Actual:", add)
-	println("Subtraction: Expected: 6, Actual:", sub)
-	println("Multiplication: Expected: 42, Actual:", mul)
-	println("Division: Expected: 4, Actual:", div)
-	println("Modulus: Expected: 2, Actual:", mod)
-}

package/compliance/tests/basic_arithmetic/basic_arithmetic.gs.ts

@@ -1,19 +0,0 @@
-// Generated file based on basic_arithmetic.go
-// Updated when compliance tests are re-run, DO NOT EDIT!
-
-import * as goscript from "@go/builtin";
-
-export async function main(): Promise<void> {
-	// === Basic Arithmetic ===
-	let add = 2 + 3
-	let sub = 10 - 4
-	let mul = 6 * 7
-	let div = 20 / 5
-	let mod = 17 % 3
-	console.log("Addition: Expected: 5, Actual:", add)
-	console.log("Subtraction: Expected: 6, Actual:", sub)
-	console.log("Multiplication: Expected: 42, Actual:", mul)
-	console.log("Division: Expected: 4, Actual:", div)
-	console.log("Modulus: Expected: 2, Actual:", mod)
-}
-

package/compliance/tests/basic_arithmetic/expected.log

@@ -1,5 +0,0 @@
-Addition: Expected: 5, Actual: 5
-Subtraction: Expected: 6, Actual: 6
-Multiplication: Expected: 42, Actual: 42
-Division: Expected: 4, Actual: 4
-Modulus: Expected: 2, Actual: 2

package/compliance/tests/boolean_logic/boolean_logic.go

@@ -1,13 +0,0 @@
-package main
-
-func main() {
-	// === Boolean Logic ===
-	a := true
-	b := false
-	and := a && b
-	or := a || b
-	notA := !a
-	println("AND: Expected: false, Actual:", and)
-	println("OR: Expected: true, Actual:", or)
-	println("NOT: Expected: false, Actual:", notA)
-}

package/compliance/tests/boolean_logic/boolean_logic.gs.ts

@@ -1,17 +0,0 @@
-// Generated file based on boolean_logic.go
-// Updated when compliance tests are re-run, DO NOT EDIT!
-
-import * as goscript from "@go/builtin";
-
-export async function main(): Promise<void> {
-	// === Boolean Logic ===
-	let a = true
-	let b = false
-	let and = a && b
-	let or = a || b
-	let notA = !a
-	console.log("AND: Expected: false, Actual:", and)
-	console.log("OR: Expected: true, Actual:", or)
-	console.log("NOT: Expected: false, Actual:", notA)
-}
-