goscript 0.0.2

package/compliance/tests/struct_field_access/struct_field_access.go

@@ -0,0 +1,13 @@
+package main
+
+type MyStruct struct {
+	MyInt    int
+	MyString string
+}
+
+func main() {
+	// === Struct Field Access ===
+	ms := MyStruct{MyInt: 42, MyString: "foo"}
+	println("MyInt: Expected: 42, Actual:", ms.MyInt)
+	println("MyString: Expected: foo, Actual:", ms.MyString)
+}

package/compliance/tests/struct_field_access/struct_field_access.gs.ts

@@ -0,0 +1,20 @@
+// Generated file based on struct_field_access.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 async function main(): Promise<void> {
+	// === Struct Field Access ===
+	let ms = new MyStruct({ MyInt: 42, MyString: "foo" })
+	console.log("MyInt: Expected: 42, Actual:", ms.MyInt)
+	console.log("MyString: Expected: foo, Actual:", ms.MyString)
+}
+

package/compliance/tests/struct_value_init_clone/expected.log

@@ -0,0 +1,5 @@
+p1: 1 2
+p1 after p2 mod: 1 2
+p2: 10 2
+v after p3 mod: 3 4
+p3: 3 40

package/compliance/tests/struct_value_init_clone/struct_value_init_clone.go

@@ -0,0 +1,28 @@
+package main
+
+type Point struct {
+	X int
+	Y int
+}
+
+func main() {
+	// Initialize directly
+	p1 := Point{X: 1, Y: 2}
+	println("p1:", p1.X, p1.Y)
+
+	// Assign to another variable (should trigger clone)
+	p2 := p1
+	p2.X = 10 // Modify the copy
+
+	// Print both to show they are independent
+	println("p1 after p2 mod:", p1.X, p1.Y)
+	println("p2:", p2.X, p2.Y)
+
+	// Initialize via variable assignment
+	v := Point{X: 3, Y: 4}
+	p3 := v   // Should trigger clone
+	p3.Y = 40 // Modify the copy
+
+	println("v after p3 mod:", v.X, v.Y)
+	println("p3:", p3.X, p3.Y)
+}

package/compliance/tests/struct_value_init_clone/struct_value_init_clone.gs.ts

@@ -0,0 +1,35 @@
+// Generated file based on struct_value_init_clone.go
+// Updated when compliance tests are re-run, DO NOT EDIT!
+
+import * as goscript from "@go/builtin";
+
+class Point {
+	public X: number = 0;
+	public Y: number = 0;
+	
+	constructor(init?: Partial<Point>) { if (init) Object.assign(this, init as any); }
+	public clone(): Point { return Object.assign(Object.create(Point.prototype) as Point, this); }
+}
+
+export async function main(): Promise<void> {
+	// Initialize directly
+	let p1 = new Point({ X: 1, Y: 2 })
+	console.log("p1:", p1.X, p1.Y)
+	
+	// Assign to another variable (should trigger clone)
+	let p2 = p1.clone()
+	p2.X = 10 // Modify the copy
+	
+	// Print both to show they are independent
+	console.log("p1 after p2 mod:", p1.X, p1.Y)
+	console.log("p2:", p2.X, p2.Y)
+	
+	// Initialize via variable assignment
+	let v = new Point({ X: 3, Y: 4 })
+	let p3 = v.clone() // Should trigger clone
+	p3.Y = 40 // Modify the copy
+	
+	console.log("v after p3 mod:", v.X, v.Y)
+	console.log("p3:", p3.X, p3.Y)
+}
+

package/compliance/tests/switch_statement/expected.log

@@ -0,0 +1,14 @@
+Integer switch:
+two
+
+String switch:
+hello
+
+Switch without expression:
+negative
+
+Switch without expression (zero):
+zero
+
+Switch without expression (positive):
+positive

package/compliance/tests/switch_statement/switch_statement.go

@@ -0,0 +1,59 @@
+package main
+
+func main() {
+	i := 2
+	println("Integer switch:")
+	switch i {
+	case 1:
+		println("one")
+	case 2:
+		println("two")
+	case 3:
+		println("three")
+	default:
+		println("other integer")
+	}
+
+	s := "hello"
+	println("\nString switch:")
+	switch s {
+	case "world":
+		println("world")
+	case "hello":
+		println("hello")
+	default:
+		println("other string")
+	}
+	x := -5
+	println("\nSwitch without expression:")
+	switch {
+	case x < 0:
+		println("negative")
+	case x == 0:
+		println("zero")
+	default: // x > 0
+		println("positive")
+	}
+
+	x = 0
+	println("\nSwitch without expression (zero):")
+	switch {
+	case x < 0:
+		println("negative")
+	case x == 0:
+		println("zero")
+	default: // x > 0
+		println("positive")
+	}
+
+	x = 10
+	println("\nSwitch without expression (positive):")
+	switch {
+	case x < 0:
+		println("negative")
+	case x == 0:
+		println("zero")
+	default: // x > 0
+		println("positive")
+	}
+}

