redscript-mc 3.0.1 → 3.0.2

package/src/parser/type-parser.ts

@@ -0,0 +1,276 @@
+/**
+ * TypeParser — parses type annotations and generic type arguments.
+ * Extends ParserBase to gain token navigation.
+ */
+
+import type { TypeNode, Param } from '../ast/types'
+import { ParserBase } from './utils'
+
+export class TypeParser extends ParserBase {
+  // -------------------------------------------------------------------------
+  // Type Parsing
+  // -------------------------------------------------------------------------
+
+  parseType(): TypeNode {
+    const token = this.peek()
+    let type: TypeNode
+
+    if (token.kind === '(') {
+      // Disambiguate: tuple type `(T, T)` vs function type `(T) -> R`
+      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('->')) {
+        this.pos = saved
+        return this.parseFunctionType()
+      }
+      return { kind: 'tuple', elements }
+    }
+
+    if (token.kind === 'float') {
+      this.advance()
+      const filePart = this.filePath ? `${this.filePath}:` : ''
+      this.warnings.push(
+        `[DeprecatedType] ${filePart}line ${token.line}, col ${token.col}: 'float' is deprecated, use 'fixed' instead (×10000 fixed-point)`
+      )
+      type = { kind: 'named', name: 'float' }
+    } else if (token.kind === 'int' || token.kind === 'bool' ||
+        token.kind === 'fixed' || token.kind === 'string' || token.kind === 'void' ||
+        token.kind === 'BlockPos') {
+      this.advance()
+      type = { kind: 'named', name: token.kind }
+    } else if (token.kind === 'ident') {
+      this.advance()
+      if (token.value === 'selector' && this.check('<')) {
+        this.advance() // consume <
+        const entityType = this.expect('ident').value
+        this.expect('>')
+        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 if (token.value === 'double' || token.value === 'byte' ||
+                 token.value === 'short' || token.value === 'long' ||
+                 token.value === 'format_string') {
+        type = { kind: 'named', name: token.value as any }
+      } else {
+        type = { kind: 'struct', name: token.value }
+      }
+    } else {
+      this.error(`Expected type, got '${token.value || token.kind}'. Valid types: int, float, bool, string, void, or a struct/enum name`)
+    }
+
+    while (this.match('[')) {
+      this.expect(']')
+      type = { kind: 'array', elem: type }
+    }
+
+    return type
+  }
+
+  parseFunctionType(): TypeNode {
+    this.expect('(')
+    const params: TypeNode[] = []
+
+    if (!this.check(')')) {
+      do {
+        params.push(this.parseType())
+      } while (this.match(','))
+    }
+
+    this.expect(')')
+    this.expect('->')
+    const returnType = this.parseType()
+    return { kind: 'function_type', params, return: returnType }
+  }
+
+  /**
+   * 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.
+   */
+  tryParseTypeArgs(): TypeNode[] | null {
+    const saved = this.pos
+    this.advance() // consume '<'
+    const typeArgs: 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
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Lambda lookahead helpers (needed by expr-parser)
+  // -------------------------------------------------------------------------
+
+  isLambdaStart(): boolean {
+    if (!this.check('(')) return false
+
+    let offset = 1
+    if (this.peek(offset).kind !== ')') {
+      while (true) {
+        if (this.peek(offset).kind !== 'ident') {
+          return false
+        }
+        offset += 1
+
+        if (this.peek(offset).kind === ':') {
+          offset += 1
+          const consumed = this.typeTokenLength(offset)
+          if (consumed === 0) {
+            return false
+          }
+          offset += consumed
+        }
+
+        if (this.peek(offset).kind === ',') {
+          offset += 1
+          continue
+        }
+        break
+      }
+    }
+
+    if (this.peek(offset).kind !== ')') {
+      return false
+    }
+    offset += 1
+
+    if (this.peek(offset).kind === '=>') {
+      return true
+    }
+
+    if (this.peek(offset).kind === '->') {
+      offset += 1
+      const consumed = this.typeTokenLength(offset)
+      if (consumed === 0) {
+        return false
+      }
+      offset += consumed
+      return this.peek(offset).kind === '=>'
+    }
+
+    return false
+  }
+
+  typeTokenLength(offset: number): number {
+    const token = this.peek(offset)
+
+    if (token.kind === '(') {
+      let inner = offset + 1
+      if (this.peek(inner).kind !== ')') {
+        while (true) {
+          const consumed = this.typeTokenLength(inner)
+          if (consumed === 0) {
+            return 0
+          }
+          inner += consumed
+          if (this.peek(inner).kind === ',') {
+            inner += 1
+            continue
+          }
+          break
+        }
+      }
+
+      if (this.peek(inner).kind !== ')') {
+        return 0
+      }
+      inner += 1
+
+      if (this.peek(inner).kind !== '->') {
+        return 0
+      }
+      inner += 1
+      const returnLen = this.typeTokenLength(inner)
+      return returnLen === 0 ? 0 : inner + returnLen - offset
+    }
+
+    const isNamedType =
+      token.kind === 'int' ||
+      token.kind === 'bool' ||
+      token.kind === 'float' ||
+      token.kind === 'fixed' ||
+      token.kind === 'string' ||
+      token.kind === 'void' ||
+      token.kind === 'BlockPos' ||
+      token.kind === 'ident'
+    if (!isNamedType) {
+      return 0
+    }
+
+    let length = 1
+    while (this.peek(offset + length).kind === '[' && this.peek(offset + length + 1).kind === ']') {
+      length += 2
+    }
+    return length
+  }
+
+  // -------------------------------------------------------------------------
+  // Params parsing (used by decl-parser)
+  // -------------------------------------------------------------------------
+
+  parseParams(implTypeName?: string): Param[] {
+    const params: Param[] = []
+
+    if (!this.check(')')) {
+      do {
+        const paramToken = this.expect('ident')
+        const name = paramToken.value
+        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: import('../ast/types').Expr | undefined
+        if (this.match('=')) {
+          defaultValue = (this as any).parseExpr()
+        }
+        params.push(this.withLoc({ name, type, default: defaultValue }, paramToken))
+      } while (this.match(','))
+    }
+
+    return params
+  }
+
+  parseInterfaceParams(): Param[] {
+    const params: Param[] = []
+    if (!this.check(')')) {
+      do {
+        const paramToken = this.expect('ident')
+        const paramName = paramToken.value
+        let type: TypeNode
+        if (params.length === 0 && paramName === 'self' && !this.check(':')) {
+          type = { kind: 'named', name: 'void' }
+        } else {
+          this.expect(':')
+          type = this.parseType()
+        }
+        params.push(this.withLoc({ name: paramName, type }, paramToken))
+      } while (this.match(','))
+    }
+    return params
+  }
+}

package/src/parser/utils.ts

@@ -0,0 +1,173 @@
+/**
+ * Parser utilities — base class with token navigation, error handling,
+ * and shared constants used by all sub-parsers.
+ */
+
+import { Lexer, type Token, type TokenKind } from '../lexer'
+import type { Span } from '../ast/types'
+import { DiagnosticError } from '../diagnostics'
+
+// ---------------------------------------------------------------------------
+// Operator Precedence (higher = binds tighter)
+// ---------------------------------------------------------------------------
+
+export const PRECEDENCE: Record<string, number> = {
+  '||': 1,
+  '&&': 2,
+  '==': 3, '!=': 3,
+  '<': 4, '<=': 4, '>': 4, '>=': 4, 'is': 4,
+  '+': 5, '-': 5,
+  '*': 6, '/': 6, '%': 6,
+}
+
+export const BINARY_OPS = new Set(['||', '&&', '==', '!=', '<', '<=', '>', '>=', 'is', '+', '-', '*', '/', '%'])
+
+export type { Lexer }
+
+// ---------------------------------------------------------------------------
+// ParserBase — token navigation, error reporting, span attachment
+// ---------------------------------------------------------------------------
+
+export class ParserBase {
+  protected tokens: Token[]
+  protected pos: number = 0
+  protected sourceLines: string[]
+  protected filePath?: string
+  /** Set to true once `module library;` is seen. */
+  protected inLibraryMode: boolean = false
+  /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
+  readonly warnings: string[] = []
+  /** Parse errors collected during error-recovery mode. */
+  readonly parseErrors: DiagnosticError[] = []
+
+  constructor(tokens: Token[], source?: string, filePath?: string) {
+    this.tokens = tokens
+    this.sourceLines = source?.split('\n') ?? []
+    this.filePath = filePath
+  }
+
+  // -------------------------------------------------------------------------
+  // Token navigation
+  // -------------------------------------------------------------------------
+
+  peek(offset = 0): Token {
+    const idx = this.pos + offset
+    if (idx >= this.tokens.length) {
+      return this.tokens[this.tokens.length - 1] // eof
+    }
+    return this.tokens[idx]
+  }
+
+  advance(): Token {
+    const token = this.tokens[this.pos]
+    if (token.kind !== 'eof') this.pos++
+    return token
+  }
+
+  check(kind: TokenKind): boolean {
+    return this.peek().kind === kind
+  }
+
+  match(...kinds: TokenKind[]): boolean {
+    for (const kind of kinds) {
+      if (this.check(kind)) {
+        this.advance()
+        return true
+      }
+    }
+    return false
+  }
+
+  expect(kind: TokenKind): Token {
+    const token = this.peek()
+    if (token.kind !== kind) {
+      throw new DiagnosticError(
+        'ParseError',
+        `Expected '${kind}' but got '${token.kind}'`,
+        { file: this.filePath, line: token.line, col: token.col },
+        this.sourceLines
+      )
+    }
+    return this.advance()
+  }
+
+  error(message: string): never {
+    const token = this.peek()
+    throw new DiagnosticError(
+      'ParseError',
+      message,
+      { file: this.filePath, line: token.line, col: token.col },
+      this.sourceLines
+    )
+  }
+
+  withLoc<T extends object>(node: T, token: Token): T {
+    const span: Span = { line: token.line, col: token.col }
+    Object.defineProperty(node, 'span', {
+      value: span,
+      enumerable: false,
+      configurable: true,
+      writable: true,
+    })
+    return node
+  }
+
+  getLocToken(node: object): Token | null {
+    const span = (node as { span?: Span }).span
+    if (!span) {
+      return null
+    }
+    return { kind: 'eof', value: '', line: span.line, col: span.col }
+  }
+
+  checkIdent(value: string): boolean {
+    return this.check('ident') && this.peek().value === value
+  }
+
+  // -------------------------------------------------------------------------
+  // Error Recovery
+  // -------------------------------------------------------------------------
+
+  syncToNextDecl(): void {
+    const TOP_LEVEL_KEYWORDS = new Set([
+      'fn', 'struct', 'impl', 'enum', 'const', 'let', 'export', 'declare', 'import', 'namespace', 'module'
+    ])
+    while (!this.check('eof')) {
+      const kind = this.peek().kind
+      if (kind === '}') {
+        this.advance()
+        return
+      }
+      if (TOP_LEVEL_KEYWORDS.has(kind)) {
+        return
+      }
+      if (kind === 'ident' && this.peek().value === 'import') {
+        return
+      }
+      this.advance()
+    }
+  }
+
+  syncToNextStmt(): void {
+    while (!this.check('eof')) {
+      const kind = this.peek().kind
+      if (kind === ';') {
+        this.advance()
+        return
+      }
+      if (kind === '}') {
+        return
+      }
+      this.advance()
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Sub-parser helper (used by string interpolation)
+  // -------------------------------------------------------------------------
+
+  protected makeSubParser(source: string): ParserBase {
+    const tokens = new Lexer(source, this.filePath).tokenize()
+    return new ParserBase(tokens, source, this.filePath)
+  }
+}

package/src/stdlib/queue.mcrs

@@ -11,6 +11,19 @@
 
 module library;
 
+// Placeholder conventions used in raw() strings:
+//   __OBJ__  → replaced with __<namespace> (per-namespace scoreboard objective)
+//   __NS__   → replaced with the current namespace
+//   __RS__   → replaced with "rs" (global RedScript scoreboard objective)
+
+// ─── Initialisation ──────────────────────────────────────────────────────────
+
+/// Ensure the shared "rs" scoreboard objective exists.
+/// Called automatically on datapack load.
+@load fn __queue_init() {
+    raw("scoreboard objectives add rs dummy");
+}
+
 // ─── Internal macro helpers ──────────────────────────────────────────────────
 
 fn __queue_append_apply() {
@@ -18,11 +31,11 @@ fn __queue_append_apply() {
 }
 
 fn __queue_peek_apply() {
-    raw("$execute store result score $ret __OBJ__ run data get storage rs:arrays Queue[$(idx)]");
+    raw("$execute store result score rs.peek_tmp __RS__ run data get storage rs:arrays Queue[$(idx)]");
 }
 
 fn __queue_size_raw_apply() {
-    raw("$execute store result score $ret __OBJ__ run data get storage rs:arrays Queue");
+    raw("execute store result score $ret __OBJ__ run data get storage rs:arrays Queue");
 }
 
 // ─── Public API ──────────────────────────────────────────────────────────────
@@ -53,10 +66,10 @@ fn queue_pop(): int {
     let empty: int = queue_empty();
     if (empty == 1) { return -1; }
 
-    // Read front element
-    raw("scoreboard players set $ret __OBJ__ 0");
+    // Read front element via macro (idx → Queue[idx] → rs.peek_tmp)
     raw("execute store result storage rs:macro_args idx int 1 run scoreboard players get rs.q_head __RS__");
     raw("function __NS__:__queue_peek_apply with storage rs:macro_args");
+    raw("scoreboard players operation $ret __OBJ__ = rs.peek_tmp __RS__");
     // Advance head pointer
     raw("scoreboard players add rs.q_head __RS__ 1");
     raw("return 1");
@@ -75,9 +88,9 @@ fn queue_peek(): int {
     let empty: int = queue_empty();
     if (empty == 1) { return -1; }
 
-    raw("scoreboard players set $ret __OBJ__ 0");
     raw("execute store result storage rs:macro_args idx int 1 run scoreboard players get rs.q_head __RS__");
     raw("function __NS__:__queue_peek_apply with storage rs:macro_args");
+    raw("scoreboard players operation $ret __OBJ__ = rs.peek_tmp __RS__");
     raw("return 1");
     return 0;
 }
@@ -92,7 +105,7 @@ fn queue_peek(): int {
 /// let n: int = queue_size()
 fn queue_size(): int {
     raw("scoreboard players set $ret __OBJ__ 0");
-    raw("function __NS__:__queue_size_raw_apply with storage rs:macro_args");
+    raw("function __NS__:__queue_size_raw_apply");
     raw("scoreboard players operation $ret __OBJ__ -= rs.q_head __RS__");
     raw("return 1");
     return 0;