fix: stub unsafe

Signed-off-by: Christian Stewart <[email protected]>

Author: paralin

compiler/builtin_test.go

@@ -42,7 +42,7 @@ func TestEmitBuiltinOption(t *testing.T) {
 			t.Fatalf("Compilation failed: %v", err)
 		}
 
-		// Check that the unsafe package wasn't emitted (we know it's handwritten)
+		// Check that handwritten packages like unsafe aren't emitted when DisableEmitBuiltin=true
 		unsafePath := filepath.Join(outputDir, "@goscript/unsafe")
 		if _, err := os.Stat(unsafePath); !os.IsNotExist(err) {
 			t.Errorf("unsafe package was emitted when DisableEmitBuiltin=true")

compiler/compiler.go

@@ -238,50 +238,6 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			continue
 		}
 
-		// Check if this is the unsafe package, which is not supported in GoScript
-		if pkg.PkgPath == "unsafe" {
-			// Find which packages that would actually be compiled depend on unsafe
-			var dependentPackages []string
-			for _, otherPkg := range pkgs {
-				if otherPkg.PkgPath != "unsafe" {
-					// Check if this package would actually be compiled (same logic as above)
-					wouldBeCompiled := true
-
-					// If the package was not explicitly requested, check if it has a handwritten equivalent
-					if !slices.Contains(patternPkgPaths, otherPkg.PkgPath) {
-						gsSourcePath := "gs/" + otherPkg.PkgPath
-						_, gsErr := gs.GsOverrides.ReadDir(gsSourcePath)
-						if gsErr == nil {
-							// Package has handwritten equivalent, so it wouldn't be compiled
-							wouldBeCompiled = false
-						}
-					}
-
-					// Skip packages that failed to load
-					if len(otherPkg.Errors) > 0 {
-						wouldBeCompiled = false
-					}
-
-					// Only include packages that would actually be compiled and import unsafe
-					if wouldBeCompiled {
-						for importPath := range otherPkg.Imports {
-							if importPath == "unsafe" {
-								dependentPackages = append(dependentPackages, otherPkg.PkgPath)
-								break
-							}
-						}
-					}
-				}
-			}
-
-			dependentList := "unknown package"
-			if len(dependentPackages) > 0 {
-				dependentList = strings.Join(dependentPackages, ", ")
-			}
-
-			return nil, fmt.Errorf("cannot compile package 'unsafe': GoScript does not support the unsafe package due to its low-level memory operations that are incompatible with TypeScript/JavaScript. This package is required by: %s. Consider using alternative approaches that don't require unsafe operations", dependentList)
-		}
-
 		pkgCompiler, err := NewPackageCompiler(c.le, &c.config, pkg)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create package compiler for %s: %w", pkg.PkgPath, err)

compiler/compiler_test.go

@@ -141,7 +141,7 @@ func getParentGoModulePath() (string, error) {
 	return strings.TrimSpace(string(output)), nil
 }
 
