feat: more compliance tests

paralin · paralin · commit a814421c1383 · 2025-04-25T14:29:09.000-07:00
Signed-off-by: Christian Stewart &lt;christian@aperture.us&gt;
diff --git a/compliance/compliance.go b/compliance/compliance.go
@@ -243,6 +243,16 @@ func copyFile(src, dst string) error {
 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)
diff --git a/compliance/tests/async_basic/async_basic.gs.ts b/compliance/tests/async_basic/async_basic.gs.ts
@@ -4,31 +4,18 @@
 import * as goscript from "@go/builtin";
 
 // This function receives from a channel, making it async.
-async function receiveFromChan(ch: goscript.Chan<number>): Promise<number> {
-	// Assume ch.receive() is the runtime equivalent for <-ch
-	const [val] = await ch.receive()
+function receiveFromChan(ch: /* channel type */): number {
+	let val = /* unhandled unary op: <- */ch // This operation makes the function async
 	return val
 }
 
 // This function calls an async function, making it async too.
-async function caller(ch: goscript.Chan<number>): Promise<number> {
+function caller(ch: /* channel type */): number {
 	// We expect this call to be awaited in TypeScript
-	const result = await receiveFromChan(ch)
+	let result = receiveFromChan(ch)
 	return result + 1
 }
 
-export async function main(): Promise<void> {
+export function main(): void {
 	// Create a buffered channel
-	const myChan = goscript.makeChan<number>(1)
-	// Assume ch.send() is the runtime equivalent for ch <- value
-	await myChan.send(10) // Sending might be async too in the runtime
-
-	// Call the async caller function
-	const finalResult = await caller(myChan)
-	console.log(finalResult) // Expected output: 11
-
-	myChan.close()
-}
-
-// Required for top-level await
-main()
+	let myChan = 
diff --git a/compliance/tests/async_basic/expect-fail b/compliance/tests/async_basic/expect-fail
diff --git a/compliance/tests/for_range/for_range.gs.ts b/compliance/tests/for_range/for_range.gs.ts
@@ -1,4 +1,4 @@
-// Generated file based on test_for_range.go
+// Generated file based on for_range.go
 // Updated when compliance tests are re-run, DO NOT EDIT!
 
 import * as goscript from "@go/builtin";
diff --git a/compliance/tests/method_call_on_pointer_via_value/expected.log b/compliance/tests/method_call_on_pointer_via_value/expected.log
@@ -0,0 +1 @@
+Value after pointer method call via value: Expected: 200, Actual: 200
diff --git a/compliance/tests/method_call_on_pointer_via_value/method_call_on_pointer_via_value.go b/compliance/tests/method_call_on_pointer_via_value/method_call_on_pointer_via_value.go
@@ -0,0 +1,29 @@
+package main
+
+type MyStruct struct {
+	MyInt int
+}
+
+// SetValue sets the MyInt field (pointer receiver).
+func (m *MyStruct) SetValue(v int) {
+	m.MyInt = v
+}
+
+// GetValue returns the MyInt field (value receiver for verification).
+func (m MyStruct) GetValue() int {
+	return m.MyInt
+}
+
+func main() {
+	// Create a struct value
+	msValue := MyStruct{MyInt: 100}
+
+	// === Method Call on Pointer Receiver via Value ===
+	// Call the pointer-receiver method using the value variable.
+	// Go implicitly takes the address of msValue (&msValue) to call SetValue.
+	msValue.SetValue(200)
+
+	// Verify the value was modified through the method call.
+	// Expected: 200
+	println("Value after pointer method call via value: Expected: 200, Actual:", msValue.GetValue())
+}
diff --git a/compliance/tests/method_call_on_pointer_via_value/method_call_on_pointer_via_value.gs.ts b/compliance/tests/method_call_on_pointer_via_value/method_call_on_pointer_via_value.gs.ts
@@ -0,0 +1,38 @@
+// Generated file based on method_call_on_pointer_via_value.go
+// Updated when compliance tests are re-run, DO NOT EDIT!
+
+import * as goscript from "@go/builtin";
+
+class MyStruct {
+	public MyInt: number = 0;
+	
+	// SetValue sets the MyInt field (pointer receiver).
+	public SetValue(v: number): void {
+		const m = this
+		m.MyInt = v
+	}
+	
+	// GetValue returns the MyInt field (value receiver for verification).
+	public GetValue(): number {
+		const m = this
+		return m.MyInt
+	}
+	
+	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 function main(): void {
+	// Create a struct value
+	let msValue = new MyStruct({ MyInt: 100 }).clone()
+	
+	// === Method Call on Pointer Receiver via Value ===
+	// Call the pointer-receiver method using the value variable.
+	// Go implicitly takes the address of msValue (&msValue) to call SetValue.
+	msValue.SetValue(200)
+	
+	// Verify the value was modified through the method call.
+	// Expected: 200
+	console.log("Value after pointer method call via value: Expected: 200, Actual:", msValue.GetValue())
+}
+
diff --git a/compliance/tests/method_call_on_value_via_pointer/expected.log b/compliance/tests/method_call_on_value_via_pointer/expected.log
@@ -0,0 +1,2 @@
+Value via pointer call: Expected: 100, Actual: 100
+Value via pointer call after modification: Expected: 200, Actual: 200
diff --git a/compliance/tests/method_call_on_value_via_pointer/method_call_on_value_via_pointer.go b/compliance/tests/method_call_on_value_via_pointer/method_call_on_value_via_pointer.go
@@ -0,0 +1,30 @@
+package main
+
+type MyStruct struct {
+	MyInt int
+}
+
+// GetValue returns the MyInt field (value receiver).
+func (m MyStruct) GetValue() int {
+	return m.MyInt
+}
+
+func main() {
+	// Create a struct value
+	msValue := MyStruct{MyInt: 100}
+	// Create a pointer to the struct value
+	msPointer := &msValue
+
+	// === Method Call on Value Receiver via Pointer ===
+	// Call the value-receiver method using the pointer variable.
+	// Go implicitly dereferences msPointer to call GetValue on the value.
+	// Expected: 100
+	println("Value via pointer call: Expected: 100, Actual:", msPointer.GetValue())
+
+	// Modify the value through the original value variable
+	msValue.MyInt = 200
+
+	// The pointer still points to the modified value
+	// Expected: 200
+	println("Value via pointer call after modification: Expected: 200, Actual:", msPointer.GetValue())
+}
diff --git a/compliance/tests/method_call_on_value_via_pointer/method_call_on_value_via_pointer.gs.ts b/compliance/tests/method_call_on_value_via_pointer/method_call_on_value_via_pointer.gs.ts
@@ -0,0 +1,38 @@
+// Generated file based on method_call_on_value_via_pointer.go
+// Updated when compliance tests are re-run, DO NOT EDIT!
+
+import * as goscript from "@go/builtin";
+
+class MyStruct {
+	public MyInt: number = 0;
+	
+	// GetValue returns the MyInt field (value receiver).
+	public GetValue(): number {
+		const m = this
+		return m.MyInt
+	}
+	
+	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 function main(): void {
+	// Create a struct value
+	let msValue = new MyStruct({ MyInt: 100 }).clone()
+	// Create a pointer to the struct value
+	let msPointer = msValue
+	
+	// === Method Call on Value Receiver via Pointer ===
+	// Call the value-receiver method using the pointer variable.
+	// Go implicitly dereferences msPointer to call GetValue on the value.
+	// Expected: 100
+	console.log("Value via pointer call: Expected: 100, Actual:", msPointer.GetValue())
+	
+	// Modify the value through the original value variable
+	msValue.MyInt = 200
+	
+	// The pointer still points to the modified value
+	// Expected: 200
+	console.log("Value via pointer call after modification: Expected: 200, Actual:", msPointer.GetValue())
+}
+
diff --git a/compliance/tests/pointer_assignment_no_copy/expected.log b/compliance/tests/pointer_assignment_no_copy/expected.log
@@ -0,0 +1,2 @@
+Pointer copy value: Expected: modified original, Actual: modified original
+Original value after pointer copy modification: Expected: 20, Actual: 20
diff --git a/compliance/tests/pointer_assignment_no_copy/pointer_assignment_no_copy.go b/compliance/tests/pointer_assignment_no_copy/pointer_assignment_no_copy.go
@@ -0,0 +1,28 @@
+package main
+
+type MyStruct struct {
+	MyInt    int
+	MyString string
+}
+
+func main() {
+	original := &MyStruct{MyInt: 10, MyString: "original"}
+
+	// === Pointer Assignment (No Copy) ===
+	// Assigning a pointer variable to another pointer variable.
+	pointerCopy := original
+
+	// Modify the struct through the original pointer.
+	original.MyString = "modified original"
+
+	// The change should be reflected when accessing through the copied pointer.
+	// Expected: "modified original"
+	println("Pointer copy value: Expected: modified original, Actual: " + pointerCopy.MyString)
+
+	// Modify the struct through the copied pointer.
+	pointerCopy.MyInt = 20
+
+	// The change should be reflected when accessing through the original pointer.
+	// Expected: 20
+	println("Original value after pointer copy modification: Expected: 20, Actual:", original.MyInt)
+}
diff --git a/compliance/tests/pointer_assignment_no_copy/pointer_assignment_no_copy.gs.ts b/compliance/tests/pointer_assignment_no_copy/pointer_assignment_no_copy.gs.ts
@@ -0,0 +1,35 @@
+// Generated file based on pointer_assignment_no_copy.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 = "";
+	
+	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 function main(): void {
+	let original = new MyStruct({ MyInt: 10, MyString: "original" })
+	
+	// === Pointer Assignment (No Copy) ===
+	// Assigning a pointer variable to another pointer variable.
+	let pointerCopy = original
+	
+	// Modify the struct through the original pointer.
+	original.MyString = "modified original"
+	
+	// The change should be reflected when accessing through the copied pointer.
+	// Expected: "modified original"
+	console.log("Pointer copy value: Expected: modified original, Actual: " + pointerCopy.MyString)
+	
+	// Modify the struct through the copied pointer.
+	pointerCopy.MyInt = 20
+	
+	// The change should be reflected when accessing through the original pointer.
+	// Expected: 20
+	console.log("Original value after pointer copy modification: Expected: 20, Actual:", original.MyInt)
+}
+
diff --git a/compliance/tests/pointer_composite_literal_assignment/expected.log b/compliance/tests/pointer_composite_literal_assignment/expected.log
@@ -0,0 +1,3 @@
+MyInt via pointer: Expected: 42, Actual: 42
+MyString via pointer: Expected: composite literal pointer, Actual: composite literal pointer
+MyInt after modification: Expected: 99, Actual: 99
diff --git a/compliance/tests/pointer_composite_literal_assignment/pointer_composite_literal_assignment.go b/compliance/tests/pointer_composite_literal_assignment/pointer_composite_literal_assignment.go
@@ -0,0 +1,23 @@
+package main
+
+type MyStruct struct {
+	MyInt    int
+	MyString string
+}
+
+func main() {
+	// === Pointer Composite Literal Assignment ===
+	// Creating a pointer to a struct directly using a composite literal with &
+	structPointer := &MyStruct{MyInt: 42, MyString: "composite literal pointer"}
+
+	// Access fields through the pointer
+	// Expected: 42
+	println("MyInt via pointer: Expected: 42, Actual:", structPointer.MyInt)
+	// Expected: "composite literal pointer"
+	println("MyString via pointer: Expected: composite literal pointer, Actual: " + structPointer.MyString)
+
+	// Modify through the pointer
+	structPointer.MyInt = 99
+	// Expected: 99
+	println("MyInt after modification: Expected: 99, Actual:", structPointer.MyInt)
+}
diff --git a/compliance/tests/pointer_composite_literal_assignment/pointer_composite_literal_assignment.gs.ts b/compliance/tests/pointer_composite_literal_assignment/pointer_composite_literal_assignment.gs.ts
@@ -0,0 +1,30 @@
+// Generated file based on pointer_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 = "";
+	
+	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 function main(): void {
+	// === Pointer Composite Literal Assignment ===
+	// Creating a pointer to a struct directly using a composite literal with &
+	let structPointer = new MyStruct({ MyInt: 42, MyString: "composite literal pointer" })
+	
+	// Access fields through the pointer
+	// Expected: 42
+	console.log("MyInt via pointer: Expected: 42, Actual:", structPointer.MyInt)
+	// Expected: "composite literal pointer"
+	console.log("MyString via pointer: Expected: composite literal pointer, Actual: " + structPointer.MyString)
+	
+	// Modify through the pointer
+	structPointer.MyInt = 99
+	// Expected: 99
+	console.log("MyInt after modification: Expected: 99, Actual:", structPointer.MyInt)
+}
+

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// Generated file based on test_for_range.go`
	`1`	`+// Generated file based on for_range.go`
`2`	`2`	`// Updated when compliance tests are re-run, DO NOT EDIT!`
`3`	`3`
`4`	`4`	`import * as goscript from "@go/builtin";`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+Value after pointer method call via value: Expected: 200, Actual: 200`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+Value via pointer call: Expected: 100, Actual: 100`
	`2`	`+Value via pointer call after modification: Expected: 200, Actual: 200`