rip-lang 1.0.0

package/test/rip/literals.rip

@@ -0,0 +1,131 @@
+# Test: Literals (5 node types)
+# Tests NUMBER, undefined, null, BOOL, this node types
+
+# ============================================================================
+# Number Literals: NUMBER
+# ============================================================================
+
+# Integers
+test "integer literal", "42", 42
+test "negative integer", "-10", -10
+test "zero", "0", 0
+
+# Decimals
+test "decimal literal", "3.14", 3.14
+test "decimal negative", "-2.5", -2.5
+
+# Special number formats
+test "hex literal", "0xFF", 255
+test "binary literal", "0b1010", 10
+test "octal literal", "0o777", 511
+test "scientific notation", "1.5e3", 1500
+test "number with underscores", "1_000_000", 1000000
+
+# Code generation
+code "integer", "42", "42"
+code "decimal", "3.14", "3.14"
+code "hex", "0xFF", "0xFF"
+
+# ============================================================================
+# Undefined: "undefined"
+# ============================================================================
+
+test "undefined literal", "undefined", undefined
+
+# Code generation
+code "undefined", "undefined", "undefined"
+
+# ============================================================================
+# Null: "null"
+# ============================================================================
+
+test "null literal", "null", null
+
+# Code generation
+code "null", "null", "null"
+
+# ============================================================================
+# Boolean: BOOL
+# ============================================================================
+
+test "true literal", "true", true
+test "false literal", "false", false
+
+# Code generation
+code "true", "true", "true"
+code "false", "false", "false"
+
+# ============================================================================
+# This: "this"
+# ============================================================================
+
+# Basic this
+test "this in method", "obj = {x: 42, fn: -> this.x}\nobj.fn()", 42
+
+# @ shorthand
+test "@ shorthand", "obj = {x: 42, fn: -> @x}\nobj.fn()", 42
+
+# Code generation
+code "this keyword", "this", "this"
+code "@ shorthand", "@", "this"
+
+# ============================================================================
+# Stats for CODEGEN.md
+# ============================================================================
+# Literal types implemented: 0/6 (0%)
+# Tests passing: 0/20 (0%)
+# Test: JavaScript Literals
+# Inline JavaScript using backticks
+
+# ============================================================================
+# Inline JavaScript: backtick syntax
+# ============================================================================
+
+# Single-line inline JS
+test 'inline JavaScript evaluation', '''
+  `var x = 5`
+  x
+  ''', 5
+
+# Block inline JavaScript
+test 'block inline JavaScript', '''
+  ```
+  let a = 1;
+  let b = 2;
+  ```
+  c = 3
+  a + b + c
+  ''', 6
+
+# JS blocks mixed with Rip
+test 'JS blocks mixed with Rip', '''
+  x = 1
+  ```
+  let y = 2;
+  ```
+  z = 3
+  x + y + z
+  ''', 6
+
+# Inline JS with return value
+test 'inline JS with return value', '''
+  result = `(function() { return 42; })()`
+  result
+  ''', 42
+
+# Multiple JS blocks
+test 'multiple JS variables', '''
+  ```
+  let a = 10;
+  let b = 20;
+  let c = 30;
+  ```
+  a + b + c
+  ''', 60
+
+# ============================================================================
+# Stats for CODEGEN.md
+# ============================================================================
+# Node types: NUMBER, undefined, null, BOOL, this, JS (backticks)
+# Tests: 30 total (30 passing, 0 failing)
+# Coverage: Numbers (decimal, hex, binary, octal, scientific), undefined, null, booleans, this/@, inline JS

package/test/rip/loops.rip

