redscript-mc 1.1.0 → 1.2.1

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()
     }
@@ -887,6 +965,18 @@ export class Parser {
       return this.withLoc({ kind: 'float_lit', value: parseFloat(token.value) }, token)
     }
 
+    // Relative coordinate: ~  ~5  ~-3  ~0.5
+    if (token.kind === 'rel_coord') {
+      this.advance()
+      return this.withLoc({ kind: 'rel_coord', value: token.value }, token)
+    }
+
+    // Local coordinate: ^  ^5  ^-3  ^0.5
+    if (token.kind === 'local_coord') {
+      this.advance()
+      return this.withLoc({ kind: 'local_coord', value: token.value }, token)
+    }
+
     // NBT suffix literals
     if (token.kind === 'byte_lit') {
       this.advance()
@@ -911,6 +1001,11 @@ export class Parser {
       return this.parseStringExpr(token)
     }
 
+    if (token.kind === 'f_string') {
+      this.advance()
+      return this.parseFStringExpr(token)
+    }
+
     // MC name literal: #health → mc_name node (value = "health", without #)
     if (token.kind === 'mc_name') {
       this.advance()
@@ -1091,6 +1186,67 @@ export class Parser {
     return this.withLoc({ kind: 'str_interp', parts }, token)
   }
 
+  private parseFStringExpr(token: Token): Expr {
+    const parts: Array<{ kind: 'text'; value: string } | { kind: 'expr'; expr: Expr }> = []
+    let current = ''
+    let index = 0
+
+    while (index < token.value.length) {
+      if (token.value[index] === '{') {
+        if (current) {
+          parts.push({ kind: 'text', value: current })
+          current = ''
+        }
+
+        index++
+        let depth = 1
+        let exprSource = ''
+        let inString = false
+
+        while (index < token.value.length && depth > 0) {
+          const char = token.value[index]
+
+          if (char === '"' && token.value[index - 1] !== '\\') {
+            inString = !inString
+          }
+
+          if (!inString) {
+            if (char === '{') {
+              depth++
+            } else if (char === '}') {
+              depth--
+              if (depth === 0) {
+                index++
+                break
+              }
+            }
+          }
+
+          if (depth > 0) {
+            exprSource += char
+          }
+          index++
+        }
+
+        if (depth !== 0) {
+          this.error('Unterminated f-string interpolation')
+        }
+
+        parts.push({ kind: 'expr', expr: this.parseEmbeddedExpr(exprSource) })
+        continue
+      }
+
+      current += token.value[index]
+      index++
+    }
+
+    if (current) {
+      parts.push({ kind: 'text', value: current })
+    }
+
+    return this.withLoc({ kind: 'f_string', parts }, token)
+  }
+
   private parseEmbeddedExpr(source: string): Expr {
     const tokens = new Lexer(source, this.filePath).tokenize()
     const parser = new Parser(tokens, source, this.filePath)
@@ -1265,20 +1421,11 @@ export class Parser {
       return this.peek(offset + 1).kind === 'int_lit' ? 2 : 0
     }
 
-    if (token.kind !== '~' && token.kind !== '^') {
-      return 0
-    }
-
-    const next = this.peek(offset + 1)
-    if (next.kind === ',' || next.kind === ')') {
+    // rel_coord (~, ~5, ~-3) and local_coord (^, ^5, ^-3) are single tokens now
+    if (token.kind === 'rel_coord' || token.kind === 'local_coord') {
       return 1
     }
-    if (next.kind === 'int_lit') {
-      return 2
-    }
-    if (next.kind === '-' && this.peek(offset + 2).kind === 'int_lit') {
-      return 3
-    }
+
     return 0
   }
 
@@ -1296,17 +1443,28 @@ export class Parser {
   private parseCoordComponent(): CoordComponent {
     const token = this.peek()
 
-    if (token.kind === '~' || token.kind === '^') {
+    // Handle rel_coord (~, ~5, ~-3) and local_coord (^, ^5, ^-3) tokens
+    if (token.kind === 'rel_coord') {
+      this.advance()
+      // Parse the offset from the token value (e.g., "~5" -> 5, "~" -> 0, "~-3" -> -3)
+      const offset = this.parseCoordOffsetFromValue(token.value.slice(1))
+      return { kind: 'relative', offset }
+    }
+
+    if (token.kind === 'local_coord') {
       this.advance()
-      const offset = this.parseSignedCoordOffset()
-      return token.kind === '~'
-        ? { kind: 'relative', offset }
-        : { kind: 'local', offset }
+      const offset = this.parseCoordOffsetFromValue(token.value.slice(1))
+      return { kind: 'local', offset }
     }
 
     return { kind: 'absolute', value: this.parseSignedCoordOffset(true) }
   }
 
+  private parseCoordOffsetFromValue(value: string): number {
+    if (value === '' || value === undefined) return 0
+    return parseFloat(value)
+  }
+
   private parseSignedCoordOffset(requireValue = false): number {
     let sign = 1
     if (this.match('-')) {

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;
+```