redscript-mc 1.0.0 → 1.1.0

package/src/lowering/index.ts

@@ -10,9 +10,10 @@ import { buildModule } from '../ir/builder'
 import type { IRFunction, IRModule, Operand, BinOp, CmpOp } from '../ir/types'
 import { DiagnosticError } from '../diagnostics'
 import type {
-  Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, Program, RangeExpr, Span, Stmt,
+  Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, GlobalDecl, Program, RangeExpr, Span, Stmt,
   StructDecl, TypeNode, ExecuteSubcommand, BlockPosExpr, CoordComponent
 } from '../ast/types'
+import type { GlobalVar } from '../ir/types'
 
 // ---------------------------------------------------------------------------
 // Builtin Functions
@@ -28,7 +29,8 @@ const BUILTINS: Record<string, (args: string[]) => string | null> = {
   announce:    ([msg]) => `tellraw @a {"text":"${msg}"}`,
   give:        ([sel, item, count, nbt]) => nbt ? `give ${sel} ${item}${nbt} ${count ?? '1'}` : `give ${sel} ${item} ${count ?? '1'}`,
   kill:        ([sel]) => `kill ${sel ?? '@s'}`,
-  effect:      ([sel, eff, dur, amp]) => `effect give ${sel} ${eff} ${dur ?? '30'} ${amp ?? '0'}`,
+  effect:       ([sel, eff, dur, amp]) => `effect give ${sel} ${eff} ${dur ?? '30'} ${amp ?? '0'}`,
+  effect_clear: ([sel, eff]) => eff ? `effect clear ${sel} ${eff}` : `effect clear ${sel}`,
   summon: ([type, x, y, z, nbt]) => {
     const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ')
     return nbt ? `summon ${type} ${pos} ${nbt}` : `summon ${type} ${pos}`
@@ -80,6 +82,7 @@ const BUILTINS: Record<string, (args: string[]) => string | null> = {
   team_leave: () => null, // Special handling
   team_option: () => null, // Special handling
   data_get: () => null, // Special handling (returns value from NBT)
+  data_merge: () => null, // Special handling (merge NBT)
   set_new: () => null, // Special handling (returns set ID)
   set_add: () => null, // Special handling
   set_contains: () => null, // Special handling (returns 1/0)
@@ -154,7 +157,8 @@ function emitBlockPos(pos: BlockPosExpr): string {
 export class Lowering {
   private namespace: string
   private functions: IRFunction[] = []
-  private globals: string[] = []
+  private globals: GlobalVar[] = []
+  private globalNames: Map<string, { mutable: boolean }> = new Map()
   private fnDecls: Map<string, FnDecl> = new Map()
   private specializedFunctions: Map<string, string> = new Map()
   private currentFn: string = ''
@@ -185,6 +189,7 @@ export class Lowering {
 
   constructor(namespace: string) {
     this.namespace = namespace
+    LoweringBuilder.resetTempCounter()
   }
 
   lower(program: Program): IRModule {
@@ -212,6 +217,14 @@ export class Lowering {
       this.varTypes.set(constDecl.name, this.normalizeType(constDecl.type))
     }
 
+    // Process global variable declarations (top-level let)
+    for (const g of program.globals ?? []) {
+      this.globalNames.set(g.name, { mutable: g.mutable })
+      this.varTypes.set(g.name, this.normalizeType(g.type))
+      const initValue = g.init.kind === 'int_lit' ? g.init.value : 0
+      this.globals.push({ name: `$${g.name}`, init: initValue })
+    }
+
     for (const fn of program.declarations) {
       this.fnDecls.set(fn.name, fn)
       this.functionDefaults.set(fn.name, fn.params.map(param => param.default))
@@ -323,6 +336,11 @@ export class Lowering {
       }
     }
 
+    // Check for @load decorator
+    if (fn.decorators.some(d => d.name === 'load')) {
+      irFn.isLoadInit = true
+    }
+
     // Handle tick rate counter if needed
     if (tickRate && tickRate > 1) {
       this.wrapWithTickRate(irFn, tickRate)
@@ -339,7 +357,7 @@ export class Lowering {
   private wrapWithTickRate(fn: IRFunction, rate: number): void {
     // Add tick counter logic to entry block
     const counterVar = `$__tick_${fn.name}`
-    this.globals.push(counterVar)
+    this.globals.push({ name: counterVar, init: 0 })
 
     // Prepend counter logic to entry block
     const entry = fn.blocks[0]
@@ -443,6 +461,15 @@ export class Lowering {
   }
 
   private lowerLetStmt(stmt: Extract<Stmt, { kind: 'let' }>): void {
+    // Check for duplicate declaration of foreach binding
+    if (this.currentContext.binding === stmt.name) {
+      throw new DiagnosticError(
+        'LoweringError',
+        `Cannot redeclare foreach binding '${stmt.name}'`,
+        stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+    
     const varName = `$${stmt.name}`
     this.varMap.set(stmt.name, varName)
 
@@ -495,6 +522,14 @@ export class Lowering {
       return
     }
 
+    // Handle set_new returning a set ID string
+    if (stmt.init.kind === 'call' && stmt.init.fn === 'set_new') {
+      const setId = `__set_${this.foreachCounter++}`
+      this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`)
+      this.stringValues.set(stmt.name, setId)
+      return
+    }
+
     // Handle spawn_object returning entity handle
     if (stmt.init.kind === 'call' && stmt.init.fn === 'spawn_object') {
       const value = this.lowerExpr(stmt.init)
@@ -933,10 +968,22 @@ export class Lowering {
           parts.push(`at ${this.selectorToString(sub.selector)}`)
           break
         case 'if_entity':
-          parts.push(`if entity ${this.selectorToString(sub.selector)}`)
+          if (sub.selector) {
+            parts.push(`if entity ${this.selectorToString(sub.selector)}`)
+          } else if (sub.varName) {
+            // Variable with filters - substitute with @s and apply filters
+            const sel: EntitySelector = { kind: '@s', filters: sub.filters }
+            parts.push(`if entity ${this.selectorToString(sel)}`)
+          }
           break
         case 'unless_entity':
-          parts.push(`unless entity ${this.selectorToString(sub.selector)}`)
+          if (sub.selector) {
+            parts.push(`unless entity ${this.selectorToString(sub.selector)}`)
+          } else if (sub.varName) {
+            // Variable with filters - substitute with @s and apply filters
+            const sel: EntitySelector = { kind: '@s', filters: sub.filters }
+            parts.push(`unless entity ${this.selectorToString(sel)}`)
+          }
           break
         case 'in':
           parts.push(`in ${sub.dimension}`)
@@ -1269,6 +1316,15 @@ export class Lowering {
   }
 
   private lowerAssignExpr(expr: Extract<Expr, { kind: 'assign' }>): Operand {
+    // Check for const reassignment (both compile-time consts and immutable globals)
+    if (this.constValues.has(expr.target)) {
+      throw new DiagnosticError('LoweringError', `Cannot assign to constant '${expr.target}'`, getSpan(expr) ?? { line: 1, col: 1 })
+    }
+    const globalInfo = this.globalNames.get(expr.target)
+    if (globalInfo && !globalInfo.mutable) {
+      throw new DiagnosticError('LoweringError', `Cannot assign to constant '${expr.target}'`, getSpan(expr) ?? { line: 1, col: 1 })
+    }
+
     const blockPosValue = this.resolveBlockPosExpr(expr.value)
     if (blockPosValue) {
       this.blockPosVars.set(expr.target, blockPosValue)
@@ -1744,6 +1800,67 @@ export class Lowering {
       return { kind: 'var', name: dst }
     }
 
+    // data_merge(target, nbt) — merge NBT into entity/block/storage
+    // data_merge(@s, { Invisible: 1b, Silent: 1b })
+    if (name === 'data_merge') {
+      const target = args[0]
+      const nbt = args[1]
+      const nbtStr = this.exprToSnbt ? this.exprToSnbt(nbt) : this.exprToString(nbt)
+      
+      // Check if target is a selector (entity) or string (block/storage)
+      if (target.kind === 'selector') {
+        const sel = this.exprToTargetString(target)
+        this.builder.emitRaw(`data merge entity ${sel} ${nbtStr}`)
+      } else {
+        // Assume block position or storage
+        const targetStr = this.exprToString(target)
+        // If it looks like coordinates, use block; otherwise storage
+        if (targetStr.match(/^~|^\d|^\^/)) {
+          this.builder.emitRaw(`data merge block ${targetStr} ${nbtStr}`)
+        } else {
+          this.builder.emitRaw(`data merge storage ${targetStr} ${nbtStr}`)
+        }
+      }
+      return { kind: 'const', value: 0 }
+    }
+
+    // Set data structure operations — unique collections via NBT storage
+    // set_new is primarily handled in lowerLetStmt for proper string tracking.
+    // This fallback handles standalone set_new() calls without assignment.
+    if (name === 'set_new') {
+      const setId = `__set_${this.foreachCounter++}`
+      this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`)
+      return { kind: 'const', value: 0 }
+    }
+
+    if (name === 'set_add') {
+      const setId = this.exprToString(args[0])
+      const value = this.exprToString(args[1])
+      this.builder.emitRaw(`execute unless data storage rs:sets ${setId}[{value:${value}}] run data modify storage rs:sets ${setId} append value {value:${value}}`)
+      return { kind: 'const', value: 0 }
+    }
+
+    if (name === 'set_contains') {
+      const dst = this.builder.freshTemp()
+      const setId = this.exprToString(args[0])
+      const value = this.exprToString(args[1])
+      this.builder.emitRaw(`execute store result score ${dst} rs if data storage rs:sets ${setId}[{value:${value}}]`)
+      return { kind: 'var', name: dst }
+    }
+
+    if (name === 'set_remove') {
+      const setId = this.exprToString(args[0])
+      const value = this.exprToString(args[1])
+      this.builder.emitRaw(`data remove storage rs:sets ${setId}[{value:${value}}]`)
+      return { kind: 'const', value: 0 }
+    }
+
+    if (name === 'set_clear') {
+      const setId = this.exprToString(args[0])
+      this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`)
+      return { kind: 'const', value: 0 }
+    }
+
     const coordCommand = this.lowerCoordinateBuiltin(name, args)
     if (coordCommand) {
       this.builder.emitRaw(coordCommand)
@@ -1943,6 +2060,17 @@ export class Lowering {
       }
       case 'selector':
         return this.selectorToString(expr.sel)
+      case 'unary':
+        // Handle unary minus on literals directly
+        if (expr.op === '-' && expr.operand.kind === 'int_lit') {
+          return (-expr.operand.value).toString()
+        }
+        if (expr.op === '-' && expr.operand.kind === 'float_lit') {
+          return Math.trunc(-expr.operand.value).toString()
+        }
+        // Fall through to default for complex cases
+        const unaryOp = this.lowerExpr(expr)
+        return this.operandToVar(unaryOp)
       default:
         // Complex expression - lower and return var name
         const op = this.lowerExpr(expr)
@@ -2050,6 +2178,14 @@ export class Lowering {
       return null
     }
 
+    if (name === 'summon') {
+      if (args.length >= 2 && pos1) {
+        const nbt = args[2] ? ` ${this.exprToString(args[2])}` : ''
+        return `summon ${this.exprToString(args[0])} ${emitBlockPos(pos1)}${nbt}`
+      }
+      return null
+    }
+
     return null
   }
 
@@ -2294,6 +2430,13 @@ export class Lowering {
     }
     if (filters.nbt) parts.push(`nbt=${filters.nbt}`)
     if (filters.gamemode) parts.push(`gamemode=${filters.gamemode}`)
+    // Position filters
+    if (filters.x) parts.push(`x=${this.rangeToString(filters.x)}`)
+    if (filters.y) parts.push(`y=${this.rangeToString(filters.y)}`)
+    if (filters.z) parts.push(`z=${this.rangeToString(filters.z)}`)
+    // Rotation filters
+    if (filters.x_rotation) parts.push(`x_rotation=${this.rangeToString(filters.x_rotation)}`)
+    if (filters.y_rotation) parts.push(`y_rotation=${this.rangeToString(filters.y_rotation)}`)
 
     return this.finalizeSelector(parts.length ? `${kind}[${parts.join(',')}]` : kind)
   }
@@ -2318,14 +2461,19 @@ export class Lowering {
 // ---------------------------------------------------------------------------
 
 class LoweringBuilder {
-  private tempCount = 0
+  private static globalTempId = 0
   private labelCount = 0
   private blocks: any[] = []
   private currentBlock: any = null
   private locals = new Set<string>()
 
+  /** Reset the global temp counter (call between compilations). */
+  static resetTempCounter(): void {
+    LoweringBuilder.globalTempId = 0
+  }
+
   freshTemp(): string {
-    const name = `$t${this.tempCount++}`
+    const name = `$_${LoweringBuilder.globalTempId++}`
     this.locals.add(name)
     return name
   }

package/src/mc-test/runner.ts

@@ -1,11 +1,11 @@
 /**
  * RedScript MC Integration Test Runner
  *
- * Compiles a .rs file, installs it to a running Paper server,
+ * Compiles a .mcrs file, installs it to a running Paper server,
  * runs test scenarios, and reports results.
  *
  * Usage:
- *   npx ts-node src/mc-test/runner.ts src/examples/counter.rs
+ *   npx ts-node src/mc-test/runner.ts src/examples/counter.mcrs
  *
  * Requires:
  *   - Paper server running with TestHarnessPlugin
@@ -105,7 +105,7 @@ export async function runMCTests(
 if (require.main === module) {
   const sourceFile = process.argv[2]
   if (!sourceFile) {
-    console.error('Usage: ts-node runner.ts <source.rs>')
+    console.error('Usage: ts-node runner.ts <source.mcrs>')
     process.exit(1)
   }
 

package/src/mc-test/setup.ts

@@ -36,11 +36,11 @@ function main() {
   // Example files
   const exampleNamespaces = ['counter', 'world_manager']
   for (const ns of exampleNamespaces) {
-    const file = path.join(EXAMPLES_DIR, `${ns}.rs`)
+    const file = path.join(EXAMPLES_DIR, `${ns}.mcrs`)
     if (fs.existsSync(file)) {
       writeFixture(fs.readFileSync(file, 'utf-8'), ns)
     } else {
-      console.log(`  ⚠ ${ns}.rs not found, skipping`)
+      console.log(`  ⚠ ${ns}.mcrs not found, skipping`)
     }
   }
 

package/src/parser/index.ts

@@ -7,7 +7,7 @@
 
 import { Lexer, type Token, type TokenKind } from '../lexer'
 import type {
-  Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, LiteralExpr, Param,
+  Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, GlobalDecl, LiteralExpr, Param,
   Program, RangeExpr, SelectorFilter, SelectorKind, Span, Stmt, TypeNode, AssignOp,
   StructDecl, StructField, ExecuteSubcommand, EnumDecl, EnumVariant, BlockPosExpr,
   CoordComponent, LambdaParam
@@ -132,6 +132,7 @@ export class Parser {
 
   parse(defaultNamespace = 'redscript'): Program {
     let namespace = defaultNamespace
+    const globals: GlobalDecl[] = []
     const declarations: FnDecl[] = []
     const structs: StructDecl[] = []
     const enums: EnumDecl[] = []
@@ -147,7 +148,9 @@ export class Parser {
 
     // Parse struct and function declarations
     while (!this.check('eof')) {
-      if (this.check('struct')) {
+      if (this.check('let')) {
+        globals.push(this.parseGlobalDecl(true))
+      } else if (this.check('struct')) {
         structs.push(this.parseStructDecl())
       } else if (this.check('enum')) {
         enums.push(this.parseEnumDecl())
@@ -158,7 +161,7 @@ export class Parser {
       }
     }
 
-    return { namespace, declarations, structs, enums, consts }
+    return { namespace, globals, declarations, structs, enums, consts }
   }
 
   // -------------------------------------------------------------------------
@@ -227,6 +230,17 @@ export class Parser {
     return this.withLoc({ name, type, value }, constToken)
   }
 
+  private parseGlobalDecl(mutable: boolean): GlobalDecl {
+    const token = this.advance() // consume 'let'
+    const name = this.expect('ident').value
+    this.expect(':')
+    const type = this.parseType()
+    this.expect('=')
+    const init = this.parseExpr()
+    this.expect(';')
+    return this.withLoc({ kind: 'global', name, type, init, mutable }, token)
+  }
+
   // -------------------------------------------------------------------------
   // Function Declaration
   // -------------------------------------------------------------------------
@@ -650,15 +664,15 @@ export class Parser {
         if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
           this.advance() // consume 'entity'
         }
-        const selector = this.parseSelector()
-        subcommands.push({ kind: 'if_entity', selector })
+        const selectorOrVar = this.parseSelectorOrVarSelector()
+        subcommands.push({ kind: 'if_entity', ...selectorOrVar })
       } else if (this.match('unless')) {
         // Expect 'entity' keyword (as ident) or just parse selector directly  
         if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
           this.advance() // consume 'entity'
         }
-        const selector = this.parseSelector()
-        subcommands.push({ kind: 'unless_entity', selector })
+        const selectorOrVar = this.parseSelectorOrVarSelector()
+        subcommands.push({ kind: 'unless_entity', ...selectorOrVar })
       } else if (this.match('in')) {
         const dim = this.expect('ident').value
         subcommands.push({ kind: 'in', dimension: dim })
@@ -782,6 +796,10 @@ export class Parser {
             'has_tag': '__entity_has_tag',
             'push': '__array_push',
             'pop': '__array_pop',
+            'add': 'set_add',
+            'contains': 'set_contains',
+            'remove': 'set_remove',
+            'clear': 'set_clear',
           }
           const internalFn = methodMap[expr.field]
           if (internalFn) {
@@ -793,7 +811,14 @@ export class Parser {
             )
             continue
           }
-          this.error(`Unknown method '${expr.field}'`)
+          // Generic method sugar: obj.method(args) → method(obj, args)
+          const args = this.parseArgs()
+          this.expect(')')
+          expr = this.withLoc(
+            { kind: 'call', fn: expr.field, args: [expr.obj, ...args] },
+            this.getLocToken(expr) ?? openParenToken
+          )
+          continue
         }
         const args = this.parseArgs()
         this.expect(')')
@@ -1308,6 +1333,39 @@ export class Parser {
     return this.parseSelectorValue(token.value)
   }
 
+  // Parse either a selector (@a[...]) or a variable with filters (p[...])
+  // Returns { selector } for selectors or { varName, filters } for variables
+  private parseSelectorOrVarSelector(): { selector?: EntitySelector, varName?: string, filters?: SelectorFilter } {
+    if (this.check('selector')) {
+      return { selector: this.parseSelector() }
+    }
+    
+    // Must be an identifier (variable) possibly with filters
+    const varToken = this.expect('ident')
+    const varName = varToken.value
+    
+    // Check for optional filters [...]
+    if (this.check('[')) {
+      this.advance() // consume '['
+      // Collect everything until ']'
+      let filterStr = ''
+      let depth = 1
+      while (depth > 0 && !this.check('eof')) {
+        if (this.check('[')) depth++
+        else if (this.check(']')) depth--
+        if (depth > 0) {
+          filterStr += this.peek().value ?? this.peek().kind
+          this.advance()
+        }
+      }
+      this.expect(']')
+      const filters = this.parseSelectorFilters(filterStr)
+      return { varName, filters }
+    }
+    
+    return { varName }
+  }
+
   private parseSelectorValue(value: string): EntitySelector {
     // Parse @e[type=zombie, distance=..5]
     const bracketIndex = value.indexOf('[')
@@ -1364,6 +1422,21 @@ export class Parser {
         case 'scores':
           filters.scores = this.parseScoresFilter(val)
           break
+        case 'x':
+          filters.x = this.parseRangeValue(val)
+          break
+        case 'y':
+          filters.y = this.parseRangeValue(val)
+          break
+        case 'z':
+          filters.z = this.parseRangeValue(val)
+          break
+        case 'x_rotation':
+          filters.x_rotation = this.parseRangeValue(val)
+          break
+        case 'y_rotation':
+          filters.y_rotation = this.parseRangeValue(val)
+          break
       }
     }