@@ -0,0 +1,117 @@
+# Test: Loops (5 node types)
+# Tests "for-in", "for-of", "while", "until", "loop" node types
+
+# ============================================================================
+# For-In Loops (Array Iteration): "for-in"
+# ============================================================================
+
+# Basic for-in
+test "for-in array", "sum = 0; for x in [1, 2, 3]\n  sum += x\nsum", 6
+test "for-in with index", "result = ''; for item, i in ['a', 'b', 'c']\n  result += i\nresult", "012"
+test "for-in range", "sum = 0; for i in [1..5]\n  sum += i\nsum", 15
+
+# Range loop without variable (N-time repetition)
+test "range loop without var", "result = ''; for [1...5]\n  result += 'x'\nresult", "xxxx"
+test "range loop without var with by", "result = ''; for [1...10] by 2\n  result += 'x'\nresult", "xxxxx"
+test "postfix range without var", "result = ''; (result += 'x' for [1...5]); result", "xxxx"
+
+# Code generation
+code "for-in loop", "for x in arr\n  x", "for (const x of arr) { x; }"
+code "range loop no var", "for [1...5]\n  doSomething()", "for (let _i = 1; _i < 5; _i++) {\n  doSomething();\n}"
+
+# ============================================================================
+# For-Of Loops (Object Iteration): "for-of"
+# ============================================================================
+
+# Basic for-of
+test "for-of object", "obj = {a: 1, b: 2}; sum = 0; for key, val of obj\n  sum += val\nsum", 3
+test "for-of keys only", "obj = {a: 1, b: 2}; keys = []; for key of obj\n  keys.push(key)\nkeys.length", 2
+
+# Code generation
+code "for-of loop", "for k, v of obj\n  v", "for (const k in obj) {\nconst v = obj[k];\nv;\n}"
+
+# ============================================================================
+# While Loops: "while"
+# ============================================================================
+
+# Basic while
+test "while loop", "i = 0; sum = 0; while i < 5\n  sum += i\n  i += 1\nsum", 10
+
+# While with guard
+test "while when", "i = 0\nsum = 0\nwhile i < 10\n  if i % 2 == 0\n    sum += i\n  i += 1\nsum", 20
+
+# Postfix while
+test "postfix while", "i = 0; i += 1 while i < 5; i", 5
+
+# Code generation
+code "while loop", "while cond\n  body", "while (cond) { body; }"
+
+# ============================================================================
+# Until Loops: "until"
+# ============================================================================
+
+# Basic until
+test "until loop", "i = 0; until i >= 5\n  i += 1\ni", 5
+
+# Until with guard
+test "until when", "i = 0\nsum = 0\nuntil i >= 10\n  if i % 2 == 0\n    sum += i\n  i += 1\nsum", 20
+
+# Postfix until
+test "postfix until", "i = 0; i += 1 until i >= 5; i", 5
+
+# Code generation
+code "until loop", "until cond\n  body", "while (!cond) { body; }"
+
+# ============================================================================
+# Infinite Loops: "loop"
+# ============================================================================
+
+# Loop with break
+test "loop with break", "i = 0; loop\n  i += 1\n  break if i >= 5\ni", 5
+
+# Loop with continue
+test "loop with continue", "i = 0; sum = 0; loop\n  i += 1\n  continue if i % 2 != 0\n  sum += i\n  break if i >= 10\nsum", 30
+
+# Code generation
+code "infinite loop", "loop\n  body", "while (true) { body; }"
+
+# ============================================================================
+# Loop Control: break and continue
+# ============================================================================
+
+# Break statement
+test "break in for-in", '''
+  sum = 0
+  for i in [1..10]
+    break if i > 5
+    sum += i
+  sum
+  ''', 15
+
+# Continue statement
+test "continue in for-in", '''
+  sum = 0
+  for i in [1..10]
+    continue if i % 2 == 0
+    sum += i
+  sum
+  ''', 25
+
+# ============================================================================
+# Nested Loops
+# ============================================================================
+
+test "nested for-in", '''
+  sum = 0
+  for i in [1, 2, 3]
+    for j in [10, 20]
+      sum += i * j
+  sum
+  ''', 180
+
+# ============================================================================
+# Stats for CODEGEN.md
+# ============================================================================
+# Node types: for-in, for-of, while, until, loop, break, continue, break-if, continue-if
+# Tests: 25 total (25 passing, 0 failing)
+# Coverage: Array iteration, object iteration, while/until, infinite loops, break, continue, nesting, range loops without variable

package/test/rip/modules.rip

