feat: implement slices sort func

Signed-off-by: Christian Stewart <christian@aperture.us>

Author: paralin

AGENTS.md

@@ -17,6 +17,7 @@ This document contains guidelines and rules for AI agents working on the GoScrip
 - Leverage adding more tests, for example in `compiler/analysis_test.go`, instead of debug logging, for diagnosing issues or investigating hypotheses. If the new test case is temporary and you plan to remove it later, add a `tmp_test.go` file or similar to keep things separated.
 - AVOID type arguments unless necessary (prefer type inference)
 - When making Git commits use the existing commit message pattern and Linux-kernel style commit message bodies.
+- When you would normally add a new compliance test check if a very-similar compliance test already exists and if so extend that one instead. For example testing another function in the same package.
 
 ## Project Overview
 

compiler/composite-lit.go

@@ -341,7 +341,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 		case *types.Map, *types.Struct:
 			// Handle struct directly with the struct literal logic
 			if structType, ok := underlying.(*types.Struct); ok {
-				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+				return c.writeUntypedStructLiteral(exp, tv.Type, structType)
 			}
 			// Map case would be handled here
 			return fmt.Errorf("untyped map composite literals not yet supported")
@@ -356,7 +356,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				// This is an anonymous struct literal with inferred pointer type
 				// Just create the struct object directly - no var-refing needed
 				// Anonymous literals are not variables, so they don't get var-refed
-				return c.writeUntypedStructLiteral(exp, elemType) // true = anonymous
+				return c.writeUntypedStructLiteral(exp, ptrType.Elem(), elemType)
 			default:
 				return fmt.Errorf("unhandled pointer composite literal element type: %T", elemType)
 			}
@@ -384,7 +384,7 @@ func (c *GoToTSCompiler) writeUntypedArrayLiteral(exp *ast.CompositeLit) error {
 }
 
 // writeUntypedStructLiteral handles untyped composite literals that are structs or pointers to structs
-func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, structType *types.Struct) error {
+func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, actualType types.Type, structType *types.Struct) error {
 	// Create field mapping like the typed struct case
 	directFields := make(map[string]ast.Expr)
 
@@ -408,8 +408,23 @@ func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, struct
 		}
 	}
 
-	// Write the object literal (always anonymous for untyped)
-	c.tsw.WriteLiterally("{")
+	// Check if this is a named type
+	isNamed := false
+	if _, ok := actualType.(*types.Named); ok {
+		isNamed = true
+	}
+
+	// Write the object literal
+	if isNamed {
+		// For named structs, use constructor
+		c.tsw.WriteLiterally("$.markAsStructValue(new ")
+		// Write the type name
+		c.WriteGoType(actualType, GoTypeContextGeneral)
+		c.tsw.WriteLiterally("({")
+	} else {
+		// For truly anonymous structs, just write a simple object literal
+		c.tsw.WriteLiterally("{")
+	}
 
 	firstFieldWritten := false
 	// Write fields in order
@@ -434,7 +449,12 @@ func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, struct
 		firstFieldWritten = true
 	}
 
-	c.tsw.WriteLiterally("}")
+	// Close the object literal
+	if isNamed {
+		c.tsw.WriteLiterally("}))")
+	} else {
+		c.tsw.WriteLiterally("}")
+	}
 	return nil
 }
 

compliance/WIP.md

