redscript-mc 1.1.0 → 1.2.1

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')
@@ -405,6 +481,17 @@ describe('Parser', () => {
       })
     })
 
+    it('parses f-string literal', () => {
+      const expr = parseExpr('f"Score: {x}"')
+      expect(expr).toEqual({
+        kind: 'f_string',
+        parts: [
+          { kind: 'text', value: 'Score: ' },
+          { kind: 'expr', expr: { kind: 'ident', name: 'x' } },
+        ],
+      })
+    })
+
       it('parses boolean literals', () => {
         expect(parseExpr('true')).toEqual({ kind: 'bool_lit', value: true })
         expect(parseExpr('false')).toEqual({ kind: 'bool_lit', value: false })
@@ -459,11 +546,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 +573,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', () => {
@@ -97,6 +97,22 @@ fn chat() {
     ])
   })
 
+  it('renders f-strings through tellraw score components', () => {
+    const runtime = loadCompiledProgram(`
+fn chat() {
+    let score: int = 7;
+    say(f"You have {score} points");
+}
+`)
+
+    runtime.load()
+    runtime.execFunction('chat')
+
+    expect(runtime.getChatLog()).toEqual([
+      'You have 7 points',
+    ])
+  })
+
   it('kills only entities matched by a foreach selector', () => {
     const runtime = loadCompiledProgram(`
 fn purge_zombies() {
@@ -135,8 +151,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 +193,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 +250,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 +268,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 +286,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 +300,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

@@ -120,6 +120,39 @@ fn test() {
       expect(errors).toHaveLength(0)
     })
 
+    it('allows f-strings in runtime output builtins', () => {
+      const errors = typeCheck(`
+fn test() {
+    let score: int = 5;
+    say(f"Score: {score}");
+    tellraw(@a, f"Score: {score}");
+    actionbar(@s, f"Score: {score}");
+    title(@s, f"Score: {score}");
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('rejects f-strings outside runtime output builtins', () => {
+      const errors = typeCheck(`
+fn test() {
+    let msg: string = f"Score";
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('expected string, got format_string')
+    })
+
+    it('rejects unsupported f-string placeholder types', () => {
+      const errors = typeCheck(`
+fn test() {
+    say(f"Flag: {true}");
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('f-string placeholder must be int or string')
+    })
+
     it('detects too many arguments', () => {
       const errors = typeCheck(`
 fn greet() {
@@ -211,6 +244,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 +566,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

@@ -22,7 +22,19 @@ export interface Span {
 // Type Nodes
 // ---------------------------------------------------------------------------
 
-export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double'
+export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string'
+
+// 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 }
@@ -30,6 +42,8 @@ export type 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
@@ -43,6 +57,16 @@ export interface LambdaExpr {
   body: Expr | Block
 }
 
+export type FStringPart =
+  | { kind: 'text'; value: string }
+  | { kind: 'expr'; expr: Expr }
+
+export interface FStringExpr {
+  kind: 'f_string'
+  parts: FStringPart[]
+  span?: Span
+}
+
 // ---------------------------------------------------------------------------
 // Range Expression
 // ---------------------------------------------------------------------------
@@ -115,15 +139,19 @@ export type Expr =
   | { kind: 'short_lit';  value: number; span?: Span }
   | { kind: 'long_lit';   value: number; span?: Span }
   | { kind: 'double_lit'; value: number; span?: Span }
+  | { kind: 'rel_coord';  value: string; span?: Span }   // ~  ~5  ~-3  (relative coordinate)
+  | { kind: 'local_coord'; value: string; span?: Span }  // ^  ^5  ^-3  (local/facing coordinate)
   | { kind: 'bool_lit';   value: boolean; span?: Span }
   | { kind: 'str_lit';    value: string; span?: Span }
   | { kind: 'mc_name';   value: string; span?: Span }  // #health → "health" (MC identifier)
   | { kind: 'str_interp'; parts: Array<string | Expr>; span?: Span }
+  | FStringExpr
   | { kind: 'range_lit';  range: RangeExpr; span?: Span }
   | (BlockPosExpr & { span?: Span })
   | { 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 +208,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 +253,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 +296,7 @@ export interface Program {
   globals: GlobalDecl[]
   declarations: FnDecl[]
   structs: StructDecl[]
+  implBlocks: ImplBlock[]
   enums: EnumDecl[]
   consts: ConstDecl[]
 }

package/src/cli.ts

@@ -26,7 +26,7 @@ function printUsage(): void {
 RedScript Compiler
 
 Usage:
-  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>]
+  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>] [--no-dce]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
   redscript fmt <file.mcrs> [file2.mcrs ...]
@@ -46,6 +46,7 @@ Options:
   --output-nbt <file>    Output .nbt file path for structure target
   --namespace <ns>       Datapack namespace (default: derived from filename)
   --target <target>      Output target: datapack (default), cmdblock, or structure
+  --no-dce               Disable AST dead code elimination
   --stats                Print optimizer statistics
   --hot-reload <url>     After each successful compile, POST to <url>/reload
                          (use with redscript-testharness; e.g. http://localhost:25561)
@@ -78,8 +79,9 @@ function parseArgs(args: string[]): {
   stats?: boolean
   help?: boolean
   hotReload?: string
+  dce?: boolean
 } {
-  const result: ReturnType<typeof parseArgs> = {}
+  const result: ReturnType<typeof parseArgs> = { dce: true }
   let i = 0
 
   while (i < args.length) {
@@ -103,6 +105,9 @@ function parseArgs(args: string[]): {
     } else if (arg === '--stats') {
       result.stats = true
       i++
+    } else if (arg === '--no-dce') {
+      result.dce = false
+      i++
     } else if (arg === '--hot-reload') {
       result.hotReload = args[++i]
       i++
@@ -153,7 +158,14 @@ function printOptimizationStats(stats: OptimizationStats | undefined): void {
   console.log(`  Total mcfunction commands: ${stats.totalCommandsBefore} -> ${stats.totalCommandsAfter} (${formatReduction(stats.totalCommandsBefore, stats.totalCommandsAfter)} reduction)`)
 }
 
-function compileCommand(file: string, output: string, namespace: string, target: string = 'datapack', showStats = false): void {
+function compileCommand(
+  file: string,
+  output: string,
+  namespace: string,
+  target: string = 'datapack',
+  showStats = false,
+  dce = true
+): void {
   // Read source file
   if (!fs.existsSync(file)) {
     console.error(`Error: File not found: ${file}`)
@@ -164,7 +176,7 @@ function compileCommand(file: string, output: string, namespace: string, target:
 
   try {
     if (target === 'cmdblock') {
-      const result = compile(source, { namespace, filePath: file })
+      const result = compile(source, { namespace, filePath: file, dce })
       printWarnings(result.warnings)
 
       // Generate command block JSON
@@ -184,7 +196,7 @@ function compileCommand(file: string, output: string, namespace: string, target:
         printOptimizationStats(result.stats)
       }
     } else if (target === 'structure') {
-      const structure = compileToStructure(source, namespace, file)
+      const structure = compileToStructure(source, namespace, file, { dce })
       fs.mkdirSync(path.dirname(output), { recursive: true })
       fs.writeFileSync(output, structure.buffer)
 
@@ -195,7 +207,7 @@ function compileCommand(file: string, output: string, namespace: string, target:
         printOptimizationStats(structure.stats)
       }
     } else {
-      const result = compile(source, { namespace, filePath: file })
+      const result = compile(source, { namespace, filePath: file, dce })
       printWarnings(result.warnings)
 
       // Default: generate datapack
@@ -255,7 +267,7 @@ async function hotReload(url: string): Promise<void> {
   }
 }
 
-function watchCommand(dir: string, output: string, namespace?: string, hotReloadUrl?: string): void {
+function watchCommand(dir: string, output: string, namespace?: string, hotReloadUrl?: string, dce = true): void {
   // Check if directory exists
   if (!fs.existsSync(dir)) {
     console.error(`Error: Directory not found: ${dir}`)
@@ -290,7 +302,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
       try {
         source = fs.readFileSync(file, 'utf-8')
         const ns = namespace ?? deriveNamespace(file)
-        const result = compile(source, { namespace: ns, filePath: file })
+        const result = compile(source, { namespace: ns, filePath: file, dce })
         printWarnings(result.warnings)
 
         // Create output directory
@@ -382,7 +394,8 @@ async function main(): Promise<void> {
         output,
         namespace,
         target,
-        parsed.stats
+        parsed.stats,
+        parsed.dce
       )
       }
       break
@@ -397,7 +410,8 @@ async function main(): Promise<void> {
         parsed.file,
         parsed.output ?? './dist',
         parsed.namespace,
-        parsed.hotReload
+        parsed.hotReload,
+        parsed.dce
       )
       break