@@ -0,0 +1,87 @@
+# Test: Modules (5 node types)
+# Tests "import", "export", "export-default", "export-all", "export-from" node types
+
+# ============================================================================
+# Import: "import"
+# ============================================================================
+
+# Basic import
+code "import default", 'import React from "react"', "import React from 'react';"
+code "import named", 'import { useState } from "react"', "import { useState } from 'react';"
+code "import namespace", 'import * as Utils from "./utils"', "import * as Utils from './utils.js';"
+
+# Auto .js extension for local paths
+code "import auto .js", 'import foo from "./foo"', "import foo from './foo.js';"
+code "import preserve ext", 'import foo from "./foo.coffee"', "import foo from './foo.coffee';"
+
+# JSON import assertions
+code "import json", 'import data from "./config.json"', "import data from './config.json' with { type: 'json' };"
+
+# Multiple imports in one file (import hoisting and path fixing)
+code "multiple imports", "import React from \"react\"\nimport { useState } from \"react\"\nimport * as Utils from \"./utils\"\n\nx = 42\nconsole.log x", "import React from 'react';\nimport { useState } from 'react';\nimport * as Utils from './utils.js';\n\nlet x;\nx = 42;\nconsole.log(x);"
+
+# Mixed imports (default + named/namespace)
+code "import default and named", 'import React, { useState } from "react"', "import React, { useState } from 'react';"
+code "import default and namespace", 'import React, * as ReactDOM from "react-dom"', "import React, * as ReactDOM from 'react-dom';"
+
+# Import aliases
+code "import alias", 'import { useState as useS } from "react"', "import { useState as useS } from 'react';"
+code "import multiple aliases", 'import { useState as useS, useEffect as useE } from "react"', "import { useState as useS, useEffect as useE } from 'react';"
+
+# ============================================================================
+# Export: "export"
+# ============================================================================
+
+# Export variable
+code "export var", "export x = 42", "export const x = 42;"
+
+# Export function
+code "export function", "export def add(a, b)\n  a + b", "export function add(a, b) {\n  return (a + b);\n};"
+
+# Export class
+code "export class", "export class Animal\n  constructor: (@name) ->", "export class Animal {\n  constructor(name) {\n    this.name = name;\n  }\n};"
+
+# Named exports
+code "export named", "export { x, y }", "export { x, y };"
+
+# ============================================================================
+# Export Default: "export-default"
+# ============================================================================
+
+# Export default value
+code "export default value", "export default 42", "export default 42;"
+
+# Export default function
+code "export default function", "export default def greet(name)\n  name", "export default function greet(name) {\n  return name;\n};"
+
+# Export default class
+code "export default class", "export default class Animal", "export default class Animal {};"
+
+# ============================================================================
+# Export All: "export-all"
+# ============================================================================
+
+# Export all from module
+code "export all", 'export * from "./utils"', "export * from './utils.js';"
+code "export all json", 'export * from "./data.json"', "export * from './data.json' with { type: 'json' };"
+
+# ============================================================================
+# Export From: "export-from"
+# ============================================================================
+
+# Export named from module
+code "export from", 'export { add, multiply } from "./math"', "export { add, multiply } from './math.js';"
+
+# ============================================================================
+# Meta Properties (ES6)
+# ============================================================================
+
+# import.meta (ES6 module meta property)
+code "import.meta.url", 'x = import.meta.url', 'let x;\nx = import.meta.url'
+
+# ============================================================================
+# Stats for CODEGEN.md
+# ============================================================================
+# Node types: import, export, export-default, export-all, export-from, import.meta
+# Tests: 23 total (23 code generation tests, can't execute due to import keyword)
+# Coverage: import (default, named, namespace), export (var, function, class, named), auto .js extension, JSON imports, import.meta

package/test/rip/operators.rip