-func TestUnsafePackageErrorMessage(t *testing.T) {
+func TestUnsafePackageCompilation(t *testing.T) {
 	// Create a temporary directory for the test output
 	tempDir, err := os.MkdirTemp("", "goscript-test-unsafe")
 	if err != nil {
@@ -154,11 +154,11 @@ func TestUnsafePackageErrorMessage(t *testing.T) {
 	log.SetLevel(logrus.DebugLevel)
 	le := logrus.NewEntry(log)
 
-	// Test with AllDependencies=true to ensure we get all packages including unsafe
+	// Test with AllDependencies=true and DisableEmitBuiltin=false to ensure handwritten packages are copied
 	config := &compiler.Config{
 		OutputPath:         tempDir,
 		AllDependencies:    true,
-		DisableEmitBuiltin: true, // This ensures handwritten packages are skipped
+		DisableEmitBuiltin: false, // This ensures handwritten packages are copied to output
 	}
 
 	comp, err := compiler.NewCompiler(config, le, nil)
@@ -168,32 +168,26 @@ func TestUnsafePackageErrorMessage(t *testing.T) {
 
 	// Try to compile a package that has dependencies that import unsafe
 	// We'll use "sync/atomic" which imports unsafe but doesn't have a handwritten equivalent
-	_, err = comp.CompilePackages(context.Background(), "sync/atomic")
+	result, err := comp.CompilePackages(context.Background(), "sync/atomic")
 
-	// We expect this to fail with an unsafe package error
-	if err == nil {
-		t.Fatalf("Expected compilation to fail due to unsafe package, but it succeeded")
+	// This should now succeed since we have a handwritten unsafe package
+	if err != nil {
+		t.Fatalf("Expected compilation to succeed with handwritten unsafe package, but it failed: %v", err)
 	}
 
-	errorMsg := err.Error()
-
-	// Verify the error message contains the expected text
-	if !strings.Contains(errorMsg, "cannot compile package 'unsafe'") {
-		t.Errorf("Error message should mention unsafe package, got: %s", errorMsg)
+	// Verify that the unsafe package was copied (not compiled) since it has a handwritten equivalent
+	if !slices.Contains(result.CopiedPackages, "unsafe") {
+		t.Errorf("Expected unsafe package to be in CopiedPackages, but it wasn't. CopiedPackages: %v", result.CopiedPackages)
 	}
 
-	// Verify that packages with handwritten equivalents are NOT mentioned in the error
-	// These packages have handwritten equivalents in gs/ and should not be in the error message
-	handwrittenPackages := []string{"runtime", "errors", "time", "context", "slices"}
-
-	for _, pkg := range handwrittenPackages {
-		if strings.Contains(errorMsg, pkg) {
-			t.Errorf("Error message should not mention handwritten package '%s', but it does. Error: %s", pkg, errorMsg)
-		}
+	// Verify that sync/atomic was compiled
+	if !slices.Contains(result.CompiledPackages, "sync/atomic") {
+		t.Errorf("Expected sync/atomic package to be in CompiledPackages, but it wasn't. CompiledPackages: %v", result.CompiledPackages)
 	}
 
-	// The error message should mention sync/atomic since it would actually be compiled
-	if !strings.Contains(errorMsg, "sync/atomic") {
-		t.Errorf("Error message should mention 'sync/atomic' as it would be compiled, got: %s", errorMsg)
+	// Check that the unsafe package directory exists in the output
+	unsafePath := filepath.Join(tempDir, "@goscript/unsafe")
+	if _, err := os.Stat(unsafePath); os.IsNotExist(err) {
+		t.Errorf("unsafe package directory was not created at %s", unsafePath)
 	}
 }

gs/unsafe/index.ts

@@ -0,0 +1 @@
+export * from "./unsafe.js" 

gs/unsafe/unsafe.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest'
+import * as unsafe from './unsafe.js'
+
+describe('unsafe package', () => {
+  it('should throw error for Alignof', () => {
+    expect(() => unsafe.Alignof({})).toThrow('unsafe.Alignof is not supported in JavaScript/TypeScript')
+  })
+
+  it('should throw error for Offsetof', () => {
+    expect(() => unsafe.Offsetof({})).toThrow('unsafe.Offsetof is not supported in JavaScript/TypeScript')
+  })
+
+  it('should throw error for Sizeof', () => {
+    expect(() => unsafe.Sizeof({})).toThrow('unsafe.Sizeof is not supported in JavaScript/TypeScript')
+  })
+
+  it('should throw error for Add', () => {
+    expect(() => unsafe.Add(null, 1)).toThrow('unsafe.Add is not supported in JavaScript/TypeScript')
+  })
+
+  it('should throw error for Slice', () => {
+    expect(() => unsafe.Slice(null, 1)).toThrow('unsafe.Slice is not supported in JavaScript/TypeScript')
+  })
+
+  it('should throw error for SliceData', () => {
+    expect(() => unsafe.SliceData([])).toThrow('unsafe.SliceData is not supported in JavaScript/TypeScript')
+  })
+
+  it('should throw error for String', () => {
+    expect(() => unsafe.String(null, 1)).toThrow('unsafe.String is not supported in JavaScript/TypeScript')
+  })
+
+  it('should throw error for StringData', () => {
+    expect(() => unsafe.StringData('test')).toThrow('unsafe.StringData is not supported in JavaScript/TypeScript')
+  })
+
+  it('should export IntegerType as number type', () => {
+    // IntegerType is just a type alias, so we can't test it directly
+    // But we can verify it's exported and can be used as a type
+    const value: unsafe.IntegerType = 42
+    expect(typeof value).toBe('number')
+  })
+
+  it('should export ArbitraryType and Pointer types', () => {
+    // These are type aliases, so we can't test them directly
+    // But we can verify they can be used as types
+    const arbitrary: unsafe.ArbitraryType = 'anything'
+    const pointer: unsafe.Pointer = null
+    expect(arbitrary).toBe('anything')
+    expect(pointer).toBe(null)
+  })
+}) 

gs/unsafe/unsafe.ts

@@ -0,0 +1,61 @@
+// Package unsafe provides facilities for low-level programming including operations
+// that violate the type system. Most operations are not supported in JavaScript/TypeScript
+// and will throw errors when used.
+
+// ArbitraryType is a shorthand for an arbitrary Go type; it is not a real type
+export type ArbitraryType = any;
+
+// Pointer is a pointer type but a Pointer value may not be dereferenced
+export type Pointer = any;
+
+// IntegerType is a shorthand for an integer type; it is not a real type
+// This is the only type from unsafe that can be meaningfully implemented in JavaScript
+export type IntegerType = number;
+
+// Alignof returns the alignment of the (type of the) variable in bytes
+// This operation is not meaningful in JavaScript/TypeScript
+export function Alignof(variable: ArbitraryType): number {
+  throw new Error("unsafe.Alignof is not supported in JavaScript/TypeScript: memory alignment is not a meaningful concept in JavaScript");
+}
+
+// Offsetof returns the field offset in bytes relative to the struct's address
+// This operation is not meaningful in JavaScript/TypeScript
+export function Offsetof(selector: ArbitraryType): number {
+  throw new Error("unsafe.Offsetof is not supported in JavaScript/TypeScript: memory layout and field offsets are not meaningful concepts in JavaScript");
+}
+
+// Sizeof returns the size of the (type of the) variable in bytes
+// This operation is not meaningful in JavaScript/TypeScript
+export function Sizeof(variable: ArbitraryType): number {
+  throw new Error("unsafe.Sizeof is not supported in JavaScript/TypeScript: memory size is not a meaningful concept in JavaScript");
+}
+
+// Add adds len to ptr and returns the updated pointer
+// Pointer arithmetic is not supported in JavaScript/TypeScript
+export function Add(ptr: Pointer, len: IntegerType): Pointer {
+  throw new Error("unsafe.Add is not supported in JavaScript/TypeScript: pointer arithmetic is not available in JavaScript");
+}
+
+// Slice returns a slice whose underlying array starts at ptr
+// This operation is not meaningful in JavaScript/TypeScript
+export function Slice(ptr: Pointer, len: IntegerType): any[] {
+  throw new Error("unsafe.Slice is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript");
+}
+
+// SliceData returns a pointer to the underlying array of the slice
+// This operation is not meaningful in JavaScript/TypeScript
+export function SliceData(slice: any[]): Pointer {
+  throw new Error("unsafe.SliceData is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript");
+}
+
+// String returns a string value whose underlying bytes start at ptr
+// This operation is not meaningful in JavaScript/TypeScript
+export function String(ptr: Pointer, len: IntegerType): string {
+  throw new Error("unsafe.String is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript");
+}
+
+// StringData returns a pointer to the underlying bytes of the str
+// This operation is not meaningful in JavaScript/TypeScript
+export function StringData(str: string): Pointer {
+  throw new Error("unsafe.StringData is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript");
+} 

package.json

@@ -49,7 +49,7 @@
     "test": "npm run test:go && npm run test:js",
     "test:go": "go test -v ./...",
     "test:js": "npm run typecheck && vitest run",
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsgo --noEmit -p tsconfig.build.json",
     "format": "npm run format:go && npm run format:js && npm run format:config",
     "format:config": "prettier --write tsconfig.json package.json",
     "format:go": "gofumpt -w .",