redscript-mc 1.1.0 → 1.2.0

package/src/parser/index.ts

@@ -9,8 +9,8 @@ import { Lexer, type Token, type TokenKind } from '../lexer'
 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,
-  CoordComponent, LambdaParam
+  StructDecl, StructField, ExecuteSubcommand, EnumDecl, EnumVariant, BlockPosExpr, ImplBlock,
+  CoordComponent, LambdaParam, EntityTypeName
 } from '../ast/types'
 import type { BinOp, CmpOp } from '../ir/types'
 import { DiagnosticError } from '../diagnostics'
@@ -23,12 +23,33 @@ const PRECEDENCE: Record<string, number> = {
   '||': 1,
   '&&': 2,
   '==': 3, '!=': 3,
-  '<': 4, '<=': 4, '>': 4, '>=': 4,
+  '<': 4, '<=': 4, '>': 4, '>=': 4, 'is': 4,
   '+': 5, '-': 5,
   '*': 6, '/': 6, '%': 6,
 }
 
-const BINARY_OPS = new Set(['||', '&&', '==', '!=', '<', '<=', '>', '>=', '+', '-', '*', '/', '%'])
+const BINARY_OPS = new Set(['||', '&&', '==', '!=', '<', '<=', '>', '>=', 'is', '+', '-', '*', '/', '%'])
+
+const ENTITY_TYPE_NAMES = new Set<EntityTypeName>([
+  'entity',
+  'Player',
+  'Mob',
+  'HostileMob',
+  'PassiveMob',
+  'Zombie',
+  'Skeleton',
+  'Creeper',
+  'Spider',
+  'Enderman',
+  'Pig',
+  'Cow',
+  'Sheep',
+  'Chicken',
+  'Villager',
+  'ArmorStand',
+  'Item',
+  'Arrow',
+])
 
 function computeIsSingle(raw: string): boolean {
   if (/^@[spr](\[|$)/.test(raw)) return true
@@ -135,6 +156,7 @@ export class Parser {
     const globals: GlobalDecl[] = []
     const declarations: FnDecl[] = []
     const structs: StructDecl[] = []
+    const implBlocks: ImplBlock[] = []
     const enums: EnumDecl[] = []
     const consts: ConstDecl[] = []
 
@@ -152,6 +174,8 @@ export class Parser {
         globals.push(this.parseGlobalDecl(true))
       } else if (this.check('struct')) {
         structs.push(this.parseStructDecl())
+      } else if (this.check('impl')) {
+        implBlocks.push(this.parseImplBlock())
       } else if (this.check('enum')) {
         enums.push(this.parseEnumDecl())
       } else if (this.check('const')) {
@@ -161,7 +185,7 @@ export class Parser {
       }
     }
 
-    return { namespace, globals, declarations, structs, enums, consts }
+    return { namespace, globals, declarations, structs, implBlocks, enums, consts }
   }
 
   // -------------------------------------------------------------------------
@@ -219,6 +243,20 @@ export class Parser {
     return this.withLoc({ name, variants }, enumToken)
   }
 
+  private parseImplBlock(): ImplBlock {
+    const implToken = this.expect('impl')
+    const typeName = this.expect('ident').value
+    this.expect('{')
+
+    const methods: FnDecl[] = []
+    while (!this.check('}') && !this.check('eof')) {
+      methods.push(this.parseFnDecl(typeName))
+    }
+
+    this.expect('}')
+    return this.withLoc({ kind: 'impl_block', typeName, methods }, implToken)
+  }
+
   private parseConstDecl(): ConstDecl {
     const constToken = this.expect('const')
     const name = this.expect('ident').value
@@ -245,17 +283,17 @@ export class Parser {
   // Function Declaration
   // -------------------------------------------------------------------------
 
-  private parseFnDecl(): FnDecl {
+  private parseFnDecl(implTypeName?: string): FnDecl {
     const decorators = this.parseDecorators()
 
     const fnToken = this.expect('fn')
     const name = this.expect('ident').value
     this.expect('(')
-    const params = this.parseParams()
+    const params = this.parseParams(implTypeName)
     this.expect(')')
 
     let returnType: TypeNode = { kind: 'named', name: 'void' }
-    if (this.match('->')) {
+    if (this.match('->') || this.match(':')) {
       returnType = this.parseType()
     }
 
@@ -277,7 +315,7 @@ export class Parser {
   }
 
   private parseDecoratorValue(value: string): Decorator {
-    // Parse @tick or @on_trigger("name") or @on_advancement("story/mine_diamond")
+    // Parse @tick, @on(PlayerDeath), or @on_trigger("name")
     const match = value.match(/^@(\w+)(?:\(([^)]*)\))?$/)
     if (!match) {
       this.error(`Invalid decorator: ${value}`)
@@ -292,6 +330,14 @@ export class Parser {
 
     const args: Decorator['args'] = {}
 
+    if (name === 'on') {
+      const eventTypeMatch = argsStr.match(/^([A-Za-z_][A-Za-z0-9_]*)$/)
+      if (eventTypeMatch) {
+        args.eventType = eventTypeMatch[1]
+        return { name, args }
+      }
+    }
+
     // Handle @on_trigger("name"), @on_advancement("id"), @on_craft("item"), @on_join_team("team")
     if (name === 'on_trigger' || name === 'on_advancement' || name === 'on_craft' || name === 'on_join_team') {
       const strMatch = argsStr.match(/^"([^"]*)"$/)
@@ -328,15 +374,20 @@ export class Parser {
     return { name, args }
   }
 
-  private parseParams(): Param[] {
+  private parseParams(implTypeName?: string): Param[] {
     const params: Param[] = []
 
     if (!this.check(')')) {
       do {
         const paramToken = this.expect('ident')
         const name = paramToken.value
-        this.expect(':')
-        const type = this.parseType()
+        let type: TypeNode
+        if (implTypeName && params.length === 0 && name === 'self' && !this.check(':')) {
+          type = { kind: 'struct', name: implTypeName }
+        } else {
+          this.expect(':')
+          type = this.parseType()
+        }
         let defaultValue: Expr | undefined
         if (this.match('=')) {
           defaultValue = this.parseExpr()
@@ -740,6 +791,15 @@ export class Parser {
       if (prec < minPrec) break
 
       const opToken = this.advance()
+      if (op === 'is') {
+        const entityType = this.parseEntityTypeName()
+        left = this.withLoc(
+          { kind: 'is_check', expr: left, entityType },
+          this.getLocToken(left) ?? opToken
+        )
+        continue
+      }
+
       const right = this.parseBinaryExpr(prec + 1) // left associative
       left = this.withLoc(
         { kind: 'binary', op: op as BinOp | CmpOp | '&&' | '||', left, right },
@@ -766,6 +826,14 @@ export class Parser {
     return this.parsePostfixExpr()
   }
 
+  private parseEntityTypeName(): EntityTypeName {
+    const token = this.expect('ident')
+    if (ENTITY_TYPE_NAMES.has(token.value as EntityTypeName)) {
+      return token.value as EntityTypeName
+    }
+    this.error(`Unknown entity type '${token.value}'`)
+  }
+
   private isSubtraction(): boolean {
     // Check if this minus is binary (subtraction) by looking at previous token
     // If previous was a value (literal, ident, ), ]) it's subtraction
@@ -871,6 +939,16 @@ export class Parser {
   private parsePrimaryExpr(): Expr {
     const token = this.peek()
 
+    if (token.kind === 'ident' && this.peek(1).kind === '::') {
+      const typeToken = this.advance()
+      this.expect('::')
+      const methodToken = this.expect('ident')
+      this.expect('(')
+      const args = this.parseArgs()
+      this.expect(')')
+      return this.withLoc({ kind: 'static_call', type: typeToken.value, method: methodToken.value, args }, typeToken)
+    }
+
     if (token.kind === 'ident' && this.peek(1).kind === '=>') {
       return this.parseSingleParamLambda()
     }

package/src/stdlib/README.md

@@ -70,10 +70,13 @@ Cooldown system using scoreboards.
 - `is_on_cooldown(target)` → int
 
 ### timer.mcrs
-Timer utilities.
-- `timer_start(name, ticks)`
-- `timer_tick()`
-- `timer_done(name)` → int
+Timer utilities with an OOP API.
+- `Timer::new(ticks)` → `Timer`
+- `timer.start()`, `timer.pause()`, `timer.reset()`
+- `timer.done()` → bool
+- `timer.elapsed()` → int
+- `timer.remaining()` → int
+- `timer.tick()` — manual tick update; current runtime uses one shared timer slot
 
 ### combat.mcrs
 Combat helpers.
@@ -162,3 +165,30 @@ Player input detection (right click, sneak, look direction).
 // Position ranges
 @a[x=-5..5, y=62..68, z=-5..5]  // In specific area
 ```
+
+### tags.mcrs
+Minecraft Java Edition tag constants generated from the Minecraft Fandom tag list.
+
+#### Coverage
+- 171 `BLOCK_*` constants for Java block tags
+- 14 `ENTITY_*` constants for Java entity type tags
+- 99 `ITEM_*` constants for Java item tags
+- 2 `FLUID_*` constants for Java fluid tags
+- 27 `DAMAGE_*` constants for Java damage type tags
+
+#### Naming
+- Constants use `SCREAMING_SNAKE_CASE`
+- Each constant is prefixed by category: `BLOCK_`, `ENTITY_`, `ITEM_`, `FLUID_`, `DAMAGE_`
+- Each value is the full tag selector string, for example `#minecraft:mineable/axe`
+
+#### Usage
+```mcrs
+import "stdlib/tags.mcrs"
+
+// Select skeleton variants
+kill(@e[type=ENTITY_SKELETONS]);
+
+// Use block and item tags in your own helpers
+const LOGS: string = BLOCK_LOGS;
+const SWORDS: string = ITEM_SWORDS;
+```