redscript-mc 1.2.29 → 2.0.0

package/src/index.ts

@@ -1,181 +1,30 @@
 /**
  * RedScript Compiler
- * 
+ *
  * Main entry point for programmatic usage.
  */
 
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-export const version = '1.2.11'
+export const version = '2.0.0'
 
 import { Lexer } from './lexer'
 import { Parser } from './parser'
-import { TypeChecker } from './typechecker'
-import { Lowering, setScoreboardObjective } from './lowering'
-import type { Warning } from './lowering'
-import {
-  constantFoldingWithStats,
-  copyPropagation,
-  deadCodeEliminationWithStats,
-} from './optimizer/passes'
-import { eliminateDeadCode } from './optimizer/dce'
-import {
-  countMcfunctionCommands,
-  generateDatapackWithStats,
-  DatapackFile,
-} from './codegen/mcfunction'
-import { preprocessSource, preprocessSourceWithMetadata } from './compile'
-import type { IRModule } from './ir/types'
-import type { Program } from './ast/types'
-import type { DiagnosticError } from './diagnostics'
-import { createEmptyOptimizationStats, type OptimizationStats } from './optimizer/commands'
+import { preprocessSource } from './compile'
 
-export interface CompileOptions {
-  namespace?: string
-  optimize?: boolean
-  typeCheck?: boolean
-  filePath?: string
-  dce?: boolean
-  mangle?: boolean
-  /** Scoreboard objective used for all variable slots.
-   *  Defaults to '__<namespace>' (e.g. '__mathshow') to avoid collisions when
-   *  multiple RedScript datapacks are loaded simultaneously, without occupying
-   *  the user's own namespace. Override only if you need a specific name. */
-  scoreboardObjective?: string
-}
-
-export interface CompileResult {
-  files: DatapackFile[]
-  advancements: DatapackFile[]
-  ast: Program
-  ir: IRModule
-  typeErrors?: DiagnosticError[]
-  warnings?: Warning[]
-  stats?: OptimizationStats
-  sourceMap?: Record<string, string>
-}
-
-/**
- * Compile RedScript source code to a Minecraft datapack.
- * 
- * @param source - The RedScript source code
- * @param options - Compilation options
- * @returns Compiled datapack files
- */
-export function compile(source: string, options: CompileOptions = {}): CompileResult {
-  const namespace = options.namespace ?? 'redscript'
-  const shouldOptimize = options.optimize ?? true
-  const shouldTypeCheck = options.typeCheck ?? true
-  const shouldRunDce = options.dce ?? shouldOptimize
-  const mangle = options.mangle ?? false
-  const filePath = options.filePath
-  const preprocessed = preprocessSourceWithMetadata(source, { filePath })
-  const preprocessedSource = preprocessed.source
-
-  // Lexing
-  const tokens = new Lexer(preprocessedSource, filePath).tokenize()
-
-  // Parsing — user source
-  const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
-
-  // Library imports: files that declared `module library;` are parsed independently
-  // (fresh Parser per file) so their functions are DCE-eligible but never bleed into user code.
-  const allLibrarySources: Array<{ src: string; fp?: string }> = []
-  for (const li of preprocessed.libraryImports ?? []) {
-    allLibrarySources.push({ src: li.source, fp: li.filePath })
-  }
-  for (const { src, fp } of allLibrarySources) {
-    const libPreprocessed = preprocessSourceWithMetadata(src, fp ? { filePath: fp } : {})
-    const libTokens = new Lexer(libPreprocessed.source, fp).tokenize()
-    const libAst = new Parser(libTokens, libPreprocessed.source, fp).parse(namespace)
-    for (const fn of libAst.declarations) fn.isLibraryFn = true
-    parsedAst.declarations.push(...libAst.declarations)
-    parsedAst.structs.push(...libAst.structs)
-    parsedAst.implBlocks.push(...libAst.implBlocks)
-    parsedAst.enums.push(...libAst.enums)
-    parsedAst.consts.push(...libAst.consts)
-    parsedAst.globals.push(...libAst.globals)
-  }
-
-  const dceResult = shouldRunDce ? eliminateDeadCode(parsedAst, preprocessed.ranges) : { program: parsedAst, warnings: [] }
-  const ast = dceResult.program
-
-  // Type checking (warn mode - collect errors but don't block)
-  let typeErrors: DiagnosticError[] | undefined
-  if (shouldTypeCheck) {
-    const checker = new TypeChecker(preprocessedSource, filePath)
-    typeErrors = checker.check(ast)
-  }
-
-  // Configure scoreboard objective for this compilation.
-  // Default: use the datapack namespace so each datapack gets its own objective
-  // automatically, preventing variable collisions when multiple datapacks coexist.
-  const scoreboardObj = options.scoreboardObjective ?? `__${namespace}`
-  setScoreboardObjective(scoreboardObj)
-
-  // Lowering to IR
-  const lowering = new Lowering(namespace, preprocessed.ranges)
-  const ir = lowering.lower(ast)
-
-  let optimizedIR: IRModule = ir
-  let generated = generateDatapackWithStats(ir, { optimizeCommands: shouldOptimize, mangle, scoreboardObjective: scoreboardObj })
-  let optimizationStats: OptimizationStats | undefined
-
-  if (shouldOptimize) {
-    const stats = createEmptyOptimizationStats()
-    const copyPropagatedFunctions = []
-    const deadCodeEliminatedFunctions = []
-
-    for (const fn of ir.functions) {
-      const folded = constantFoldingWithStats(fn)
-      stats.constantFolds += folded.stats.constantFolds ?? 0
+// Re-export v2 compile API
+export { compile, CompileOptions, CompileResult } from '../src2/emit/compile'
+export type { DatapackFile } from '../src2/emit/index'
 
-      const propagated = copyPropagation(folded.fn)
-      copyPropagatedFunctions.push(propagated)
-
-      const dce = deadCodeEliminationWithStats(propagated)
-      deadCodeEliminatedFunctions.push(dce.fn)
-    }
-
-    const copyPropagatedIR: IRModule = { ...ir, functions: copyPropagatedFunctions }
-    optimizedIR = { ...ir, functions: deadCodeEliminatedFunctions }
-
-    const baselineGenerated = generateDatapackWithStats(ir, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
-    const beforeDceGenerated = generateDatapackWithStats(copyPropagatedIR, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
-    const afterDceGenerated = generateDatapackWithStats(optimizedIR, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
-    generated = generateDatapackWithStats(optimizedIR, { optimizeCommands: true, mangle, scoreboardObjective: scoreboardObj })
-
-    stats.deadCodeRemoved =
-      countMcfunctionCommands(beforeDceGenerated.files) - countMcfunctionCommands(afterDceGenerated.files)
-    stats.licmHoists = generated.stats.licmHoists
-    stats.licmLoopBodies = generated.stats.licmLoopBodies
-    stats.cseRedundantReads = generated.stats.cseRedundantReads
-    stats.cseArithmetic = generated.stats.cseArithmetic
-    stats.setblockMergedCommands = generated.stats.setblockMergedCommands
-    stats.setblockFillCommands = generated.stats.setblockFillCommands
-    stats.setblockSavedCommands = generated.stats.setblockSavedCommands
-    stats.totalCommandsBefore = countMcfunctionCommands(baselineGenerated.files)
-    stats.totalCommandsAfter = countMcfunctionCommands(generated.files)
-    optimizationStats = stats
-  } else {
-    optimizedIR = ir
-    generated = generateDatapackWithStats(ir, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
-  }
-
-  return {
-    files: [...generated.files, ...generated.advancements],
-    advancements: generated.advancements,
-    ast,
-    ir: optimizedIR,
-    typeErrors,
-    warnings: [...dceResult.warnings, ...lowering.warnings],
-    stats: optimizationStats,
-    sourceMap: generated.sourceMap,
-  }
-}
+// Re-export utilities
+export { Lexer } from './lexer'
+export { Parser } from './parser'
+export { preprocessSource, preprocessSourceWithMetadata } from './compile'
+export { MCCommandValidator } from './mc-validator'
+export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types'
+export type { DiagnosticError } from './diagnostics'
 
 /**
  * Check RedScript source code for errors without generating output.
- * 
+ *
  * @param source - The RedScript source code
  * @param namespace - Optional namespace
  * @returns null if no errors, or an error object
@@ -190,16 +39,3 @@ export function check(source: string, namespace = 'redscript', filePath?: string
     return err as Error
   }
 }
-
-// Re-export types and classes for advanced usage
-export { Lexer } from './lexer'
-export { Parser } from './parser'
-export { TypeChecker } from './typechecker'
-export { Lowering } from './lowering'
-export { optimize } from './optimizer/passes'
-export { generateDatapack } from './codegen/mcfunction'
-export { MCCommandValidator } from './mc-validator'
-export type { DatapackFile } from './codegen/mcfunction'
-export type { IRModule, IRFunction } from './ir/types'
-export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types'
-export type { DiagnosticError } from './diagnostics'

package/src/lexer/index.ts

@@ -313,9 +313,17 @@ export class Lexer {
       return
     }
 
-    // Local coordinate: ^ or ^5 or ^-3 or ^0.5
+    // Local coordinate: ^ or ^5 or ^-3 or ^0.5 or ^varname (macro variable)
     if (char === '^') {
       let value = '^'
+      // Check for identifier (variable name for macro substitution, e.g. ^px, ^height)
+      if (/[a-zA-Z_]/.test(this.peek())) {
+        while (/[a-zA-Z0-9_]/.test(this.peek())) {
+          value += this.advance()
+        }
+        this.addToken('local_coord', value, startLine, startCol)
+        return
+      }
       // Check for optional sign
       if (this.peek() === '-' || this.peek() === '+') {
         value += this.advance()

package/src/mc-test/runner.ts

@@ -54,9 +54,10 @@ export async function runMCTests(
     // Compile and install datapack
     const outDir = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
     console.log(`Compiling ${sourceFile}...`)
-    const result = compile(fs.readFileSync(sourceFile, 'utf-8'))
-    if (!result.success || !result.files) {
-      throw result.error ?? new Error('Compilation failed')
+    const ns = path.basename(sourceFile, '.mcrs')
+    const result = compile(fs.readFileSync(sourceFile, 'utf-8'), { namespace: ns, filePath: sourceFile })
+    if (!result.files) {
+      throw new Error('Compilation failed')
     }
     // Write files
     fs.mkdirSync(outDir, { recursive: true })

package/src/parser/index.ts

@@ -12,7 +12,7 @@ import type {
   StructDecl, StructField, ExecuteSubcommand, EnumDecl, EnumVariant, BlockPosExpr, ImplBlock,
   CoordComponent, LambdaParam, EntityTypeName
 } from '../ast/types'
-import type { BinOp, CmpOp } from '../ir/types'
+import type { BinOp, CmpOp } from '../ast/types'
 import { DiagnosticError } from '../diagnostics'
 
 // ---------------------------------------------------------------------------

package/src/repl.ts

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

package/src/runtime/index.ts

@@ -1496,7 +1496,7 @@ export class MCRuntime {
 
   compileAndLoad(source: string): void {
     const result = rsCompile(source, { namespace: this.namespace })
-    if (!result.success || !result.files) {
+    if (!result.files) {
       throw new Error('Compilation failed')
     }
 

package/src2/__tests__/e2e/basic.test.ts

@@ -0,0 +1,154 @@
+/**
+ * End-to-end tests for the v2 compiler pipeline.
+ *
+ * These tests compile RedScript source through the full pipeline
+ * (Lexer → Parser → HIR → MIR → optimize → LIR → emit) and verify
+ * the generated .mcfunction output contains expected MC commands.
+ */
+
+import { compile } from '../../emit/compile'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+describe('e2e: basic compilation', () => {
+  test('simple arithmetic function produces scoreboard commands', () => {
+    const source = `
+      fn add(a: int, b: int): int {
+        return a + b;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+
+    const addFn = getFile(result.files, 'add.mcfunction')
+    expect(addFn).toBeDefined()
+    expect(addFn).toContain('scoreboard players operation')
+    expect(addFn).toContain('__test')
+  })
+
+  test('pack.mcmeta is generated with pack_format 26', () => {
+    const source = `fn noop(): void {}`
+    const result = compile(source, { namespace: 'demo' })
+    const meta = getFile(result.files, 'pack.mcmeta')
+    expect(meta).toBeDefined()
+    const parsed = JSON.parse(meta!)
+    expect(parsed.pack.pack_format).toBe(26)
+  })
+
+  test('load.mcfunction creates scoreboard objective', () => {
+    const source = `fn noop(): void {}`
+    const result = compile(source, { namespace: 'mypack' })
+    const load = getFile(result.files, 'load.mcfunction')
+    expect(load).toBeDefined()
+    expect(load).toContain('scoreboard objectives add __mypack dummy')
+  })
+
+  test('@tick function appears in tick.json', () => {
+    const source = `
+      @tick fn game_tick(): void {
+        let x: int = 1;
+      }
+    `
+    const result = compile(source, { namespace: 'ticktest' })
+    const tickJson = getFile(result.files, 'tick.json')
+    expect(tickJson).toBeDefined()
+    const parsed = JSON.parse(tickJson!)
+    expect(parsed.values).toContain('ticktest:game_tick')
+  })
+
+  test('@load function appears in load.json', () => {
+    const source = `
+      @load fn setup(): void {
+        let x: int = 42;
+      }
+    `
+    const result = compile(source, { namespace: 'loadtest' })
+    const loadJson = getFile(result.files, 'load.json')
+    expect(loadJson).toBeDefined()
+    const parsed = JSON.parse(loadJson!)
+    expect(parsed.values).toContain('loadtest:setup')
+    // load.json should also reference the objective-init load function
+    expect(parsed.values).toContain('loadtest:load')
+  })
+
+  test('if/else produces conditional call pattern', () => {
+    const source = `
+      fn check(x: int): int {
+        if (x > 0) {
+          return 1;
+        } else {
+          return 0;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'cond' })
+
+    // The main function should contain call_if_matches / call_unless_matches
+    const checkFn = getFile(result.files, 'check.mcfunction')
+    expect(checkFn).toBeDefined()
+    expect(checkFn).toContain('execute if score')
+    expect(checkFn).toContain('matches')
+    expect(checkFn).toContain('run function')
+  })
+
+  test('while loop produces loop structure with recursive call', () => {
+    const source = `
+      fn count(): void {
+        let i: int = 0;
+        while (i < 10) {
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'loop' })
+
+    // There should be a loop body function that calls itself (or a header)
+    const fnFiles = result.files.filter(f => f.path.endsWith('.mcfunction'))
+    expect(fnFiles.length).toBeGreaterThan(1) // main + at least one extracted block
+
+    // At least one file should have a conditional call pattern for the loop
+    const allContent = fnFiles.map(f => f.content).join('\n')
+    expect(allContent).toContain('execute if score')
+    expect(allContent).toContain('run function')
+  })
+
+  test('function names are lowercased in output paths', () => {
+    const source = `fn MyFunc(): void {}`
+    const result = compile(source, { namespace: 'ns' })
+    const fn = result.files.find(f => f.path.includes('myfunc.mcfunction'))
+    expect(fn).toBeDefined()
+  })
+
+  test('constant assignment produces score_set', () => {
+    const source = `
+      fn init(): int {
+        let x: int = 42;
+        return x;
+      }
+    `
+    const result = compile(source, { namespace: 'cst' })
+    const fn = getFile(result.files, 'init.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('scoreboard players set')
+    expect(fn).toContain('42')
+  })
+
+  test('load.json always includes namespace:load', () => {
+    const source = `fn noop(): void {}`
+    const result = compile(source, { namespace: 'abc' })
+    const loadJson = getFile(result.files, 'load.json')
+    expect(loadJson).toBeDefined()
+    const parsed = JSON.parse(loadJson!)
+    expect(parsed.values).toContain('abc:load')
+  })
+
+  test('no tick.json when no @tick functions', () => {
+    const source = `fn noop(): void {}`
+    const result = compile(source, { namespace: 'notick' })
+    const tickJson = getFile(result.files, 'tick.json')
+    expect(tickJson).toBeUndefined()
+  })
+})

package/src2/__tests__/e2e/macros.test.ts

@@ -0,0 +1,199 @@
+/**
+ * End-to-end tests for MC 1.20.2+ macro function support in the v2 pipeline.
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), the compiler should
+ * automatically compile it as a macro function using $-prefixed syntax and
+ * call it via `function ns:fn with storage rs:macro_args`.
+ */
+
+import { compile } from '../../emit/compile'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+// ---------------------------------------------------------------------------
+// Macro function detection
+// ---------------------------------------------------------------------------
+
+describe('e2e: macro function detection', () => {
+  test('function with int params in summon coords emits $-prefixed command', () => {
+    const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'spawn_zombie.mcfunction')
+    expect(fn).toBeDefined()
+    // The function body should have a $summon macro line
+    expect(fn).toContain('$summon minecraft:zombie $(x) $(y) $(z)')
+  })
+
+  test('function with all constant args does NOT produce macro line', () => {
+    const source = `
+      fn spawn_fixed() {
+        summon("minecraft:zombie", 100, 64, 200);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'spawn_fixed.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('summon minecraft:zombie 100 64 200')
+    // No $ prefix
+    expect(fn).not.toMatch(/^\$summon/m)
+  })
+
+  test('function with int params in particle coords emits $-prefixed command', () => {
+    const source = `
+      fn show_particle(x: int, y: int, z: int) {
+        particle("minecraft:flame", x, y, z);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'show_particle.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('$particle minecraft:flame $(x) $(y) $(z)')
+  })
+
+  test('function with int params in setblock coords emits $-prefixed command', () => {
+    const source = `
+      fn place_block(x: int, y: int, z: int) {
+        setblock(x, y, z, "minecraft:stone");
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'place_block.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('$setblock $(x) $(y) $(z) minecraft:stone')
+  })
+
+  test('mixed literal and variable args: only variable args get $()', () => {
+    const source = `
+      fn teleport_y(y: int) {
+        summon("minecraft:zombie", 100, y, 200);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'teleport_y.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('$summon minecraft:zombie 100 $(y) 200')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Macro call site generation
+// ---------------------------------------------------------------------------
+
+describe('e2e: macro call site generation', () => {
+  test('call site emits store_score_to_nbt + function with storage', () => {
+    const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+
+      fn caller(px: int, pz: int) {
+        spawn_zombie(px, 64, pz);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const callerFn = getFile(result.files, 'caller.mcfunction')
+    expect(callerFn).toBeDefined()
+
+    // Should have 'function test:spawn_zombie with storage rs:macro_args'
+    expect(callerFn).toContain('with storage rs:macro_args')
+    expect(callerFn).toContain('spawn_zombie')
+  })
+
+  test('call site stores args to rs:macro_args NBT', () => {
+    const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+
+      fn caller(my_x: int) {
+        spawn_zombie(my_x, 64, 0);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const callerFn = getFile(result.files, 'caller.mcfunction')
+    expect(callerFn).toBeDefined()
+
+    // Should have NBT storage setup for macro args
+    expect(callerFn).toContain('rs:macro_args')
+    expect(callerFn).toContain('with storage')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Float macro params (local coords)
+// ---------------------------------------------------------------------------
+
+describe('e2e: float macro params with local coords', () => {
+  test('float params in ^coord positions produce macro function', () => {
+    const source = `
+      fn draw_pt(px: float, py: float) {
+        particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'draw_pt.mcfunction')
+    expect(fn).toBeDefined()
+    // Should have $particle with ^$(px) and ^$(py)
+    expect(fn).toContain('$particle minecraft:end_rod ^$(px) ^$(py) ^5')
+  })
+
+  test('float macro call site uses double 0.01 scale for NBT storage', () => {
+    const source = `
+      fn draw_pt(px: float, py: float) {
+        particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
+      }
+
+      fn caller() {
+        draw_pt(100, 200);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const callerFn = getFile(result.files, 'caller.mcfunction')
+    expect(callerFn).toBeDefined()
+
+    // Should store to NBT with double type and 0.01 scale
+    expect(callerFn).toContain('rs:macro_args')
+    expect(callerFn).toContain('double 0.01')
+    expect(callerFn).toContain('with storage rs:macro_args')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Non-macro functions still work
+// ---------------------------------------------------------------------------
+
+describe('e2e: non-macro functions', () => {
+  test('say builtin emits normal (non-macro) command', () => {
+    const source = `
+      fn greet() {
+        say("hello world");
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'greet.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('say hello world')
+    // No $ prefix
+    expect(fn).not.toMatch(/^\$/m)
+  })
+
+  test('kill builtin emits normal command', () => {
+    const source = `
+      fn cleanup() {
+        kill(@e[tag=temp]);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'cleanup.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('kill @e[tag=temp]')
+  })
+})