redscript-mc 1.0.0 → 1.2.0

package/src/__tests__/parser.test.ts

@@ -25,6 +25,7 @@ describe('Parser', () => {
       const program = parse('')
       expect(program.namespace).toBe('test')
       expect(program.declarations).toEqual([])
+      expect(program.implBlocks).toEqual([])
       expect(program.enums).toEqual([])
       expect(program.consts).toEqual([])
     })
@@ -102,6 +103,13 @@ describe('Parser', () => {
         { name: 'on_death' },
       ])
     })
+
+    it('parses @on event decorators', () => {
+      const program = parse('@on(PlayerDeath)\nfn handle_death(player: Player) {}')
+      expect(program.declarations[0].decorators).toEqual([
+        { name: 'on', args: { eventType: 'PlayerDeath' } },
+      ])
+    })
   })
 
   describe('types', () => {
@@ -151,6 +159,52 @@ describe('Parser', () => {
         },
       ])
     })
+
+    it('parses impl blocks', () => {
+      const program = parse(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int): Timer {
+    return { duration: duration };
+  }
+
+  fn start(self) {}
+}
+`)
+      expect(program.implBlocks).toHaveLength(1)
+      expect(program.implBlocks[0].typeName).toBe('Timer')
+      expect(program.implBlocks[0].methods.map(method => method.name)).toEqual(['new', 'start'])
+      expect(program.implBlocks[0].methods[1].params[0]).toEqual({
+        name: 'self',
+        type: { kind: 'struct', name: 'Timer' },
+        default: undefined,
+      })
+    })
+
+    it('parses impl blocks with static and instance methods', () => {
+      const program = parse(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn new(x: int, y: int) -> Point {
+    return { x: x, y: y };
+  }
+
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+`)
+      expect(program.implBlocks).toHaveLength(1)
+      expect(program.implBlocks[0].typeName).toBe('Point')
+      expect(program.implBlocks[0].methods[0].params.map(param => param.name)).toEqual(['x', 'y'])
+      expect(program.implBlocks[0].methods[1].params[0]).toEqual({
+        name: 'self',
+        type: { kind: 'struct', name: 'Point' },
+        default: undefined,
+      })
+    })
   })
 
   describe('statements', () => {
@@ -197,6 +251,28 @@ describe('Parser', () => {
       expect((stmt as any).else_).toHaveLength(1)
     })
 
+    it('parses entity is-checks in if conditions', () => {
+      const stmt = parseStmt('if (e is Player) { kill(@s); }')
+      expect(stmt.kind).toBe('if')
+      expect((stmt as any).cond).toEqual({
+        kind: 'is_check',
+        expr: { kind: 'ident', name: 'e' },
+        entityType: 'Player',
+      })
+    })
+
+    it('parses entity is-checks inside foreach bodies', () => {
+      const stmt = parseStmt('foreach (e in @e) { if (e is Zombie) { kill(e); } }')
+      expect(stmt.kind).toBe('foreach')
+      const innerIf = (stmt as any).body[0]
+      expect(innerIf.kind).toBe('if')
+      expect(innerIf.cond).toEqual({
+        kind: 'is_check',
+        expr: { kind: 'ident', name: 'e' },
+        entityType: 'Zombie',
+      })
+    })
+
     it('parses while statement', () => {
       const stmt = parseStmt('while (i > 0) { i = i - 1; }')
       expect(stmt.kind).toBe('while')
@@ -459,11 +535,11 @@ describe('Parser', () => {
         expect(expr).toEqual({ kind: 'ident', name: 'foo' })
       })
 
-      it('parses function call', () => {
-        const expr = parseExpr('foo(1, 2)')
-        expect(expr).toEqual({
-          kind: 'call',
-          fn: 'foo',
+    it('parses function call', () => {
+      const expr = parseExpr('foo(1, 2)')
+      expect(expr).toEqual({
+        kind: 'call',
+        fn: 'foo',
           args: [
             { kind: 'int_lit', value: 1 },
             { kind: 'int_lit', value: 2 },
@@ -486,6 +562,16 @@ describe('Parser', () => {
       })
     })
 
+    it('parses static method calls', () => {
+      const expr = parseExpr('Timer::new(100)')
+      expect(expr).toEqual({
+        kind: 'static_call',
+        type: 'Timer',
+        method: 'new',
+        args: [{ kind: 'int_lit', value: 100 }],
+      })
+    })
+
     describe('binary operators', () => {
       it('parses arithmetic', () => {
         const expr = parseExpr('1 + 2')

package/src/__tests__/runtime.test.ts

@@ -29,7 +29,7 @@ function loadExample(name: string): string {
 
 describe('MCRuntime behavioral integration', () => {
   it('runs the counter example and increments the scoreboard across ticks', () => {
-    const runtime = loadCompiledProgram(loadExample('counter.rs'))
+    const runtime = loadCompiledProgram(loadExample('counter.mcrs'))
 
     runtime.load()
     runtime.ticks(5)
@@ -57,7 +57,7 @@ fn compute() {
     runtime.load()
     runtime.execFunction('compute')
 
-    expect(runtime.getScore('math', 'result')).toBe(11)
+    expect(runtime.getScore('math', 'runtime.result')).toBe(11)
   })
 
   it('captures say, announce, actionbar, and title output in the chat log', () => {
@@ -135,8 +135,8 @@ fn arrays() {
     runtime.load()
     runtime.execFunction('arrays')
 
-    expect(runtime.getScore('arrays', 'len')).toBe(1)
-    expect(runtime.getScore('arrays', 'last')).toBe(9)
+    expect(runtime.getScore('arrays', 'runtime.len')).toBe(1)
+    expect(runtime.getScore('arrays', 'runtime.last')).toBe(9)
     expect(runtime.getStorage('rs:heap.arr')).toEqual([4])
   })
 
@@ -177,7 +177,7 @@ fn pulse() {
     runtime.load()
     runtime.ticks(10)
 
-    expect(runtime.getScore('pulse', 'count')).toBe(2)
+    expect(runtime.getScore('pulse', 'runtime.count')).toBe(2)
   })
 
   it('executes only the matching match arm', () => {
@@ -234,7 +234,7 @@ fn test() {
     runtime.load()
     runtime.execFunction('test')
 
-    expect(runtime.getScore('lambda', 'direct')).toBe(10)
+    expect(runtime.getScore('lambda', 'runtime.direct')).toBe(10)
   })
 
   it('executes lambdas passed as callback arguments', () => {
@@ -252,7 +252,7 @@ fn test() {
     runtime.load()
     runtime.execFunction('test')
 
-    expect(runtime.getScore('lambda', 'callback')).toBe(15)
+    expect(runtime.getScore('lambda', 'runtime.callback')).toBe(15)
   })
 
   it('executes block-body lambdas', () => {
@@ -270,7 +270,7 @@ fn test() {
     runtime.load()
     runtime.execFunction('test')
 
-    expect(runtime.getScore('lambda', 'block')).toBe(11)
+    expect(runtime.getScore('lambda', 'runtime.block')).toBe(11)
   })
 
   it('executes immediately-invoked expression-body lambdas', () => {
@@ -284,6 +284,6 @@ fn test() {
     runtime.load()
     runtime.execFunction('test')
 
-    expect(runtime.getScore('lambda', 'iife')).toBe(10)
+    expect(runtime.getScore('lambda', 'runtime.iife')).toBe(10)
   })
 })

package/src/__tests__/typechecker.test.ts

@@ -211,6 +211,147 @@ fn test() {
 `)
       expect(errors).toHaveLength(0)
     })
+
+    it('type checks timer builtins with void callbacks and interval IDs', () => {
+      const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => {
+        say("later");
+    });
+    let intervalId: int = setInterval(20, () => {
+        say("tick");
+    });
+    clearInterval(intervalId);
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('rejects timer callbacks with the wrong return type', () => {
+      const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => 1);
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('Return type mismatch: expected void, got int')
+    })
+
+    it('allows impl instance methods with inferred self type', () => {
+      const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+
+fn test() {
+  let timer: Timer = { duration: 10 };
+  let value: int = timer.elapsed();
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('records then-branch entity narrowing for is-checks', () => {
+      const source = `
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(e);
+        }
+    }
+}
+`
+      const tokens = new Lexer(source).tokenize()
+      const ast = new Parser(tokens).parse('test')
+      const checker = new TypeChecker(source) as any
+      checker.check(ast)
+
+      const foreachStmt = ast.declarations[0].body[0] as any
+      const ifStmt = foreachStmt.body[0]
+      expect(checker.getThenBranchNarrowing(ifStmt.cond)).toEqual({
+        name: 'e',
+        type: { kind: 'entity', entityType: 'Player' },
+        mutable: false,
+      })
+    })
+
+    it('allows static impl method calls', () => {
+      const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int) -> Timer {
+    return { duration: duration };
+  }
+}
+
+fn test() {
+  let timer: Timer = Timer::new(10);
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('rejects using is-checks on non-entity values', () => {
+      const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {
+        say("nope");
+    }
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain("'is' checks require an entity expression, got int")
+    })
+
+    it('rejects calling instance impl methods as static methods', () => {
+      const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+
+fn test() {
+  let total: int = Point::distance();
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain("Method 'Point::distance' is an instance method")
+    })
+  })
+
+  describe('entity is-check narrowing', () => {
+    it('allows entity type checks on foreach bindings', () => {
+      const errors = typeCheck(`
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(@s);
+        }
+    }
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('rejects is-checks on non-entity expressions', () => {
+      const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {}
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain("'is' checks require an entity expression")
+    })
   })
 
   describe('return type checking', () => {
@@ -392,4 +533,34 @@ fn broken() -> int {
       expect(errors.length).toBeGreaterThanOrEqual(3)
     })
   })
+
+  describe('event handlers', () => {
+    it('accepts matching @on event signatures', () => {
+      const errors = typeCheck(`
+@on(PlayerDeath)
+fn handle_death(player: Player) {
+    tp(player, @p);
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('rejects unknown event types', () => {
+      const errors = typeCheck(`
+@on(NotARealEvent)
+fn handle(player: Player) {}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain("Unknown event type 'NotARealEvent'")
+    })
+
+    it('rejects mismatched event signatures', () => {
+      const errors = typeCheck(`
+@on(BlockBreak)
+fn handle_break(player: Player) {}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('must declare 2 parameter(s)')
+    })
+  })
 })

package/src/ast/types.ts

@@ -24,12 +24,26 @@ export interface Span {
 
 export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double'
 
+// Entity type hierarchy
+export type EntityTypeName = 
+  | 'entity'      // Base type
+  | 'Player'      // @a, @p, @r
+  | 'Mob'         // Base mob type
+  | 'HostileMob'  // Hostile mobs
+  | 'PassiveMob'  // Passive mobs
+  // Specific mob types (common ones)
+  | 'Zombie' | 'Skeleton' | 'Creeper' | 'Spider' | 'Enderman'
+  | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager'
+  | 'ArmorStand' | 'Item' | 'Arrow'
+
 export type TypeNode =
   | { kind: 'named'; name: PrimitiveType }
   | { kind: 'array'; elem: TypeNode }
   | { kind: 'struct'; name: string }
   | { kind: 'enum'; name: string }
   | { kind: 'function_type'; params: TypeNode[]; return: TypeNode }
+  | { kind: 'entity'; entityType: EntityTypeName }  // Entity types
+  | { kind: 'selector' }  // Selector type (multiple entities)
 
 export interface LambdaParam {
   name: string
@@ -68,6 +82,13 @@ export interface SelectorFilter {
   sort?: 'nearest' | 'furthest' | 'random' | 'arbitrary'
   nbt?: string
   gamemode?: string
+  // Position filters
+  x?: RangeExpr
+  y?: RangeExpr
+  z?: RangeExpr
+  // Rotation filters
+  x_rotation?: RangeExpr
+  y_rotation?: RangeExpr
 }
 
 export interface EntitySelector {
@@ -117,6 +138,7 @@ export type Expr =
   | { kind: 'ident';      name: string; span?: Span }
   | { kind: 'selector';   raw: string; isSingle: boolean; sel: EntitySelector; span?: Span }
   | { kind: 'binary';     op: BinOp | CmpOp | '&&' | '||'; left: Expr; right: Expr; span?: Span }
+  | { kind: 'is_check';   expr: Expr; entityType: EntityTypeName; span?: Span }
   | { kind: 'unary';      op: '!' | '-'; operand: Expr; span?: Span }
   | { kind: 'assign';     target: string; op: AssignOp; value: Expr; span?: Span }
   | { kind: 'call';       fn: string; args: Expr[]; span?: Span }
@@ -146,8 +168,8 @@ export type LiteralExpr =
 export type ExecuteSubcommand =
   | { kind: 'as'; selector: EntitySelector }
   | { kind: 'at'; selector: EntitySelector }
-  | { kind: 'if_entity'; selector: EntitySelector }
-  | { kind: 'unless_entity'; selector: EntitySelector }
+  | { kind: 'if_entity'; selector?: EntitySelector; varName?: string; filters?: SelectorFilter }
+  | { kind: 'unless_entity'; selector?: EntitySelector; varName?: string; filters?: SelectorFilter }
   | { kind: 'in'; dimension: string }
 
 export type Stmt =
@@ -173,9 +195,10 @@ export type Block = Stmt[]
 // ---------------------------------------------------------------------------
 
 export interface Decorator {
-  name: 'tick' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team'
+  name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team'
   args?: {
     rate?: number
+    eventType?: string
     trigger?: string
     advancement?: string
     item?: string
@@ -217,6 +240,13 @@ export interface StructDecl {
   span?: Span
 }
 
+export interface ImplBlock {
+  kind: 'impl_block'
+  typeName: string
+  methods: FnDecl[]
+  span?: Span
+}
+
 export interface EnumVariant {
   name: string
   value?: number
@@ -235,14 +265,25 @@ export interface ConstDecl {
   span?: Span
 }
 
+export interface GlobalDecl {
+  kind: 'global'
+  name: string
+  type: TypeNode
+  init: Expr
+  mutable: boolean  // let = true, const = false
+  span?: Span
+}
+
 // ---------------------------------------------------------------------------
 // Program (Top-Level)
 // ---------------------------------------------------------------------------
 
 export interface Program {
   namespace: string    // Inferred from filename or `namespace mypack;`
+  globals: GlobalDecl[]
   declarations: FnDecl[]
   structs: StructDecl[]
+  implBlocks: ImplBlock[]
   enums: EnumDecl[]
   consts: ConstDecl[]
 }

package/src/cli.ts

@@ -29,13 +29,13 @@ Usage:
   redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
-  redscript fmt <file.rs> [file2.rs ...]
+  redscript fmt <file.mcrs> [file2.mcrs ...]
   redscript repl
   redscript version
 
 Commands:
   compile   Compile a RedScript file to a Minecraft datapack
-  watch     Watch a directory for .rs file changes, recompile, and hot reload
+  watch     Watch a directory for .mcrs file changes, recompile, and hot reload
   check     Check a RedScript file for errors without generating output
   fmt       Auto-format RedScript source files
   repl      Start an interactive RedScript REPL
@@ -268,7 +268,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
     process.exit(1)
   }
 
-  console.log(`👁  Watching ${dir} for .rs file changes...`)
+  console.log(`👁  Watching ${dir} for .mcrs file changes...`)
   console.log(`   Output: ${output}`)
   if (hotReloadUrl) console.log(`   Hot reload: ${hotReloadUrl}`)
   console.log(`   Press Ctrl+C to stop\n`)
@@ -276,11 +276,11 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
   // Debounce timer
   let debounceTimer: NodeJS.Timeout | null = null
 
-  // Compile all .rs files in directory
+  // Compile all .mcrs files in directory
   async function compileAll(): Promise<void> {
     const files = findRsFiles(dir)
     if (files.length === 0) {
-      console.log(`⚠  No .rs files found in ${dir}`)
+      console.log(`⚠  No .mcrs files found in ${dir}`)
       return
     }
 
@@ -319,7 +319,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
     }
   }
 
-  // Find all .rs files recursively
+  // Find all .mcrs files recursively
   function findRsFiles(directory: string): string[] {
     const results: string[] = []
     const entries = fs.readdirSync(directory, { withFileTypes: true })
@@ -328,7 +328,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
       const fullPath = path.join(directory, entry.name)
       if (entry.isDirectory()) {
         results.push(...findRsFiles(fullPath))
-      } else if (entry.isFile() && entry.name.endsWith('.rs')) {
+      } else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
         results.push(fullPath)
       }
     }
@@ -341,7 +341,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
 
   // Watch for changes
   fs.watch(dir, { recursive: true }, (eventType, filename) => {
-    if (filename && filename.endsWith('.rs')) {
+    if (filename && filename.endsWith('.mcrs')) {
       // Debounce rapid changes
       if (debounceTimer) {
         clearTimeout(debounceTimer)
@@ -412,9 +412,9 @@ async function main(): Promise<void> {
 
     case 'fmt':
     case 'format': {
-      const files = args.filter(a => a.endsWith('.rs'))
+      const files = args.filter(a => a.endsWith('.mcrs'))
       if (files.length === 0) {
-        console.error('Usage: redscript fmt <file.rs> [file2.rs ...]')
+        console.error('Usage: redscript fmt <file.mcrs> [file2.mcrs ...]')
         process.exit(1)
       }
       const { format } = require('./formatter')

package/src/codegen/mcfunction/index.ts

@@ -11,13 +11,14 @@
  * Variable mapping:
  *   scoreboard objective: "rs"
  *   fake player:          "$<varname>"
- *   temporaries:          "$t0", "$t1", ...
+ *   temporaries:          "$_0", "$_1", ...
  *   return value:         "$ret"
  *   parameters:           "$p0", "$p1", ...
  */
 
 import type { IRBlock, IRFunction, IRModule, Operand, Terminator } from '../../ir/types'
 import { optimizeCommandFunctions, type OptimizationStats, createEmptyOptimizationStats, mergeOptimizationStats } from '../../optimizer/commands'
+import { EVENT_TYPES, isEventTypeName, type EventTypeName } from '../../events/types'
 
 // ---------------------------------------------------------------------------
 // Utilities
@@ -270,6 +271,10 @@ export function generateDatapackWithStats(
   // Collect all trigger handlers
   const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName)
   const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName!))
+  const eventHandlers = module.functions.filter((fn): fn is IRFunction & { eventHandler: { eventType: EventTypeName; tag: string } } =>
+    !!fn.eventHandler && isEventTypeName(fn.eventHandler.eventType)
+  )
+  const eventTypes = new Set<EventTypeName>(eventHandlers.map(fn => fn.eventHandler.eventType))
 
   // Collect all tick functions
   const tickFunctionNames: string[] = []
@@ -293,7 +298,7 @@ export function generateDatapackWithStats(
     `scoreboard objectives add ${OBJ} dummy`,
   ]
   for (const g of module.globals) {
-    loadLines.push(`scoreboard players set ${varRef(g)} ${OBJ} 0`)
+    loadLines.push(`scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`)
   }
 
   // Add trigger objectives
@@ -302,6 +307,19 @@ export function generateDatapackWithStats(
     loadLines.push(`scoreboard players enable @a ${triggerName}`)
   }
 
+  for (const eventType of eventTypes) {
+    const detection = EVENT_TYPES[eventType].detection
+    if (eventType === 'PlayerDeath') {
+      loadLines.push('scoreboard objectives add rs.deaths deathCount')
+    } else if (eventType === 'EntityKill') {
+      loadLines.push('scoreboard objectives add rs.kills totalKillCount')
+    } else if (eventType === 'ItemUse') {
+      loadLines.push('# ItemUse detection requires a project-specific objective/tag setup')
+    } else if (detection === 'tag' || detection === 'advancement') {
+      loadLines.push(`# ${eventType} detection expects tag ${EVENT_TYPES[eventType].tag} to be set externally`)
+    }
+  }
+
   // Generate trigger dispatch functions
   for (const triggerName of triggerNames) {
     const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName)
@@ -356,6 +374,13 @@ export function generateDatapackWithStats(
     }
   }
 
+  // Call @load functions from __load
+  for (const fn of module.functions) {
+    if (fn.isLoadInit) {
+      loadLines.push(`function ${ns}:${fn.name}`)
+    }
+  }
+
   // Write __load.mcfunction
   files.push({
     path: `data/${ns}/function/__load.mcfunction`,
@@ -384,8 +409,20 @@ export function generateDatapackWithStats(
     }
   }
 
+  if (eventHandlers.length > 0) {
+    tickLines.push('# Event checks')
+    for (const eventType of eventTypes) {
+      const tag = EVENT_TYPES[eventType].tag
+      const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType)
+      for (const handler of handlers) {
+        tickLines.push(`execute as @a[tag=${tag}] run function ${ns}:${handler.name}`)
+      }
+      tickLines.push(`tag @a[tag=${tag}] remove ${tag}`)
+    }
+  }
+
   // Only generate __tick if there's something to run
-  if (tickFunctionNames.length > 0 || triggerNames.size > 0) {
+  if (tickFunctionNames.length > 0 || triggerNames.size > 0 || eventHandlers.length > 0) {
     files.push({
       path: `data/${ns}/function/__tick.mcfunction`,
       content: tickLines.join('\n'),