goscript 0.0.2

package/compliance/compliance.go

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

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

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

@@ -0,0 +1,19 @@
+// 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

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

package/compliance/tests/async_basic/async_basic.go

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

@@ -0,0 +1,30 @@
+// 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

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

package/compliance/tests/basic_arithmetic/basic_arithmetic.go

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

@@ -0,0 +1,19 @@
+// 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

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

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

@@ -0,0 +1,17 @@
+// 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)
+}
+

package/compliance/tests/boolean_logic/expected.log

@@ -0,0 +1,3 @@
+AND: Expected: false, Actual: false
+OR: Expected: true, Actual: true
+NOT: Expected: false, Actual: false

package/compliance/tests/channel_basic/channel_basic.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	messages := make(chan string)
+
+	go func() {
+		messages <- "ping"
+	}()
+
+	msg := <-messages
+	println(msg)
+}

package/compliance/tests/channel_basic/channel_basic.gs.ts

@@ -0,0 +1,18 @@
+// Generated file based on channel_basic.go
+// Updated when compliance tests are re-run, DO NOT EDIT!
+
+import * as goscript from "@go/builtin";
+
+export async function main(): Promise<void> {
+	let messages = goscript.makeChannel<string>(0)
+	
+	queueMicrotask(async () => {
+		{
+			await messages.send("ping")
+		}
+	})
+	
+	let msg = await messages.receive()
+	console.log(msg)
+}
+

package/compliance/tests/channel_basic/expected.log

@@ -0,0 +1 @@
+ping

package/compliance/tests/composite_literal_assignment/composite_literal_assignment.go

@@ -0,0 +1,20 @@
+package main
+
+type MyStruct struct {
+	MyInt    int
+	MyString string
+	myBool   bool
+}
+
+func main() {
+	// === Composite Literal Assignment (Value Copy) ===
+	// Creating a struct directly using a composite literal.
+	structLiteral := MyStruct{MyString: "composite literal"}
+	// Assigning it creates another independent copy.
+	structLiteralCopy := structLiteral
+	structLiteralCopy.MyString = "modified composite literal copy"
+	// Expected: "composite literal"
+	println("Original struct literal: Expected: composite literal, Actual: " + structLiteral.MyString)
+	// Expected: "modified composite literal copy"
+	println("Modified struct literal copy: Expected: modified composite literal copy, Actual: " + structLiteralCopy.MyString)
+}

package/compliance/tests/composite_literal_assignment/composite_literal_assignment.gs.ts

@@ -0,0 +1,27 @@
+// Generated file based on composite_literal_assignment.go
+// Updated when compliance tests are re-run, DO NOT EDIT!
+
+import * as goscript from "@go/builtin";
+
+class MyStruct {
+	public MyInt: number = 0;
+	public MyString: string = "";
+	private myBool: boolean = false;
+	
+	constructor(init?: Partial<MyStruct>) { if (init) Object.assign(this, init as any); }
+	public clone(): MyStruct { return Object.assign(Object.create(MyStruct.prototype) as MyStruct, this); }
+}
+
+export async function main(): Promise<void> {
+	// === Composite Literal Assignment (Value Copy) ===
+	// Creating a struct directly using a composite literal.
+	let structLiteral = new MyStruct({ MyString: "composite literal" })
+	// Assigning it creates another independent copy.
+	let structLiteralCopy = structLiteral.clone()
+	structLiteralCopy.MyString = "modified composite literal copy"
+	// Expected: "composite literal"
+	console.log("Original struct literal: Expected: composite literal, Actual: " + structLiteral.MyString)
+	// Expected: "modified composite literal copy"
+	console.log("Modified struct literal copy: Expected: modified composite literal copy, Actual: " + structLiteralCopy.MyString)
+}
+

package/compliance/tests/composite_literal_assignment/expected.log

@@ -0,0 +1,2 @@
+Original struct literal: Expected: composite literal, Actual: composite literal
+Modified struct literal copy: Expected: modified composite literal copy, Actual: modified composite literal copy

package/compliance/tests/constants/constants.go

@@ -0,0 +1,18 @@
+package main
+
+const (
+	Pi    = 3.14
+	Truth = false
+	// TODO: Handle large integer constants and bit shifts exceeding JS number limits.
+	// Big      = 1 << 60
+	// Small    = Big >> 59 // Commented out as it depends on Big
+	Greeting = "Hello, Constants!"
+)
+
+func main() {
+	println(Pi)
+	println(Truth)
+	// println(Big) // Commented out until large integer handling is implemented
+	// println(Small) // Commented out as it depends on Big
+	println(Greeting)
+}