redscript-mc 2.0.0 → 2.1.0

package/src/parser/index.ts

@@ -10,7 +10,7 @@ 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, ImplBlock,
-  CoordComponent, LambdaParam, EntityTypeName
+  CoordComponent, LambdaParam, EntityTypeName, ImportDecl
 } from '../ast/types'
 import type { BinOp, CmpOp } from '../ast/types'
 import { DiagnosticError } from '../diagnostics'
@@ -174,7 +174,9 @@ export class Parser {
     const implBlocks: ImplBlock[] = []
     const enums: EnumDecl[] = []
     const consts: ConstDecl[] = []
+    const imports: ImportDecl[] = []
     let isLibrary = false
+    let moduleName: string | undefined
 
     // Check for namespace declaration
     if (this.check('namespace')) {
@@ -184,7 +186,7 @@ export class Parser {
       this.expect(';')
     }
 
-    // Check for module declaration: `module library;`
+    // Check for module declaration: `module library;` or `module <name>;`
     // Library-mode: all functions parsed from this point are marked isLibraryFn=true.
     // When using the `librarySources` compile option, each library source is parsed
     // by its own fresh Parser — so this flag never bleeds into user code.
@@ -194,11 +196,14 @@ export class Parser {
       if (modKind.value === 'library') {
         isLibrary = true
         this.inLibraryMode = true
+      } else {
+        // Named module declaration: `module math;`
+        moduleName = modKind.value
       }
       this.expect(';')
     }
 
-    // Parse struct and function declarations
+    // Parse struct, function, and import declarations
     while (!this.check('eof')) {
       if (this.check('let')) {
         globals.push(this.parseGlobalDecl(true))
@@ -214,12 +219,29 @@ export class Parser {
         // Declaration-only stub (e.g. from builtins.d.mcrs) — parse and discard
         this.advance() // consume 'declare'
         this.parseDeclareStub()
+      } else if (this.check('export')) {
+        declarations.push(this.parseExportedFnDecl())
+      } else if (this.check('ident') && this.peek().value === 'import') {
+        // `import math::sin;` or `import math::*;`
+        this.advance() // consume 'import'
+        const importToken = this.peek()
+        const modName = this.expect('ident').value
+        this.expect('::')
+        let symbol: string
+        if (this.check('*')) {
+          this.advance()
+          symbol = '*'
+        } else {
+          symbol = this.expect('ident').value
+        }
+        this.expect(';')
+        imports.push(this.withLoc({ moduleName: modName, symbol }, importToken))
       } else {
         declarations.push(this.parseFnDecl())
       }
     }
 
-    return { namespace, globals, declarations, structs, implBlocks, enums, consts, isLibrary }
+    return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, isLibrary }
   }
 
   // -------------------------------------------------------------------------
@@ -326,11 +348,41 @@ export class Parser {
   // Function Declaration
   // -------------------------------------------------------------------------
 
+  /** Parse `export fn name(...)` — marks the function as exported (survives DCE). */
+  private parseExportedFnDecl(): FnDecl {
+    this.expect('export')
+    const fn = this.parseFnDecl()
+    fn.isExported = true
+    return fn
+  }
+
   private parseFnDecl(implTypeName?: string): FnDecl {
     const decorators = this.parseDecorators()
 
+    // Map @keep decorator to isExported flag (backward compat)
+    let isExported: boolean | undefined
+    const filteredDecorators = decorators.filter(d => {
+      if (d.name === 'keep') {
+        isExported = true
+        return false
+      }
+      return true
+    })
+
     const fnToken = this.expect('fn')
     const name = this.expect('ident').value
+
+    // Parse optional generic type parameters: fn max<T>(...)
+    let typeParams: string[] | undefined
+    if (this.check('<')) {
+      this.advance() // consume '<'
+      typeParams = []
+      do {
+        typeParams.push(this.expect('ident').value)
+      } while (this.match(','))
+      this.expect('>')
+    }
+
     this.expect('(')
     const params = this.parseParams(implTypeName)
     this.expect(')')
@@ -343,7 +395,8 @@ export class Parser {
     const body = this.parseBlock()
 
     const fn: import('../ast/types').FnDecl = this.withLoc(
-      { name, params, returnType, decorators, body, isLibraryFn: this.inLibraryMode || undefined },
+      { name, typeParams, params, returnType, decorators: filteredDecorators, body,
+        isLibraryFn: this.inLibraryMode || undefined, isExported },
       fnToken,
     )
     return fn
@@ -442,11 +495,17 @@ export class Parser {
       return { name, rawArgs }
     }
 
-    // Handle key=value format (e.g., rate=20)
+    // Handle key=value format (e.g., rate=20, batch=10, onDone=fn_name)
     for (const part of argsStr.split(',')) {
       const [key, val] = part.split('=').map(s => s.trim())
       if (key === 'rate') {
         args.rate = parseInt(val, 10)
+      } else if (key === 'ticks') {
+        args.ticks = parseInt(val, 10)
+      } else if (key === 'batch') {
+        args.batch = parseInt(val, 10)
+      } else if (key === 'onDone') {
+        args.onDone = val
       } else if (key === 'trigger') {
         args.trigger = val
       } else if (key === 'advancement') {
@@ -491,7 +550,24 @@ export class Parser {
     let type: TypeNode
 
     if (token.kind === '(') {
-      return this.parseFunctionType()
+      // Disambiguate: tuple type `(T, T)` vs function type `(T) -> R`
+      // Look ahead: parse elements, then check if '->' follows.
+      const saved = this.pos
+      this.advance() // consume '('
+      const elements: TypeNode[] = []
+      if (!this.check(')')) {
+        do {
+          elements.push(this.parseType())
+        } while (this.match(','))
+      }
+      this.expect(')')
+      if (this.check('->')) {
+        // It's a function type — restore and use existing parseFunctionType
+        this.pos = saved
+        return this.parseFunctionType()
+      }
+      // It's a tuple type
+      return { kind: 'tuple', elements }
     }
 
     if (token.kind === 'int' || token.kind === 'bool' ||
@@ -508,6 +584,11 @@ export class Parser {
         type = { kind: 'selector', entityType }
       } else if (token.value === 'selector') {
         type = { kind: 'selector' }
+      } else if (token.value === 'Option' && this.check('<')) {
+        this.advance() // consume <
+        const inner = this.parseType()
+        this.expect('>')
+        type = { kind: 'option', inner }
       } else {
         type = { kind: 'struct', name: token.value }
       }
@@ -633,6 +714,25 @@ export class Parser {
 
   private parseLetStmt(): Stmt {
     const letToken = this.expect('let')
+
+    // Destructuring: let (a, b, c) = expr;
+    if (this.check('(')) {
+      this.advance() // consume '('
+      const names: string[] = []
+      do {
+        names.push(this.expect('ident').value)
+      } while (this.match(','))
+      this.expect(')')
+      let type: TypeNode | undefined
+      if (this.match(':')) {
+        type = this.parseType()
+      }
+      this.expect('=')
+      const init = this.parseExpr()
+      this.expect(';')
+      return this.withLoc({ kind: 'let_destruct', names, type, init }, letToken)
+    }
+
     const name = this.expect('ident').value
 
     let type: TypeNode | undefined
@@ -661,6 +761,30 @@ export class Parser {
 
   private parseIfStmt(): Stmt {
     const ifToken = this.expect('if')
+
+    // if let Some(x) = expr { ... }
+    if (this.check('let') && this.peek(1).kind === 'ident' && this.peek(1).value === 'Some') {
+      this.advance() // consume 'let'
+      this.advance() // consume 'Some'
+      this.expect('(')
+      const binding = this.expect('ident').value
+      this.expect(')')
+      this.expect('=')
+      const init = this.parseExpr()
+      const then = this.parseBlock()
+
+      let else_: Block | undefined
+      if (this.match('else')) {
+        if (this.check('if')) {
+          else_ = [this.parseIfStmt()]
+        } else {
+          else_ = this.parseBlock()
+        }
+      }
+
+      return this.withLoc({ kind: 'if_let_some', binding, init, then, else_ }, ifToken)
+    }
+
     this.expect('(')
     const cond = this.parseExpr()
     this.expect(')')
@@ -1105,10 +1229,52 @@ export class Parser {
     return ['int_lit', 'float_lit', 'ident', ')', ']'].includes(prev.kind)
   }
 
+  /**
+   * Try to parse `<Type, ...>` as explicit generic type arguments.
+   * Returns the parsed type list if successful, null if this looks like a comparison.
+   * Does NOT consume any tokens if it returns null.
+   */
+  private tryParseTypeArgs(): import('../ast/types').TypeNode[] | null {
+    const saved = this.pos
+    this.advance() // consume '<'
+    const typeArgs: import('../ast/types').TypeNode[] = []
+    try {
+      do {
+        typeArgs.push(this.parseType())
+      } while (this.match(','))
+      if (!this.check('>')) {
+        this.pos = saved
+        return null
+      }
+      this.advance() // consume '>'
+      return typeArgs
+    } catch {
+      this.pos = saved
+      return null
+    }
+  }
+
   private parsePostfixExpr(): Expr {
     let expr = this.parsePrimaryExpr()
 
     while (true) {
+      // Generic call: ident<Type>(args) — check before regular '(' handling
+      if (expr.kind === 'ident' && this.check('<')) {
+        const typeArgs = this.tryParseTypeArgs()
+        if (typeArgs !== null && this.check('(')) {
+          const openParenToken = this.peek()
+          this.advance() // consume '('
+          const args = this.parseArgs()
+          this.expect(')')
+          expr = this.withLoc(
+            { kind: 'call', fn: expr.name, args, typeArgs },
+            this.getLocToken(expr) ?? openParenToken
+          )
+          continue
+        }
+        // Not a generic call — fall through to normal expression handling
+      }
+
       // Function call
       if (this.match('(')) {
         const openParenToken = this.tokens[this.pos - 1]
@@ -1205,11 +1371,16 @@ export class Parser {
     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)
+      const memberToken = this.expect('ident')
+      if (this.check('(')) {
+        // Static method call: Type::method(args)
+        this.advance() // consume '('
+        const args = this.parseArgs()
+        this.expect(')')
+        return this.withLoc({ kind: 'static_call', type: typeToken.value, method: memberToken.value, args }, typeToken)
+      }
+      // Enum variant access: Enum::Variant
+      return this.withLoc({ kind: 'path_expr', enumName: typeToken.value, variant: memberToken.value }, typeToken)
     }
 
     if (token.kind === 'ident' && this.peek(1).kind === '=>') {
@@ -1302,13 +1473,28 @@ export class Parser {
       }, token)
     }
 
+    // Some(expr) — Option constructor
+    if (token.kind === 'ident' && token.value === 'Some' && this.peek(1).kind === '(') {
+      this.advance() // consume 'Some'
+      this.advance() // consume '('
+      const value = this.parseExpr()
+      this.expect(')')
+      return this.withLoc({ kind: 'some_lit', value }, token)
+    }
+
+    // None — Option empty constructor
+    if (token.kind === 'ident' && token.value === 'None') {
+      this.advance()
+      return this.withLoc({ kind: 'none_lit' }, token)
+    }
+
     // Identifier
     if (token.kind === 'ident') {
       this.advance()
       return this.withLoc({ kind: 'ident', name: token.value }, token)
     }
 
-    // Grouped expression
+    // Grouped expression or tuple literal
     if (token.kind === '(') {
       if (this.isBlockPosLiteral()) {
         return this.parseBlockPos()
@@ -1317,9 +1503,20 @@ export class Parser {
         return this.parseLambdaExpr()
       }
       this.advance()
-      const expr = this.parseExpr()
+      const first = this.parseExpr()
+      // If followed by a comma, it's a tuple literal
+      if (this.match(',')) {
+        const elements: Expr[] = [first]
+        if (!this.check(')')) {
+          do {
+            elements.push(this.parseExpr())
+          } while (this.match(','))
+        }
+        this.expect(')')
+        return this.withLoc({ kind: 'tuple_lit', elements }, token)
+      }
       this.expect(')')
-      return expr
+      return first
     }
 
     // Struct literal or block: { x: 10, y: 20 }

package/src/repl.ts

@@ -1,7 +1,7 @@
 import * as readline from 'readline'
 
 import { compile } from './index'
-import type { DatapackFile } from '../src2/emit/index'
+import type { DatapackFile } from './emit/index'
 
 const REPL_FN = '__repl'
 

package/src/stdlib/math.mcrs

@@ -17,7 +17,7 @@ module library;
 
 // ─── Phase 1: Basic integer helpers ──────────────────────────────────────────
 
-fn abs(x: int) -> int {
+fn abs<T>(x: T) -> T {
     if (x < 0) {
         return 0 - x;
     }
@@ -34,21 +34,21 @@ fn sign(x: int) -> int {
     return 0;
 }
 
-fn min(a: int, b: int) -> int {
+fn min<T>(a: T, b: T) -> T {
     if (a < b) {
         return a;
     }
     return b;
 }
 
-fn max(a: int, b: int) -> int {
+fn max<T>(a: T, b: T) -> T {
     if (a > b) {
         return a;
     }
     return b;
 }
 
-fn clamp(x: int, lo: int, hi: int) -> int {
+fn clamp<T>(x: T, lo: T, hi: T) -> T {
     if (x < lo) {
         return lo;
     }

package/src/templates/quest.mcrs

@@ -14,7 +14,7 @@ fn quest_target(questId: int) -> int {
     return 5;
 }
 
-fn load_quest(player: string, questId: int) -> Quest {
+fn load_quest(player: selector, questId: int) -> Quest {
     let progress: int = scoreboard_get(player, "quest_progress");
     let completed: int = scoreboard_get(player, "quest_completed");
     let target: int = quest_target(questId);
@@ -22,7 +22,7 @@ fn load_quest(player: string, questId: int) -> Quest {
     return quest;
 }
 
-fn quest_start(player: string, questId: int) {
+fn quest_start(player: selector, questId: int) {
     let quest: Quest = { id: questId, progress: 0, target: quest_target(questId), completed: 0 };
     scoreboard_set(player, "quest_id", quest.id);
     scoreboard_set(player, "quest_progress", quest.progress);
@@ -32,7 +32,7 @@ fn quest_start(player: string, questId: int) {
     actionbar(player, "Objective accepted");
 }
 
-fn quest_progress(player: string, questId: int, amount: int) {
+fn quest_progress(player: selector, questId: int, amount: int) {
     let activeQuest: int = scoreboard_get(player, "quest_id");
     let quest: Quest = load_quest(player, questId);
 
@@ -57,7 +57,7 @@ fn quest_progress(player: string, questId: int, amount: int) {
     }
 }
 
-fn quest_complete(player: string, questId: int) {
+fn quest_complete(player: selector, questId: int) {
     let activeQuest: int = scoreboard_get(player, "quest_id");
 
     if (activeQuest == questId) {