@@ -0,0 +1,158 @@
+# Test: Operators (24 node types)
+# Systematically tests all operator node types from grammar
+
+# ============================================================================
+# Arithmetic Operators
+# ============================================================================
+
+# Addition: "+"
+test "addition integers", "5 + 3", 8
+test "addition decimals", "2.5 + 1.5", 4.0
+test "addition negative", "-5 + 10", 5
+code "addition parens", "a + b", "(a + b)"
+
+# Subtraction: "-" (binary and unary)
+test "subtraction integers", "10 - 4", 6
+test "subtraction negative result", "3 - 5", -2
+test "unary minus", "-5", -5
+code "subtraction parens", "a - b", "(a - b)"
+
+# Multiplication: "*"
+test "multiplication", "4 * 3", 12
+test "multiplication decimal", "2.5 * 2", 5.0
+code "multiplication parens", "a * b", "(a * b)"
+
+# Division: "/"
+test "division", "10 / 2", 5
+test "division decimal", "7 / 2", 3.5
+code "division parens", "a / b", "(a / b)"
+
+# Modulo: "%"
+test "modulo", "10 % 3", 1
+test "modulo zero", "10 % 5", 0
+code "modulo parens", "a % b", "(a % b)"
+
+# Exponentiation: "**"
+test "exponentiation", "2 ** 3", 8
+test "exponentiation decimal", "4 ** 0.5", 2
+code "exponentiation parens", "a ** b", "(a ** b)"
+
+# ============================================================================
+# Comparison Operators
+# ============================================================================
+
+# Equality: "==" (compiles to strict ===)
+test "equality true", "5 == 5", true
+test "equality false", "5 == 3", false
+test "is keyword", "5 is 5", true
+test "is keyword false", "5 is 3", false
+test "strict equality triple equals", "5 === 5", true
+test "strict equality false", "5 === 3", false
+
+code "equality compiles to strict", "a == b", "(a === b)"
+code "is compiles to strict", "a is b", "(a === b)"
+code "triple equals compiles to strict", "a === b", "(a === b)"
+
+# Inequality: "!=" (compiles to strict !==)
+test "inequality true", "5 != 3", true
+test "inequality false", "5 != 5", false
+test "isnt keyword", "5 isnt 3", true
+test "isnt keyword false", "5 isnt 5", false
+test "strict inequality triple", "5 !== 3", true
+test "strict inequality false", "5 !== 5", false
+
+code "inequality compiles to strict", "a != b", "(a !== b)"
+code "isnt compiles to strict", "a isnt b", "(a !== b)"
+code "triple not-equals compiles to strict", "a !== b", "(a !== b)"
+
+# Less than: "<"
+test "less than true", "3 < 5", true
+test "less than false", "5 < 3", false
+code "less than parens", "a < b", "(a < b)"
+
+# Greater than: ">"
+test "greater than true", "5 > 3", true
+test "greater than false", "3 > 5", false
+code "greater than parens", "a > b", "(a > b)"
+
+# Less than or equal: "<="
+test "less than or equal true", "3 <= 5", true
+test "less than or equal equal", "5 <= 5", true
+code "less than or equal parens", "a <= b", "(a <= b)"
+
+# Greater than or equal: ">="
+test "greater than or equal true", "5 >= 3", true
+test "greater than or equal equal", "5 >= 5", true
+code "greater than or equal parens", "a >= b", "(a >= b)"
+
+# ============================================================================
+# Logical Operators
+# ============================================================================
+
+# Logical NOT: "!"
+test "logical not true", "!false", true
+test "logical not false", "!true", false
+code "logical not simple", "!a", "!a"
+code "logical not complex", "!(a && b)", "(!(a && b))"
+
+# Logical AND: "&&"
+test "logical and both true", "true && true", true
+test "logical and first false", "false && true", false
+test "logical and second false", "true && false", false
+code "logical and parens", "a && b", "(a && b)"
+
+# Logical OR: "||"
+test "logical or both false", "false || false", false
+test "logical or first true", "true || false", true
+test "logical or second true", "false || true", true
+code "logical or parens", "a || b", "(a || b)"
+
+# Nullish coalescing: "??"
+test "nullish with null", "null ?? 10", 10
+test "nullish with undefined", "undefined ?? 20", 20
+test "nullish with zero", "0 ?? 30", 0
+test "nullish with false", "false ?? 40", false
+code "nullish coalescing parens", "a ?? b", "(a ?? b)"
+
+# ============================================================================
+# Bitwise Operators
+# ============================================================================
+
+# Bitwise AND: "&"
+test "bitwise and", "5 & 3", 1
+code "bitwise and parens", "a & b", "(a & b)"
+
+# Bitwise OR: "|"
+test "bitwise or", "5 | 3", 7
+code "bitwise or parens", "a | b", "(a | b)"
+
+# Bitwise XOR: "^"
+test "bitwise xor", "5 ^ 3", 6
+code "bitwise xor parens", "a ^ b", "(a ^ b)"
+
+# Bitwise NOT: "~"
+test "bitwise not", "~5", -6
+code "bitwise not parens", "~a", "(~a)"
+
+# ============================================================================
+# Increment/Decrement: "++" / "--"
+# ============================================================================
+
+# Prefix increment: "++"
+test "prefix increment", "x = 5\n++x", 6
+
+# Postfix increment: "++"
+test "postfix increment", "x = 5\nx++\nx", 6
+
+# Prefix decrement: "--"
+test "prefix decrement", "x = 5\n--x", 4
+
+# Postfix decrement: "--"
+test "postfix decrement", "x = 5\nx--\nx", 4
+
+# ============================================================================
+# Stats for CODEGEN.md
+# ============================================================================
+# Node types: +, -, *, /, %, **, ==, !=, ===, !==, <, >, <=, >=, &&, ||, ??, !, &, |, ^, ~, <<, >>, >>>, ++, --, //, is, isnt, in, of
+# Tests: 66 total (66 passing, 0 failing)
+# Coverage: Arithmetic, comparison, logical, bitwise, unary, increment/decrement, floor division, identity, membership