@@ -0,0 +1,51 @@
+# Analysis: Untyped Struct Literals in Slice Literals
+
+## Problem
+
+When we have a slice literal like:
+```go
+people := []Person{
+    {Name: "Charlie", Age: 30},
+    {Name: "Alice", Age: 25},
+    {Name: "Bob", Age: 35},
+}
+```
+
+The generated TypeScript is:
+```ts
+let people = $.arrayToSlice<Person>([{Age: 30, Name: "Charlie"}, {Age: 25, Name: "Alice"}, {Age: 35, Name: "Bob"}])
+```
+
+This generates TypeScript type errors because `{Age: 30, Name: "Charlie"}` is a plain object literal, not a `Person` instance with `_fields` and `clone` methods.
+
+## Root Cause
+
+In `WriteCompositeLit`, when processing array elements at lines 184-186:
+```go
+if elm, ok := elements[i]; ok && elm != nil {
+    if err := c.WriteVarRefedValue(elm); err != nil {
+        return fmt.Errorf("failed to write array literal element: %w", err)
+    }
+}
+```
+
+The elements are untyped composite literals (`{Name: "Charlie", Age: 30}`). When `WriteVarRefedValue` is called on these, it delegates to `WriteValueExpr`, which calls `WriteCompositeLit`.
+
+Inside `WriteCompositeLit` for these untyped literals, the function checks if `exp.Type` is nil (line 334). Since these literals don't have an explicit type in the AST, it falls through to the untyped path starting at line 336.
+
+The untyped path calls `writeUntypedStructLiteral` (line 387) which just creates a plain object literal `{...}` instead of calling the struct constructor.
+
+## Solution
+
+When we have an untyped struct literal, we need to check if the inferred type is a named struct type. If it is, we should generate `new StructName({...})` instead of just `{...}`.
+
+The type information is available via `c.pkg.TypesInfo.Types[exp]` which gives us the inferred type.
+
+## Fix
+
+Modify `writeUntypedStructLiteral` to:
+1. Check if the inferred type for the expression is a named struct type
+2. If so, generate `new TypeName({...})` with the constructor call
+3. If it's truly anonymous (no named type), keep the plain object literal
+
+This requires checking the parent types.Type that led us to call writeUntypedStructLiteral.

compliance/deps/encoding/json/encode.gs.ts

@@ -2015,7 +2015,7 @@ export function appendString<Bytes extends $.Bytes | string>(dst: $.Bytes, src:
 export async function typeFields(t: reflect.Type): Promise<structFields> {
 	// Anonymous fields to explore at the current level and the next.
 	let current = $.arrayToSlice<field>([])
-	let next = $.arrayToSlice<field>([{typ: t}])
+	let next = $.arrayToSlice<field>([$.markAsStructValue(new field({typ: t}))])
 
 	// Count of queued names for current level and the next.
 	let count: Map<reflect.Type, number> | null = null

compliance/tests/slice_nil/expected.log

@@ -0,0 +1,5 @@
+s == nil: true
+s[0:0] == nil: true
+s[:0] == nil: true
+s[:] == nil: true
+slice_nil test passed

compliance/tests/slice_nil/index.ts

@@ -0,0 +1,18 @@
+package main
+
+func main() {
+	var s []int
+	println("s == nil:", s == nil)
+	
+	// Slicing nil with valid bounds should work
+	s2 := s[0:0]
+	println("s[0:0] == nil:", s2 == nil)
+	
+	s3 := s[:0]
+	println("s[:0] == nil:", s3 == nil)
+	
+	s4 := s[:]
+	println("s[:] == nil:", s4 == nil)
+	
+	println("slice_nil test passed")
+}

compliance/tests/slice_nil/slice_nil.go

@@ -0,0 +1,22 @@
+// Generated file based on slice_nil.go
+// Updated when compliance tests are re-run, DO NOT EDIT!
+
+import * as $ from "@goscript/builtin/index.js"
+
+export async function main(): Promise<void> {
+	let s: $.Slice<number> = null
+	console.log("s == nil:", s == null)
+
+	// Slicing nil with valid bounds should work
+	let s2 = $.goSlice(s, 0, 0)
+	console.log("s[0:0] == nil:", s2 == null)
+
+	let s3 = $.goSlice(s, undefined, 0)
+	console.log("s[:0] == nil:", s3 == null)
+
+	let s4 = $.goSlice(s, undefined, undefined)
+	console.log("s[:] == nil:", s4 == null)
+
+	console.log("slice_nil test passed")
+}
+

compliance/tests/slice_nil/slice_nil.gs.ts

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "lib": [
+      "es2022",
+      "esnext.disposable",
+      "dom"
+    ],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "noEmit": true,
+    "paths": {
+      "*": [
+        "./*"
+      ],
+      "@goscript/*": [
+        "../../../gs/*",
+        "../../../compliance/deps/*"
+      ],
+      "@goscript/github.com/aperturerobotics/goscript/compliance/tests/slice_nil/*": [
+        "./*"
+      ]
+    },
+    "sourceMap": true,
+    "target": "es2022"
+  },
+  "extends": "../../../tsconfig.json",
+  "include": [
+    "index.ts",
+    "slice_nil.gs.ts"
+  ]
+}

compliance/tests/slice_nil/tsconfig.json

@@ -0,0 +1,3 @@
+Alice 25
+Charlie 30
+Bob 35