package/compliance/tests/switch_statement/switch_statement.gs.ts

@@ -0,0 +1,85 @@
+// Generated file based on switch_statement.go
+// Updated when compliance tests are re-run, DO NOT EDIT!
+
+import * as goscript from "@go/builtin";
+
+export async function main(): Promise<void> {
+	let i = 2
+	console.log("Integer switch:")
+	switch (i) {
+		case 1:
+			console.log("one")
+			break
+		case 2:
+			console.log("two")
+			break
+		case 3:
+			console.log("three")
+			break
+		default:
+			console.log("other integer")
+			break
+	}
+	
+	let s = "hello"
+	console.log("\nString switch:")
+	switch (s) {
+		case "world":
+			console.log("world")
+			break
+		case "hello":
+			console.log("hello")
+			break
+		default:
+			console.log("other string")
+			break
+	}
+	let x = -5
+	console.log("\nSwitch without expression:")
+	
+	// x > 0
+	switch (true) {
+		case x < 0:
+			console.log("negative")
+			break
+		case x == 0:
+			console.log("zero")
+			break
+		default:
+			console.log("positive")
+			break
+	}
+	
+	x = 0
+	console.log("\nSwitch without expression (zero):")
+	
+	// x > 0
+	switch (true) {
+		case x < 0:
+			console.log("negative")
+			break
+		case x == 0:
+			console.log("zero")
+			break
+		default:
+			console.log("positive")
+			break
+	}
+	
+	x = 10
+	console.log("\nSwitch without expression (positive):")
+	
+	// x > 0
+	switch (true) {
+		case x < 0:
+			console.log("negative")
+			break
+		case x == 0:
+			console.log("zero")
+			break
+		default:
+			console.log("positive")
+			break
+	}
+}
+

package/compliance/tests/value_type_copy_behavior/expected.log

@@ -0,0 +1,3 @@
+valueCopy1: Expected: value copy 1, Actual: value copy 1
+dereferencedStructCopy (modified after copies were made): Expected: original dereferenced copy modified, Actual: original dereferenced copy modified
+valueCopy2: Expected: value copy 2, Actual: value copy 2

package/compliance/tests/value_type_copy_behavior/value_type_copy_behavior.go

@@ -0,0 +1,25 @@
+package main
+
+type MyStruct struct {
+	MyInt    int
+	MyString string
+	myBool   bool
+}
+
+func main() {
+	dereferencedStructCopy := MyStruct{MyString: "original"}
+	// === Value-Type Copy Behavior ===
+	// Assigning a struct (value type) creates independent copies.
+	valueCopy1, valueCopy2, pointerCopy := dereferencedStructCopy, dereferencedStructCopy, &dereferencedStructCopy
+	// Modifications to one copy do not affect others or the original.
+	valueCopy1.MyString = "value copy 1"
+	dereferencedStructCopy.MyString = "original dereferenced copy modified" // Modify the source of the copies
+	valueCopy2.MyString = "value copy 2"
+	// Expected: "value copy 1"
+	println("valueCopy1: Expected: value copy 1, Actual: " + valueCopy1.MyString)
+	// Expected: "original dereferenced copy modified"
+	println("dereferencedStructCopy (modified after copies were made): Expected: original dereferenced copy modified, Actual: " + dereferencedStructCopy.MyString)
+	// Expected: "value copy 2"
+	println("valueCopy2: Expected: value copy 2, Actual: " + valueCopy2.MyString)
+	_ = pointerCopy
+}

package/compliance/tests/value_type_copy_behavior/value_type_copy_behavior.gs.ts

@@ -0,0 +1,34 @@
+// Generated file based on value_type_copy_behavior.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> {
+	let dereferencedStructCopy = new MyStruct({ MyString: "original" })
+	// === Value-Type Copy Behavior ===
+	// Assigning a struct (value type) creates independent copies.
+	let valueCopy1 = dereferencedStructCopy.clone()
+	let valueCopy2 = dereferencedStructCopy.clone()
+	let pointerCopy = dereferencedStructCopy
+	// Modifications to one copy do not affect others or the original.
+	valueCopy1.MyString = "value copy 1"
+	dereferencedStructCopy.MyString = "original dereferenced copy modified" // Modify the source of the copies
+	valueCopy2.MyString = "value copy 2"
+	// Expected: "value copy 1"
+	console.log("valueCopy1: Expected: value copy 1, Actual: " + valueCopy1.MyString)
+	// Expected: "original dereferenced copy modified"
+	console.log("dereferencedStructCopy (modified after copies were made): Expected: original dereferenced copy modified, Actual: " + dereferencedStructCopy.MyString)
+	// Expected: "value copy 2"
+	console.log("valueCopy2: Expected: value copy 2, Actual: " + valueCopy2.MyString)
+	pointerCopy/* discarded value */
+}
+