redscript-mc 2.6.2 → 3.0.0

package/src/hir/types.ts

@@ -43,6 +43,8 @@ export type {
   AssignOp,
 }
 
+
+
 // ---------------------------------------------------------------------------
 // HIR Expressions
 // ---------------------------------------------------------------------------
@@ -68,7 +70,7 @@ export type HIRExpr =
   | { kind: 'selector'; raw: string; isSingle: boolean; sel: EntitySelector; span?: Span }
   // String interpolation
   | { kind: 'str_interp'; parts: Array<string | HIRExpr>; span?: Span }
-  | { kind: 'f_string'; parts: FStringPart[]; span?: Span }
+  | { kind: 'f_string'; parts: HIRFStringPart[]; span?: Span }
   // Identifiers
   | { kind: 'ident'; name: string; span?: Span }
   // Operators — && and || preserved (control-flow lowering happens in MIR)
@@ -88,6 +90,8 @@ export type HIRExpr =
   | { kind: 'static_call'; type: string; method: string; args: HIRExpr[]; span?: Span }
   // Enum variant path
   | { kind: 'path_expr'; enumName: string; variant: string; span?: Span }
+  // Enum variant construction with payload
+  | { kind: 'enum_construct'; enumName: string; variant: string; args: { name: string; value: HIRExpr }[]; span?: Span }
   // Lambda
   | { kind: 'lambda'; params: LambdaParam[]; returnType?: TypeNode; body: HIRExpr | HIRBlock; span?: Span }
   // Tuple literal
@@ -95,9 +99,15 @@ export type HIRExpr =
   // Option literals
   | { kind: 'some_lit'; value: HIRExpr; span?: Span }
   | { kind: 'none_lit'; span?: Span }
+  | { kind: 'unwrap_or'; opt: HIRExpr; default_: HIRExpr; span?: Span }
   // Type cast: expr as Type
   | { kind: 'type_cast'; expr: HIRExpr; targetType: TypeNode; span?: Span }
 
+/** HIR-level f-string part — uses HIRExpr instead of AST Expr */
+export type HIRFStringPart =
+  | { kind: 'text'; value: string }
+  | { kind: 'expr'; expr: HIRExpr }
+
 // ---------------------------------------------------------------------------
 // Execute Subcommands (unified — absorbs as_block, at_block, as_at)
 // ---------------------------------------------------------------------------
@@ -140,6 +150,7 @@ export type HIRMatchPattern =
   | { kind: 'PatInt'; value: number }      // 1, 2, 3
   | { kind: 'PatWild' }                    // _
   | { kind: 'PatExpr'; expr: HIRExpr }     // legacy: range_lit or other expr
+  | { kind: 'PatEnum'; enumName: string; variant: string; bindings: string[] }  // Color::RGB(r, g, b)
 
 // ---------------------------------------------------------------------------
 // HIR Statements
@@ -148,10 +159,14 @@ export type HIRMatchPattern =
 export type HIRStmt =
   | { kind: 'let'; name: string; type?: TypeNode; init: HIRExpr; span?: Span }
   | { kind: 'let_destruct'; names: string[]; type?: TypeNode; init: HIRExpr; span?: Span }
+  | { kind: 'const_decl'; name: string; type: TypeNode; value: HIRExpr; span?: Span }
   | { kind: 'expr'; expr: HIRExpr; span?: Span }
   | { kind: 'return'; value?: HIRExpr; span?: Span }
   | { kind: 'break'; span?: Span }
   | { kind: 'continue'; span?: Span }
+  | { kind: 'break_label'; label: string; span?: Span }
+  | { kind: 'continue_label'; label: string; span?: Span }
+  | { kind: 'labeled_loop'; label: string; body: HIRStmt; span?: Span }
   | { kind: 'if'; cond: HIRExpr; then: HIRBlock; else_?: HIRBlock; span?: Span }
   | { kind: 'while'; cond: HIRExpr; body: HIRBlock; step?: HIRBlock; span?: Span }
   // foreach preserved (entity iteration is MC-specific, not just sugar)
@@ -162,6 +177,7 @@ export type HIRStmt =
   | { kind: 'execute'; subcommands: HIRExecuteSubcommand[]; body: HIRBlock; span?: Span }
   | { kind: 'raw'; cmd: string; span?: Span }
   | { kind: 'if_let_some'; binding: string; init: HIRExpr; then: HIRBlock; else_?: HIRBlock; span?: Span }
+  | { kind: 'while_let_some'; binding: string; init: HIRExpr; body: HIRBlock; span?: Span }
 
 export type HIRBlock = HIRStmt[]
 
