redscript-mc 2.5.0 → 2.6.2

package/src/parser/index.ts

@@ -10,7 +10,7 @@ import type {
   Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, GlobalDecl, LiteralExpr, Param,
   Program, RangeExpr, SelectorFilter, SelectorKind, Span, Stmt, TypeNode, AssignOp,
   StructDecl, StructField, ExecuteSubcommand, EnumDecl, EnumVariant, BlockPosExpr, ImplBlock,
-  CoordComponent, LambdaParam, EntityTypeName, ImportDecl
+  CoordComponent, LambdaParam, EntityTypeName, ImportDecl, MatchPattern
 } from '../ast/types'
 import type { BinOp, CmpOp } from '../ast/types'
 import { DiagnosticError } from '../diagnostics'
@@ -81,6 +81,8 @@ export class Parser {
    *  `librarySources` compile option, each source is parsed by its own fresh
    *  Parser instance, so this flag never bleeds into user code. */
   private inLibraryMode: boolean = false
+  /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
+  readonly warnings: string[] = []
 
   constructor(tokens: Token[], source?: string, filePath?: string) {
     this.tokens = tokens
@@ -183,7 +185,7 @@ export class Parser {
       this.advance()
       const name = this.expect('ident')
       namespace = name.value
-      this.expect(';')
+      this.match(';')
     }
 
     // Check for module declaration: `module library;` or `module <name>;`
@@ -200,7 +202,7 @@ export class Parser {
         // Named module declaration: `module math;`
         moduleName = modKind.value
       }
-      this.expect(';')
+      this.match(';')
     }
 
     // Parse struct, function, and import declarations
@@ -234,7 +236,7 @@ export class Parser {
         } else {
           symbol = this.expect('ident').value
         }
-        this.expect(';')
+        this.match(';')
         imports.push(this.withLoc({ moduleName: modName, symbol }, importToken))
       } else {
         declarations.push(this.parseFnDecl())
@@ -327,7 +329,7 @@ export class Parser {
     const inferredType: TypeNode = type ?? (
       value.kind === 'str_lit' ? { kind: 'named', name: 'string' } :
       value.kind === 'bool_lit' ? { kind: 'named', name: 'bool' } :
-      value.kind === 'float_lit' ? { kind: 'named', name: 'float' } :
+      value.kind === 'float_lit' ? { kind: 'named', name: 'fixed' } :
       { kind: 'named', name: 'int' }
     )
     return this.withLoc({ name, type: inferredType, value }, constToken)
@@ -340,7 +342,7 @@ export class Parser {
     const type = this.parseType()
     this.expect('=')
     const init = this.parseExpr()
-    this.expect(';')
+    this.match(';')
     return this.withLoc({ kind: 'global', name, type, init, mutable }, token)
   }
 
@@ -393,12 +395,15 @@ export class Parser {
     }
 
     const body = this.parseBlock()
+    // Record the closing '}' line as endLine for accurate LSP scope detection
+    const closingBraceLine = this.tokens[this.pos - 1]?.line
 
     const fn: import('../ast/types').FnDecl = this.withLoc(
       { name, typeParams, params, returnType, decorators: filteredDecorators, body,
         isLibraryFn: this.inLibraryMode || undefined, isExported },
       fnToken,
     )
+    if (fn.span && closingBraceLine) fn.span.endLine = closingBraceLine
     return fn
   }
 
@@ -505,7 +510,7 @@ export class Parser {
       } else if (key === 'batch') {
         args.batch = parseInt(val, 10)
       } else if (key === 'onDone') {
-        args.onDone = val
+        args.onDone = val.replace(/^["']|["']$/g, '')
       } else if (key === 'trigger') {
         args.trigger = val
       } else if (key === 'advancement') {
@@ -570,8 +575,15 @@ export class Parser {
       return { kind: 'tuple', elements }
     }
 
-    if (token.kind === 'int' || token.kind === 'bool' ||
-        token.kind === 'float' || token.kind === 'string' || token.kind === 'void' ||
+    if (token.kind === 'float') {
+      this.advance()
+      const filePart = this.filePath ? `${this.filePath}:` : ''
+      this.warnings.push(
+        `[DeprecatedType] ${filePart}line ${token.line}, col ${token.col}: 'float' is deprecated, use 'fixed' instead (×10000 fixed-point)`
+      )
+      type = { kind: 'named', name: 'float' }
+    } else if (token.kind === 'int' || token.kind === 'bool' ||
+        token.kind === 'fixed' || token.kind === 'string' || token.kind === 'void' ||
         token.kind === 'BlockPos') {
       this.advance()
       type = { kind: 'named', name: token.kind }
@@ -589,6 +601,10 @@ export class Parser {
         const inner = this.parseType()
         this.expect('>')
         type = { kind: 'option', inner }
+      } else if (token.value === 'double' || token.value === 'byte' ||
+                 token.value === 'short' || token.value === 'long' ||
+                 token.value === 'format_string') {
+        type = { kind: 'named', name: token.value as any }
       } else {
         type = { kind: 'struct', name: token.value }
       }
@@ -729,7 +745,7 @@ export class Parser {
       }
       this.expect('=')
       const init = this.parseExpr()
-      this.expect(';')
+      this.match(';')
       return this.withLoc({ kind: 'let_destruct', names, type, init }, letToken)
     }
 
@@ -742,7 +758,7 @@ export class Parser {
 
     this.expect('=')
     const init = this.parseExpr()
-    this.expect(';')
+    this.match(';')
 
     return this.withLoc({ kind: 'let', name, type, init }, letToken)
   }
@@ -751,11 +767,11 @@ export class Parser {
     const returnToken = this.expect('return')
 
     let value: Expr | undefined
-    if (!this.check(';')) {
+    if (!this.check(';') && !this.check('}') && !this.check('eof')) {
       value = this.parseExpr()
     }
 
-    this.expect(';')
+    this.match(';')
     return this.withLoc({ kind: 'return', value }, returnToken)
   }
 
@@ -872,29 +888,57 @@ export class Parser {
 
     let start: Expr
     let end: Expr
+    let inclusive = false
 
     if (this.check('range_lit')) {
-      // Literal range: 0..10, 0..count, 0..=9
+      // Literal range: 0..10, 0..count, 0..=9, 0..=count
       const rangeToken = this.advance()
-      const range = this.parseRangeValue(rangeToken.value)
+      const raw = rangeToken.value
+      // Detect inclusive: ends with = after .. (e.g. "0..=" or "..=")
+      const incl = raw.includes('..=')
+      inclusive = incl
+      const range = this.parseRangeValue(raw)
       start = this.withLoc({ kind: 'int_lit', value: range.min ?? 0 }, rangeToken)
       if (range.max !== null && range.max !== undefined) {
-        // Fully numeric: 0..10
+        // Fully numeric: 0..10 or 0..=9
         end = this.withLoc({ kind: 'int_lit', value: range.max }, rangeToken)
       } else {
-        // Open-ended: "0.." — parse the end expression from next tokens
+        // Open-ended: "0.." or "0..=" — parse the end expression from next tokens
         end = this.parseUnaryExpr()
       }
     } else {
-      // Dynamic range: expr..expr (e.g. start..end) — not yet supported
-      // Fall back to: parse as int_lit 0..0 (safe default)
-      start = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek())
-      end   = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek())
-      this.error('Dynamic range start requires a literal integer (e.g. 0..count)')
+      // Dynamic range: expr..expr or expr..=expr
+      // parseExpr stops before range_lit (not in BINARY_OPS), so this is safe
+      const arrayOrStart = this.parseExpr()
+
+      // --- for_each detection: for item in arr { ... } ---
+      // If after parsing the expression there is no range_lit, it's a for_each (array iteration)
+      if (!this.check('range_lit')) {
+        const body = this.parseBlock()
+        return this.withLoc({ kind: 'for_each', binding: varName, array: arrayOrStart, body }, forToken)
+      }
+
+      start = arrayOrStart
+      // Consume the range_lit token which should be ".." or "..="
+      if (this.check('range_lit')) {
+        const rangeOp = this.advance()
+        inclusive = rangeOp.value.includes('=')
+        // If the range_lit captured digits after .., use them as end
+        const afterOp = rangeOp.value.replace(/^\.\.=?/, '')
+        if (afterOp.length > 0) {
+          end = this.withLoc({ kind: 'int_lit', value: parseInt(afterOp, 10) }, rangeOp)
+        } else {
+          end = this.parseExpr()
+        }
+      } else {
+        this.error('Expected .. or ..= in for-range expression')
+        start = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek())
+        end = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek())
+      }
     }
 
     const body = this.parseBlock()
-    return this.withLoc({ kind: 'for_range', varName, start, end, body }, forToken)
+    return this.withLoc({ kind: 'for_range', varName, start, end, inclusive, body }, forToken)
   }
 
   private parseForeachStmt(): Stmt {
@@ -923,25 +967,62 @@ export class Parser {
     return this.withLoc({ kind: 'foreach', binding, iterable, body, executeContext }, foreachToken)
   }
 
+  private parseMatchPattern(): MatchPattern {
+    // Wildcard: _
+    if (this.check('ident') && this.peek().value === '_') {
+      this.advance()
+      return { kind: 'PatWild' }
+    }
+    // None
+    if (this.check('ident') && this.peek().value === 'None') {
+      this.advance()
+      return { kind: 'PatNone' }
+    }
+    // Some(x)
+    if (this.check('ident') && this.peek().value === 'Some') {
+      this.advance() // consume 'Some'
+      this.expect('(')
+      const binding = this.expect('ident').value
+      this.expect(')')
+      return { kind: 'PatSome', binding }
+    }
+    // Integer literal
+    if (this.check('int_lit')) {
+      const tok = this.advance()
+      return { kind: 'PatInt', value: parseInt(tok.value, 10) }
+    }
+    // Negative integer literal: -N
+    if (this.check('-') && this.peek(1).kind === 'int_lit') {
+      this.advance() // consume '-'
+      const tok = this.advance()
+      return { kind: 'PatInt', value: -parseInt(tok.value, 10) }
+    }
+    // Legacy: range_lit or any other expression (e.g. 0..59)
+    const e = this.parseExpr()
+    return { kind: 'PatExpr', expr: e }
+  }
+
   private parseMatchStmt(): Stmt {
     const matchToken = this.expect('match')
-    this.expect('(')
-    const expr = this.parseExpr()
-    this.expect(')')
+
+    // Support both `match (expr)` (legacy) and `match expr` (new syntax)
+    let expr: Expr
+    if (this.check('(')) {
+      // Peek ahead — if it looks like `(expr)` followed by `{`, consume parens
+      this.advance() // consume '('
+      expr = this.parseExpr()
+      this.expect(')')
+    } else {
+      expr = this.parseExpr()
+    }
     this.expect('{')
 
-    const arms: Array<{ pattern: Expr | null; body: Block }> = []
+    const arms: Array<{ pattern: MatchPattern; body: Block }> = []
     while (!this.check('}') && !this.check('eof')) {
-      let pattern: Expr | null
-      if (this.check('ident') && this.peek().value === '_') {
-        this.advance()
-        pattern = null
-      } else {
-        pattern = this.parseExpr()
-      }
-
+      const pattern = this.parseMatchPattern()
       this.expect('=>')
       const body = this.parseBlock()
+      this.match(',') // optional trailing comma
       arms.push({ pattern, body })
     }
 
@@ -1140,7 +1221,7 @@ export class Parser {
 
   private parseExprStmt(): Stmt {
     const expr = this.parseExpr()
-    this.expect(';')
+    this.match(';')
     const exprToken = this.getLocToken(expr) ?? this.peek()
     return this.withLoc({ kind: 'expr', expr }, exprToken)
   }
@@ -1369,12 +1450,38 @@ export class Parser {
         continue
       }
 
+      // Type cast: expr as Type
+      // Only parse 'as' as a cast when followed by a type token (not a selector like @a)
+      if (this.check('as') && this.isTypeCastAs()) {
+        const asToken = this.advance() // consume 'as'
+        const targetType = this.parseType()
+        expr = this.withLoc(
+          { kind: 'type_cast', expr, targetType },
+          this.getLocToken(expr) ?? asToken
+        )
+        continue
+      }
+
       break
     }
 
     return expr
   }
 
+  /** Returns true if the current 'as' token is a type cast (not a context block) */
+  private isTypeCastAs(): boolean {
+    // Look ahead past 'as' to see if the next token looks like a type
+    const next = this.tokens[this.pos + 1]
+    if (!next) return false
+    const typeStartTokens = new Set(['int', 'bool', 'float', 'fixed', 'string', 'void', 'BlockPos', '('])
+    if (typeStartTokens.has(next.kind)) return true
+    if (next.kind === 'ident' && (
+      next.value === 'double' || next.value === 'byte' || next.value === 'short' ||
+      next.value === 'long' || next.value === 'selector' || next.value === 'Option'
+    )) return true
+    return false
+  }
+
   private parseArgs(): Expr[] {
     const args: Expr[] = []
 
@@ -1495,6 +1602,14 @@ export class Parser {
       }, token)
     }
 
+    // Named struct literal: TypeName { field: value, ... }
+    // Require at least one field (ident + :) to avoid ambiguity with blocks.
+    if (token.kind === 'ident' && this.peek(1).kind === '{' &&
+        this.peek(2).kind === 'ident' && this.peek(3).kind === ':') {
+      this.advance() // consume type name (used only for disambiguation, dropped from AST)
+      return this.parseStructLit()
+    }
+
     // Some(expr) — Option constructor
     if (token.kind === 'ident' && token.value === 'Some' && this.peek(1).kind === '(') {
       this.advance() // consume 'Some'
@@ -1873,6 +1988,7 @@ export class Parser {
       token.kind === 'int' ||
       token.kind === 'bool' ||
       token.kind === 'float' ||
+      token.kind === 'fixed' ||
       token.kind === 'string' ||
       token.kind === 'void' ||
       token.kind === 'BlockPos' ||
@@ -2136,24 +2252,42 @@ export class Parser {
 
   private parseRangeValue(value: string): RangeExpr {
     // ..5 → { max: 5 }
+    // ..=5 → { max: 5 }
     // 1.. → { min: 1 }
+    // 1..= → { min: 1 } (open-ended inclusive, end parsed separately)
     // 1..10 → { min: 1, max: 10 }
+    // 1..=10 → { min: 1, max: 10 }
     // 5 → { min: 5, max: 5 } (exact match)
 
+    if (value.startsWith('..=')) {
+      const rest = value.slice(3)
+      if (!rest) return {}  // open upper bound, no max
+      const max = parseInt(rest, 10)
+      return { max }
+    }
+
     if (value.startsWith('..')) {
-      const max = parseInt(value.slice(2), 10)
+      const rest = value.slice(2)
+      if (!rest) return {}  // open upper bound, no max
+      const max = parseInt(rest, 10)
       return { max }
     }
 
-    if (value.endsWith('..')) {
-      const min = parseInt(value.slice(0, -2), 10)
-      return { min }
+    const inclIdx = value.indexOf('..=')
+    if (inclIdx !== -1) {
+      const min = parseInt(value.slice(0, inclIdx), 10)
+      const rest = value.slice(inclIdx + 3)
+      if (!rest) return { min }  // open-ended inclusive
+      const max = parseInt(rest, 10)
+      return { min, max }
     }
 
     const dotIndex = value.indexOf('..')
     if (dotIndex !== -1) {
       const min = parseInt(value.slice(0, dotIndex), 10)
-      const max = parseInt(value.slice(dotIndex + 2), 10)
+      const rest = value.slice(dotIndex + 2)
+      if (!rest) return { min }  // open-ended
+      const max = parseInt(rest, 10)
       return { min, max }
     }
 

package/src/runtime/index.ts

@@ -273,6 +273,11 @@ export class MCRuntime {
     this.namespace = namespace
     // Initialize default objective
     this.scoreboard.set('rs', new Map())
+    // Pre-populate math:tables with the sin LUT (same values as _math_init in math.mcrs).
+    // This avoids requiring a real MC server for unit tests that use sin_fixed/cos_fixed.
+    // Values: sin(0°..90°) × 1000, 91 entries.
+    const SIN_TABLE = [0,17,35,52,70,87,105,122,139,156,174,191,208,225,242,259,276,292,309,326,342,358,375,391,407,423,438,454,469,485,500,515,530,545,559,574,588,602,616,629,643,656,669,682,695,707,719,731,743,755,766,777,788,799,809,819,829,839,848,857,866,875,883,891,899,906,914,921,927,934,940,946,951,956,961,966,970,974,978,982,985,988,990,993,995,996,998,999,999,1000,1000]
+    this.setStorageField('math:tables', 'sin', SIN_TABLE)
   }
 
   // -------------------------------------------------------------------------
@@ -786,6 +791,27 @@ export class MCRuntime {
   private execFunctionCmd(cmd: string, executor?: Entity): boolean {
     let fnRef = cmd.slice(9).trim() // remove 'function '
 
+    // Handle storage_get_int builtin — compiled as `function ns:storage_get_int`
+    // Parameters: $p0=0 (storagePath, lost as string), $p1=0 (fieldName, lost),
+    // $p2=index. Since string params are lost, we use a hardcoded lookup against
+    // the pre-populated math:tables.sin (the only stdlib user of this builtin).
+    // The result is written to $ret.
+    if (fnRef.endsWith(':storage_get_int')) {
+      const ns = this.namespace
+      const obj = `__${ns}`
+      const idx = this.getScore('$p2', obj)
+      const arr = this.getStorageField('math:tables', 'sin') as number[] | undefined
+      const value = Array.isArray(arr) ? (arr[idx] ?? 0) : 0
+      this.setScore('$ret', obj, value)
+      return true
+    }
+
+    // Handle storage_set_array builtin — compiled as `function ns:storage_set_array`
+    // The sin LUT is already pre-populated in the constructor; this is a no-op.
+    if (fnRef.endsWith(':storage_set_array')) {
+      return true
+    }
+
     // Handle 'function ns:name with storage ns:path' — MC macro calling convention.
     // The called function may have $( ) placeholders that need to be expanded
     // using the provided storage compound. We execute the function after

package/src/stdlib/advanced.mcrs

@@ -309,6 +309,53 @@ fn newton_sqrt(n: int) -> int {
     return x;
 }
 
+// ─── Category 3 (cont.): Higher-order Bezier curves ─────────────────────────
+
+// Quartic Bezier: 5-point curve using De Casteljau's algorithm.
+// t in [0, 1000].
+// bezier_quartic(0, 250, 500, 750, 1000, 0)    == 0    (t=0: start)
+// bezier_quartic(0, 250, 500, 750, 1000, 1000) == 1000 (t=1: end)
+// bezier_quartic(0, 250, 500, 750, 1000, 500)  == 500  (midpoint, uniform pts)
+fn bezier_quartic(p0: int, p1: int, p2: int, p3: int, p4: int, t: int) -> int {
+    let m0: int = lerp(p0, p1, t);
+    let m1: int = lerp(p1, p2, t);
+    let m2: int = lerp(p2, p3, t);
+    let m3: int = lerp(p3, p4, t);
+    let n0: int = lerp(m0, m1, t);
+    let n1: int = lerp(m1, m2, t);
+    let n2: int = lerp(m2, m3, t);
+    let o0: int = lerp(n0, n1, t);
+    let o1: int = lerp(n1, n2, t);
+    return lerp(o0, o1, t);
+}
+
+// bezier_n(pts, n, t): N-order Bezier curve via De Casteljau's algorithm.
+// pts: array of n control points (int[], will be modified in-place).
+// t in [0, 1000].
+// WARNING: modifies pts in-place. Call bezier_n_safe if you need to preserve pts.
+// bezier_n([0,333,667,1000], 4, 0)    == 0    (t=0: returns pts[0])
+// bezier_n([0,333,667,1000], 4, 1000) == 1000 (t=1: returns pts[n-1])
+fn bezier_n(pts: int[], n: int, t: int) -> int {
+    let r: int = 0;
+    while (r < n - 1) {
+        let i: int = 0;
+        while (i < n - 1 - r) {
+            pts[i] = lerp(pts[i], pts[i + 1], t);
+            i = i + 1;
+        }
+        r = r + 1;
+    }
+    return pts[0];
+}
+
+// bezier_n_safe(pts, work, n, t): N-order Bezier, non-destructive.
+// Copies pts into work (length >= n) then runs bezier_n on work.
+// pts is not modified.
+fn bezier_n_safe(pts: int[], work: int[], n: int, t: int) -> int {
+    bigint_copy(pts, work, n);
+    return bezier_n(work, n, t);
+}
+
 // Digital root: repeatedly sum digits until single digit.
 // digital_root(493) == 7  (4+9+3=16 → 1+6=7)
 // digital_root(9) == 9