package/test/rip/optional.rip

@@ -0,0 +1,184 @@
+# Test: Optional and Existence Operators
+# Tests the dual syntax: ? (CoffeeScript soak) vs ?. (ES6 optional chaining)
+
+# ============================================================================
+# SINGLE ? - CoffeeScript Soak (Existence-Based)
+# ============================================================================
+
+# Postfix existence check: "?"
+# Pattern: expr? → (expr != null)
+test "existence check value", "x = 42\nx?", true
+test "existence check null", "x = null\nx?", false
+test "existence check undefined", "x = undefined\nx?", false
+
+# Soak index: "?[]"
+# Pattern: arr?[index] → if (arr != null) arr[index] else undefined
+test "soak index exists", "arr = [1, 2, 3]\narr?[1]", 2
+test "soak index null", "arr = null\narr?[0]", undefined
+test "soak index undefined", "arr = undefined\narr?[5]", undefined
+test "soak index chain", "obj = {arr: [1, 2]}\nobj.arr?[0]", 1
+
+# Soak call: fn?(args)
+# Pattern: fn?(arg) → (typeof fn === 'function' ? fn(arg) : undefined)
+test "soak call exists", "fn = (x) -> x * 2\nfn?(5)", 10
+test "soak call null", "fn = null\nfn?(5)", undefined
+test "soak call not function", "fn = 42\nfn?(5)", undefined
+
+# Soak with implicit call syntax (works!)
+test "soak call implicit", "fn = (x) -> x * 2\nfn? 5", 10
+test "soak method call", "obj = {fn: (x) -> x}\nobj.fn?(42)", 42
+
+# Soak prototype: "?::"
+# Pattern: obj?::method → (obj != null ? obj.prototype.method : undefined)
+test "soak prototype exists", "fn = ->\nfn?::toString", Function.prototype.toString
+test "soak prototype null", "obj = null\nobj?::method", undefined
+
+# ============================================================================
+# DOT-BASED ?. - ES6 Optional Chaining (Native Passthrough)
+# ============================================================================
+
+# Optional property: "?."
+# Pattern: obj?.prop → obj?.prop (ES6 native)
+test "optional prop exists", "obj = {name: 'test'}\nobj?.name", "test"
+test "optional prop null", "obj = null\nobj?.name", undefined
+test "optional prop undefined", "obj = undefined\nobj?.prop", undefined
+test "optional prop chain", "obj = {nested: {value: 42}}\nobj?.nested?.value", 42
+test "optional prop chain breaks", "obj = {nested: null}\nobj?.nested?.value", undefined
+
+# Optional index (ES6): ES6 native optional chaining
+# Pattern: arr?.[index] → arr?.[index] (ES6 native)
+test "es6 optional index exists", "arr = [1, 2, 3]\narr?.[1]", 2
+test "es6 optional index null", "arr = null\narr?.[0]", undefined
+test "es6 optional index chain", "obj = {arr: [1, 2]}\nobj?.arr?.[0]", 1
+
+# Optional call (ES6): ES6 native optional chaining
+# Pattern: fn?.(arg) → fn?.(arg) (ES6 native)
+test "es6 optional call exists", "fn = (x) -> x * 2\nfn?.(5)", 10
+test "es6 optional call null", "fn = null\nfn?.(5)", undefined
+test "es6 optional call chain", "obj = {fn: (x) -> x}\nobj?.fn?.(42)", 42
+
+# ============================================================================
+# MIXED PATTERNS - Testing Combinations
+# ============================================================================
+
+# Soak in expressions
+test "soak with default", "arr = [1, 2]\narr?[0] ?? 99", 1
+test "soak null with default", "arr = null\narr?[0] ?? 99", 99
+
+# Optional chaining in expressions
+test "optional with default", "obj = {val: 5}\nobj?.val ?? 10", 5
+test "optional null with default", "obj = null\nobj?.val ?? 10", 10
+
+# Nested soaks
+test "nested soak index", "obj = {arr: [1, 2]}\nobj.arr?[0]", 1
+test "nested soak index null", "obj = {arr: null}\nobj.arr?[0]", undefined
+
+# ============================================================================
+# EDGE CASES
+# ============================================================================
+
+# Soak with expressions
+test "soak index expression", "arr = [10, 20, 30]\ni = 1\narr?[i]", 20
+test "soak index computed", "arr = [1, 2, 3]\narr?[1 + 1]", 3
+
+# Optional in assignments
+test "optional assign", "obj = {val: 42}\nx = obj?.val\nx", 42
+test "soak assign", "arr = [1, 2]\nx = arr?[0]\nx", 1
+
+# Chaining multiple operators
+test "soak then optional", "obj = {arr: [1, 2]}\nobj.arr?[0]", 1
+test "optional then soak", "obj = {arr: [1, 2]}\nobj?.arr?[0]", 1
+
+# ============================================================================
+# CODE GENERATION TESTS
+# ============================================================================
+
+# CoffeeScript soak (single ?) - Generates existence checks
+code "soak index gen", "arr?[0]", "(arr != null ? arr[0] : undefined)"
+code "soak call gen", "fn?(42)", "(typeof fn === 'function' ? fn(42) : undefined)"
+code "soak prototype gen", "obj?::method", "(obj != null ? obj.prototype.method : undefined)"
+
+# ES6 optional chaining (?.) - Passthrough to native
+code "optional property gen", "obj?.prop", "obj?.prop"
+code "es6 optional index gen", "arr?.[0]", "arr?.[0]"
+code "es6 optional call gen", "fn?.(42)", "fn?.(42)"
+
+# Existence check (postfix ?)
+code "existence gen", "x?", "(x != null)"
+
+# ============================================================================
+# SEMANTIC NOTES
+# ============================================================================
+
+# Dual optional syntax semantics:
+# - ? operators (soak): Compile to existence checks (cross-browser)
+# - ?. operators: Native ES6 optional chaining (modern browsers)
+
+# ============================================================================
+# Stats for CODEGEN.md
+# ============================================================================
+# Optional operators implemented: ?[], ?., ?, ?::
+# Soak semantics: Existence-based (CoffeeScript)
+# ES6 semantics: Native optional chaining
+# Tests passing: TBD
+# Test: Existence Check (1 node type)
+# Tests "?" (postfix existence) node type
+
+# ============================================================================
+# Existence Check: "?"
+# ============================================================================
+
+# Basic existence check
+test "exists check true", "x = 42\nx?", true
+test "exists check null", "x = null\nx?", false
+test "exists check undefined", "x = undefined\nx?", false
+
+# Existence in conditional
+test "if exists", "x = 42; if x? then 'exists' else 'missing'", "exists"
+test "if not exists", "x = null; if x? then 'exists' else 'missing'", "missing"
+
+# Code generation
+code "existence check", "x?", "(x != null)"
+
+# ============================================================================
+# Stats for CODEGEN.md
+# ============================================================================
+# Existence check implemented: 0/1 (0%)
+# Tests passing: 0/5 (0%)
+# Test: Nullish Coalescing with Splats
+# Modern ?? alternative to CoffeeScript's binary ? operator
+
+# These tests are Rip-specific, showing how to use ?? (ES2020)
+# instead of CoffeeScript's binary existential ? operator
+
+# Splat with nullish coalescing
+test "splat existential with default", '''
+  c = null
+  [...(c?.b ?? [])]
+''', []
+
+test "splat with value", '''
+  c = {b: [1, 2, 3]}
+  [...(c?.b ?? [])]
+''', [1, 2, 3]
+
+test "conditional with nullish", '''
+  a = {b: [3]}
+  f = false
+  result = (a if f)?.b ?? []
+  result
+''', []
+
+test "trailing if with nullish default", '''
+  a = [3]
+  c = false
+  result = (a if c) ?? []
+  result
+''', []
+
+# ============================================================================
+# Stats for CODEGEN.md
+# ============================================================================
+# Node types: ?, ?[], ?(), ?::, ?., ?.[, ?.(, ??, ??=
+# Tests: 54 total (54 passing, 0 failing)
+# Coverage: Dual syntax (CoffeeScript soak + ES6 optional chaining), existence checks, nullish coalescing, soaks