redscript-mc 1.0.0 → 1.2.0

package/src/mc-test/runner.ts

@@ -1,11 +1,11 @@
 /**
  * RedScript MC Integration Test Runner
  *
- * Compiles a .rs file, installs it to a running Paper server,
+ * Compiles a .mcrs file, installs it to a running Paper server,
  * runs test scenarios, and reports results.
  *
  * Usage:
- *   npx ts-node src/mc-test/runner.ts src/examples/counter.rs
+ *   npx ts-node src/mc-test/runner.ts src/examples/counter.mcrs
  *
  * Requires:
  *   - Paper server running with TestHarnessPlugin
@@ -105,7 +105,7 @@ export async function runMCTests(
 if (require.main === module) {
   const sourceFile = process.argv[2]
   if (!sourceFile) {
-    console.error('Usage: ts-node runner.ts <source.rs>')
+    console.error('Usage: ts-node runner.ts <source.mcrs>')
     process.exit(1)
   }
 

package/src/mc-test/setup.ts

@@ -36,11 +36,11 @@ function main() {
   // Example files
   const exampleNamespaces = ['counter', 'world_manager']
   for (const ns of exampleNamespaces) {
-    const file = path.join(EXAMPLES_DIR, `${ns}.rs`)
+    const file = path.join(EXAMPLES_DIR, `${ns}.mcrs`)
     if (fs.existsSync(file)) {
       writeFixture(fs.readFileSync(file, 'utf-8'), ns)
     } else {
-      console.log(`  ⚠ ${ns}.rs not found, skipping`)
+      console.log(`  ⚠ ${ns}.mcrs not found, skipping`)
     }
   }
 

package/src/parser/index.ts

@@ -7,10 +7,10 @@
 
 import { Lexer, type Token, type TokenKind } from '../lexer'
 import type {
-  Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, LiteralExpr, Param,
+  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
@@ -132,8 +153,10 @@ export class Parser {
 
   parse(defaultNamespace = 'redscript'): Program {
     let namespace = defaultNamespace
+    const globals: GlobalDecl[] = []
     const declarations: FnDecl[] = []
     const structs: StructDecl[] = []
+    const implBlocks: ImplBlock[] = []
     const enums: EnumDecl[] = []
     const consts: ConstDecl[] = []
 
@@ -147,8 +170,12 @@ export class Parser {
 
     // Parse struct and function declarations
     while (!this.check('eof')) {
-      if (this.check('struct')) {
+      if (this.check('let')) {
+        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')) {
@@ -158,7 +185,7 @@ export class Parser {
       }
     }
 
-    return { namespace, declarations, structs, enums, consts }
+    return { namespace, globals, declarations, structs, implBlocks, enums, consts }
   }
 
   // -------------------------------------------------------------------------
@@ -216,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
@@ -227,21 +268,32 @@ export class Parser {
     return this.withLoc({ name, type, value }, constToken)
   }
 
+  private parseGlobalDecl(mutable: boolean): GlobalDecl {
+    const token = this.advance() // consume 'let'
+    const name = this.expect('ident').value
+    this.expect(':')
+    const type = this.parseType()
+    this.expect('=')
+    const init = this.parseExpr()
+    this.expect(';')
+    return this.withLoc({ kind: 'global', name, type, init, mutable }, token)
+  }
+
   // -------------------------------------------------------------------------
   // 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()
     }
 
@@ -263,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}`)
@@ -278,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(/^"([^"]*)"$/)
@@ -314,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()
@@ -650,15 +715,15 @@ export class Parser {
         if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
           this.advance() // consume 'entity'
         }
-        const selector = this.parseSelector()
-        subcommands.push({ kind: 'if_entity', selector })
+        const selectorOrVar = this.parseSelectorOrVarSelector()
+        subcommands.push({ kind: 'if_entity', ...selectorOrVar })
       } else if (this.match('unless')) {
         // Expect 'entity' keyword (as ident) or just parse selector directly  
         if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
           this.advance() // consume 'entity'
         }
-        const selector = this.parseSelector()
-        subcommands.push({ kind: 'unless_entity', selector })
+        const selectorOrVar = this.parseSelectorOrVarSelector()
+        subcommands.push({ kind: 'unless_entity', ...selectorOrVar })
       } else if (this.match('in')) {
         const dim = this.expect('ident').value
         subcommands.push({ kind: 'in', dimension: dim })
@@ -726,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 },
@@ -752,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
@@ -782,6 +864,10 @@ export class Parser {
             'has_tag': '__entity_has_tag',
             'push': '__array_push',
             'pop': '__array_pop',
+            'add': 'set_add',
+            'contains': 'set_contains',
+            'remove': 'set_remove',
+            'clear': 'set_clear',
           }
           const internalFn = methodMap[expr.field]
           if (internalFn) {
@@ -793,7 +879,14 @@ export class Parser {
             )
             continue
           }
-          this.error(`Unknown method '${expr.field}'`)
+          // Generic method sugar: obj.method(args) → method(obj, args)
+          const args = this.parseArgs()
+          this.expect(')')
+          expr = this.withLoc(
+            { kind: 'call', fn: expr.field, args: [expr.obj, ...args] },
+            this.getLocToken(expr) ?? openParenToken
+          )
+          continue
         }
         const args = this.parseArgs()
         this.expect(')')
@@ -846,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()
     }
@@ -1308,6 +1411,39 @@ export class Parser {
     return this.parseSelectorValue(token.value)
   }
 
+  // Parse either a selector (@a[...]) or a variable with filters (p[...])
+  // Returns { selector } for selectors or { varName, filters } for variables
+  private parseSelectorOrVarSelector(): { selector?: EntitySelector, varName?: string, filters?: SelectorFilter } {
+    if (this.check('selector')) {
+      return { selector: this.parseSelector() }
+    }
+    
+    // Must be an identifier (variable) possibly with filters
+    const varToken = this.expect('ident')
+    const varName = varToken.value
+    
+    // Check for optional filters [...]
+    if (this.check('[')) {
+      this.advance() // consume '['
+      // Collect everything until ']'
+      let filterStr = ''
+      let depth = 1
+      while (depth > 0 && !this.check('eof')) {
+        if (this.check('[')) depth++
+        else if (this.check(']')) depth--
+        if (depth > 0) {
+          filterStr += this.peek().value ?? this.peek().kind
+          this.advance()
+        }
+      }
+      this.expect(']')
+      const filters = this.parseSelectorFilters(filterStr)
+      return { varName, filters }
+    }
+    
+    return { varName }
+  }
+
   private parseSelectorValue(value: string): EntitySelector {
     // Parse @e[type=zombie, distance=..5]
     const bracketIndex = value.indexOf('[')
@@ -1364,6 +1500,21 @@ export class Parser {
         case 'scores':
           filters.scores = this.parseScoresFilter(val)
           break
+        case 'x':
+          filters.x = this.parseRangeValue(val)
+          break
+        case 'y':
+          filters.y = this.parseRangeValue(val)
+          break
+        case 'z':
+          filters.z = this.parseRangeValue(val)
+          break
+        case 'x_rotation':
+          filters.x_rotation = this.parseRangeValue(val)
+          break
+        case 'y_rotation':
+          filters.y_rotation = this.parseRangeValue(val)
+          break
       }
     }