@@ -186,6 +202,9 @@ export interface HIRFunction {
   isLibraryFn?: boolean
   isExported?: boolean
   span?: Span
+  sourceFile?: string
+  /** Set when the function is decorated with @watch("objective") — the scoreboard objective to watch. */
+  watchObjective?: string
 }
 
 export interface HIRStructField {
@@ -195,12 +214,17 @@ export interface HIRStructField {
 
 export interface HIRStruct {
   name: string
+  extends?: string
   fields: HIRStructField[]
+  /** True when the struct was declared with `@singleton` */
+  isSingleton?: boolean
   span?: Span
 }
 
 export interface HIRImplBlock {
   typeName: string
+  /** Trait name when declared as `impl TraitName for TypeName` (e.g. "Display") */
+  traitName?: string
   methods: HIRFunction[]
   span?: Span
 }
@@ -208,6 +232,7 @@ export interface HIRImplBlock {
 export interface HIREnumVariant {
   name: string
   value?: number
+  fields?: { name: string; type: TypeNode }[]
 }
 
 export interface HIREnum {

package/src/index.ts

@@ -7,6 +7,7 @@
 export const version = '2.0.0'
 
 import { compile } from './emit/compile'
+import { CheckFailedError, DiagnosticError, parseErrorMessage } from './diagnostics'
 
 // Re-export v2 compile API
 export { compile, CompileOptions, CompileResult } from './emit/compile'
@@ -34,6 +35,11 @@ export interface CheckResult {
   warnings: string[]
 }
 
+export interface DetailedCheckResult {
+  errors: DiagnosticError[]
+  warnings: string[]
+}
+
 /**
  * Check RedScript source code for errors without generating output.
  * Runs the full compile pipeline (lex → parse → HIR → MIR → LIR → emit)
@@ -51,10 +57,24 @@ export function check(source: string, namespace = 'redscript', filePath?: string
  * Like check(), but also returns warnings (e.g., tick budget analysis).
  */
 export function checkWithWarnings(source: string, namespace = 'redscript', filePath?: string): CheckResult {
+  const result = checkDetailed(source, namespace, filePath)
+  return { error: result.errors[0] ?? null, warnings: result.warnings }
+}
+
+export function checkDetailed(source: string, namespace = 'redscript', filePath?: string): DetailedCheckResult {
   try {
-    const result = compile(source, { namespace, filePath })
-    return { error: null, warnings: result.warnings }
+    const result = compile(source, { namespace, filePath, stopAfterCheck: true })
+    return { errors: [], warnings: result.warnings }
   } catch (err) {
-    return { error: err as Error, warnings: [] }
+    if (err instanceof CheckFailedError) {
+      return { errors: err.diagnostics, warnings: err.warnings }
+    }
+    if (err instanceof DiagnosticError) {
+      return { errors: [err], warnings: [] }
+    }
+    return {
+      errors: [parseErrorMessage('LoweringError', (err as Error).message, source.split('\n'), filePath)],
+      warnings: [],
+    }
   }
 }

package/src/lexer/index.ts

@@ -14,9 +14,9 @@ import { DiagnosticError } from '../diagnostics'
 
 export type TokenKind =
   // Keywords
-  | 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match'
-  | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module'
-  | 'execute' | 'run' | 'unless' | 'declare' | 'export'
+  | 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'do' | 'repeat'
+  | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'extends' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module' | 'interface'
+  | 'execute' | 'run' | 'unless' | 'declare' | 'export' | 'import'
   // Types
   | 'int' | 'bool' | 'float' | 'fixed' | 'string' | 'void'
   | 'BlockPos'
@@ -73,6 +73,8 @@ const KEYWORDS: Record<string, TokenKind> = {
   while: 'while',
   for: 'for',
   foreach: 'foreach',
+  do: 'do',
+  repeat: 'repeat',
   match: 'match',
   return: 'return',
   break: 'break',
@@ -82,6 +84,7 @@ const KEYWORDS: Record<string, TokenKind> = {
   in: 'in',
   is: 'is',
   struct: 'struct',
+  extends: 'extends',
   impl: 'impl',
   enum: 'enum',
   trigger: 'trigger',
@@ -92,6 +95,8 @@ const KEYWORDS: Record<string, TokenKind> = {
   unless: 'unless',
   declare: 'declare',
   export: 'export',
+  import: 'import',
+  interface: 'interface',
   int: 'int',
   bool: 'bool',
   float: 'float',
@@ -370,9 +375,15 @@ export class Lexer {
       return
     }
 
-    // String literal
+    // String literal (triple-quoted multi-line or regular)
     if (char === '"') {
-      this.scanString(startLine, startCol)
+      if (this.peek() === '"' && this.peek(1) === '"') {
+        this.advance() // consume second "
+        this.advance() // consume third "
+        this.scanMultiLineString(startLine, startCol)
+      } else {
+        this.scanString(startLine, startCol)
+      }
       return
     }
 
@@ -428,7 +439,7 @@ export class Lexer {
 
     // Otherwise it's a decorator (@tick, @on_trigger, etc.)
     let value = '@'
-    while (/[a-zA-Z_0-9]/.test(this.peek())) {
+    while (/[a-zA-Z_0-9-]/.test(this.peek())) {
       value += this.advance()
     }
 
@@ -465,6 +476,34 @@ export class Lexer {
     return result
   }
 
+  private scanMultiLineString(startLine: number, startCol: number): void {
+    let value = ''
+
+    while (!this.isAtEnd()) {
+      // Check for closing """
+      if (this.peek() === '"' && this.peek(1) === '"' && this.peek(2) === '"') {
+        this.advance() // consume first "
+        this.advance() // consume second "
+        this.advance() // consume third "
+        break
+      }
+
+      if (this.peek() === '\\' && this.peek(1) === '"') {
+        this.advance() // skip backslash
+        value += this.advance() // add escaped quote
+        continue
+      }
+
+      value += this.advance()
+    }
+
+    // Trim leading/trailing newline for cleaner multi-line strings
+    if (value.startsWith('\n')) value = value.slice(1)
+    if (value.endsWith('\n')) value = value.slice(0, -1)
+
+    this.addToken('string_lit', value, startLine, startCol)
+  }
+
   private scanString(startLine: number, startCol: number): void {
     let value = ''
     let interpolationDepth = 0