redscript-mc 1.1.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

@@ -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
@@ -124,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 }
@@ -180,9 +195,10 @@ export type Block = Stmt[]
 // ---------------------------------------------------------------------------
 
 export interface Decorator {
-  name: 'tick' | 'load' | '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
@@ -224,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
@@ -260,6 +283,7 @@ export interface Program {
   globals: GlobalDecl[]
   declarations: FnDecl[]
   structs: StructDecl[]
+  implBlocks: ImplBlock[]
   enums: EnumDecl[]
   consts: ConstDecl[]
 }

package/src/codegen/mcfunction/index.ts

@@ -18,6 +18,7 @@
 
 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[] = []
@@ -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)
@@ -391,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'),

package/src/codegen/structure/index.ts

@@ -8,6 +8,7 @@ import { optimizeForStructure, optimizeForStructureWithStats } from '../../optim
 import { preprocessSource } from '../../compile'
 import type { IRCommand, IRFunction, IRModule } from '../../ir/types'
 import type { DatapackFile } from '../mcfunction'
+import { EVENT_TYPES, isEventTypeName, type EventTypeName } from '../../events/types'
 
 const DATA_VERSION = 3953
 const MAX_WIDTH = 16
@@ -87,6 +88,10 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
   const entries: CommandEntry[] = []
   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))
   const loadCommands = [
     `scoreboard objectives add ${OBJ} dummy`,
     ...module.globals.map(g => `scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`),
@@ -99,6 +104,14 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
     ).map(constSetup),
   ]
 
+  for (const eventType of eventTypes) {
+    if (eventType === 'PlayerDeath') {
+      loadCommands.push('scoreboard objectives add rs.deaths deathCount')
+    } else if (eventType === 'EntityKill') {
+      loadCommands.push('scoreboard objectives add rs.kills totalKillCount')
+    }
+  }
+
   // Call @load functions from __load
   for (const fn of module.functions) {
     if (fn.isLoadInit) {
@@ -146,6 +159,20 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
       })
     }
   }
+  if (eventHandlers.length > 0) {
+    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) {
+        tickCommands.push({
+          cmd: `execute as @a[tag=${tag}] run function ${module.namespace}:${handler.name}`,
+        })
+      }
+      tickCommands.push({
+        cmd: `tag @a[tag=${tag}] remove ${tag}`,
+      })
+    }
+  }
   if (tickCommands.length > 0) {
     sections.push({
       name: '__tick',

package/src/compile.ts

@@ -39,6 +39,17 @@ export interface CompileResult {
   error?: DiagnosticError
 }
 
+export interface SourceRange {
+  startLine: number
+  endLine: number
+  filePath: string
+}
+
+export interface PreprocessedSource {
+  source: string
+  ranges: SourceRange[]
+}
+
 const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/
 
 interface PreprocessOptions {
@@ -46,7 +57,19 @@ interface PreprocessOptions {
   seen?: Set<string>
 }
 
-export function preprocessSource(source: string, options: PreprocessOptions = {}): string {
+function countLines(source: string): number {
+  return source === '' ? 0 : source.split('\n').length
+}
+
+function offsetRanges(ranges: SourceRange[], lineOffset: number): SourceRange[] {
+  return ranges.map(range => ({
+    startLine: range.startLine + lineOffset,
+    endLine: range.endLine + lineOffset,
+    filePath: range.filePath,
+  }))
+}
+
+export function preprocessSourceWithMetadata(source: string, options: PreprocessOptions = {}): PreprocessedSource {
   const { filePath } = options
   const seen = options.seen ?? new Set<string>()
 
@@ -55,7 +78,7 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
   }
 
   const lines = source.split('\n')
-  const imports: string[] = []
+  const imports: PreprocessedSource[] = []
   const bodyLines: string[] = []
   let parsingHeader = true
 
@@ -90,7 +113,7 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
           )
         }
 
-        imports.push(preprocessSource(importedSource, { filePath: importPath, seen }))
+        imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }))
       }
       continue
     }
@@ -104,7 +127,31 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
     bodyLines.push(line)
   }
 
-  return [...imports, bodyLines.join('\n')].filter(Boolean).join('\n')
+  const body = bodyLines.join('\n')
+  const parts = [...imports.map(entry => entry.source), body].filter(Boolean)
+  const combined = parts.join('\n')
+
+  const ranges: SourceRange[] = []
+  let lineOffset = 0
+
+  for (const entry of imports) {
+    ranges.push(...offsetRanges(entry.ranges, lineOffset))
+    lineOffset += countLines(entry.source)
+  }
+
+  if (filePath && body) {
+    ranges.push({
+      startLine: lineOffset + 1,
+      endLine: lineOffset + countLines(body),
+      filePath: path.resolve(filePath),
+    })
+  }
+
+  return { source: combined, ranges }
+}
+
+export function preprocessSource(source: string, options: PreprocessOptions = {}): string {
+  return preprocessSourceWithMetadata(source, options).source
 }
 
 // ---------------------------------------------------------------------------
@@ -116,7 +163,8 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
   let sourceLines = source.split('\n')
 
   try {
-    const preprocessedSource = preprocessSource(source, { filePath })
+    const preprocessed = preprocessSourceWithMetadata(source, { filePath })
+    const preprocessedSource = preprocessed.source
     sourceLines = preprocessedSource.split('\n')
 
     // Lexing
@@ -126,7 +174,7 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
 
     // Lowering
-    const ir = new Lowering(namespace).lower(ast)
+    const ir = new Lowering(namespace, preprocessed.ranges).lower(ast)
 
     // Optimization
     const optimized: IRModule = shouldOptimize