redscript-mc 1.2.0 → 1.2.2

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.0.0",
+      "version": "1.0.1",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.0.0",
+  "version": "1.0.4",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/editors/vscode/syntaxes/redscript.tmLanguage.json

@@ -133,11 +133,11 @@
       "patterns": [
         {
           "name": "keyword.control.redscript",
-          "match": "\\b(if|else|while|for|foreach|return|match|in|execute|as|at|unless|run)\\b"
+          "match": "\\b(if|else|while|for|foreach|return|match|in|execute|as|at|unless|run|is)\\b"
         },
         {
           "name": "keyword.declaration.redscript",
-          "match": "\\b(fn|let|struct|enum|import|namespace|trigger)\\b"
+          "match": "\\b(fn|let|struct|enum|impl|import|namespace|trigger)\\b"
         },
         {
           "name": "keyword.declaration.const.redscript",
@@ -146,6 +146,10 @@
         {
           "name": "constant.language.boolean.redscript",
           "match": "\\b(true|false)\\b"
+        },
+        {
+          "name": "variable.language.self.redscript",
+          "match": "\\bself\\b"
         }
       ]
     },

package/examples/spiral.mcrs

@@ -0,0 +1,41 @@
+// ===== Simple Particle Demo =====
+// 展示: @tick, 状态管理, f-strings, 控制命令
+
+// 状态
+let counter: int = 0;
+let running: bool = false;
+
+// ===== 主循环 =====
+@tick fn demo_tick() {
+    if (!running) { return; }
+    
+    // 每 tick 增加计数器
+    counter = counter + 1;
+    
+    // 在玩家位置生成粒子
+    particle("minecraft:end_rod", ~0, ~1, ~0, 0.5, 0.5, 0.5, 0.1, 5);
+    
+    // 每 20 ticks (1秒) 报告一次
+    if (counter % 20 == 0) {
+        say(f"Running for {counter} ticks");
+    }
+}
+
+// ===== 控制命令 =====
+// @keep 防止 DCE 删除
+@keep fn start() {
+    running = true;
+    counter = 0;
+    say(f"Demo started!");
+}
+
+@keep fn stop() {
+    running = false;
+    say(f"Demo stopped at {counter} ticks.");
+}
+
+@keep fn reset() {
+    running = false;
+    counter = 0;
+    say(f"Demo reset.");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/dce.test.ts

@@ -0,0 +1,129 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { execFileSync } from 'child_process'
+
+import { compile } from '../index'
+
+function getFileContent(files: ReturnType<typeof compile>['files'], suffix: string): string {
+  const file = files.find(candidate => candidate.path.endsWith(suffix))
+  if (!file) {
+    throw new Error(`Missing file: ${suffix}`)
+  }
+  return file.content
+}
+
+describe('AST dead code elimination', () => {
+  it('removes unused functions reachable from entry points', () => {
+    const source = `
+fn unused() { say("never called"); }
+fn used() { say("called"); }
+@tick fn main() { used(); }
+`
+
+    const result = compile(source, { namespace: 'test' })
+
+    expect(result.ast.declarations.map(fn => fn.name)).toEqual(['used', 'main'])
+    expect(result.ir.functions.some(fn => fn.name === 'unused')).toBe(false)
+  })
+
+  it('removes unused local variables from the AST body', () => {
+    const source = `
+fn helper() {
+  let unused: int = 10;
+  let used: int = 20;
+  say_int(used);
+}
+@tick fn main() { helper(); }
+`
+
+    const result = compile(source, { namespace: 'test' })
+    const helper = result.ast.declarations.find(fn => fn.name === 'helper')
+
+    expect(helper?.body.filter(stmt => stmt.kind === 'let')).toHaveLength(1)
+    expect(helper?.body.some(stmt => stmt.kind === 'let' && stmt.name === 'unused')).toBe(false)
+  })
+
+  it('removes unused constants', () => {
+    const source = `
+const UNUSED: int = 10;
+const USED: int = 20;
+
+@tick fn main() {
+  say_int(USED);
+}
+`
+
+    const result = compile(source, { namespace: 'test' })
+
+    expect(result.ast.consts.map(constDecl => constDecl.name)).toEqual(['USED'])
+  })
+
+  it('eliminates dead branches with constant conditions', () => {
+    const source = `
+@tick fn main() {
+  if (false) {
+    say("dead code");
+  } else {
+    say("live code");
+  }
+}
+`
+
+    const result = compile(source, { namespace: 'test' })
+    const output = getFileContent(result.files, 'data/test/function/main.mcfunction')
+
+    expect(output).not.toContain('dead code')
+    expect(output).toContain('live code')
+  })
+
+  it('keeps decorated entry points', () => {
+    const source = `
+@tick fn ticker() { }
+@load fn loader() { }
+@on(PlayerDeath) fn handler(player: Player) { say("event"); }
+`
+
+    const result = compile(source, { namespace: 'test' })
+    const names = result.ast.declarations.map(fn => fn.name)
+
+    expect(names).toContain('ticker')
+    expect(names).toContain('loader')
+    expect(names).toContain('handler')
+  })
+
+  it('can disable AST DCE through the compile API', () => {
+    const source = `
+fn unused() { say("never called"); }
+@tick fn main() { say("live"); }
+`
+
+    const result = compile(source, { namespace: 'test', dce: false })
+
+    expect(result.ast.declarations.map(fn => fn.name)).toEqual(['unused', 'main'])
+    expect(result.ir.functions.some(fn => fn.name === 'unused')).toBe(true)
+  })
+})
+
+describe('CLI --no-dce', () => {
+  it('preserves unused functions when requested', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-dce-cli-'))
+    const inputPath = path.join(tempDir, 'main.mcrs')
+    const outputDir = path.join(tempDir, 'out')
+
+    fs.writeFileSync(inputPath, [
+      'fn unused() { say("keep me"); }',
+      '@tick fn main() { say("live"); }',
+      '',
+    ].join('\n'))
+
+    execFileSync(
+      process.execPath,
+      ['-r', 'ts-node/register', 'src/cli.ts', 'compile', inputPath, '-o', outputDir, '--namespace', 'test', '--no-dce'],
+      { cwd: path.resolve(process.cwd()) }
+    )
+
+    const unusedPath = path.join(outputDir, 'data', 'test', 'function', 'unused.mcfunction')
+    expect(fs.existsSync(unusedPath)).toBe(true)
+  })
+})

package/src/__tests__/lexer.test.ts

@@ -88,6 +88,14 @@ describe('Lexer', () => {
       ])
     })
 
+    it('tokenizes f-strings as a dedicated token', () => {
+      const tokens = tokenize('f"Hello {name}!"')
+      expect(tokens.map(t => [t.kind, t.value])).toEqual([
+        ['f_string', 'Hello {name}!'],
+        ['eof', ''],
+      ])
+    })
+
     it('tokenizes byte literals (b suffix)', () => {
       const tokens = tokenize('20b 0B 127b')
       expect(tokens.map(t => [t.kind, t.value])).toEqual([
@@ -170,8 +178,19 @@ describe('Lexer', () => {
 
   describe('operators', () => {
     it('tokenizes arithmetic operators', () => {
-      const tokens = tokenize('+ - * / % ~ ^')
-      expect(kinds(tokens)).toEqual(['+', '-', '*', '/', '%', '~', '^', 'eof'])
+      const tokens = tokenize('+ - * / %')
+      expect(kinds(tokens)).toEqual(['+', '-', '*', '/', '%', 'eof'])
+    })
+
+    it('tokenizes relative and local coordinates', () => {
+      const tokens = tokenize('~ ~5 ~-3 ^ ^10 ^-2')
+      expect(kinds(tokens)).toEqual(['rel_coord', 'rel_coord', 'rel_coord', 'local_coord', 'local_coord', 'local_coord', 'eof'])
+      expect(tokens[0].value).toBe('~')
+      expect(tokens[1].value).toBe('~5')
+      expect(tokens[2].value).toBe('~-3')
+      expect(tokens[3].value).toBe('^')
+      expect(tokens[4].value).toBe('^10')
+      expect(tokens[5].value).toBe('^-2')
     })
 
     it('tokenizes comparison operators', () => {

package/src/__tests__/lowering.test.ts

@@ -582,6 +582,15 @@ fn choose(dir: Direction) {
       expect(rawCmds).toContain('tellraw @a ["",{"text":"You have "},{"score":{"name":"$score","objective":"rs"}},{"text":" points"}]')
     })
 
+    it('lowers f-string output builtins to tellraw/title JSON components', () => {
+      const ir = compile('fn test() { let score: int = 7; say(f"Score: {score}"); tellraw(@a, f"Score: {score}"); actionbar(@s, f"Score: {score}"); title(@s, f"Score: {score}"); }')
+      const fn = getFunction(ir, 'test')!
+      const rawCmds = getRawCommands(fn)
+      expect(rawCmds).toContain('tellraw @a ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]')
+      expect(rawCmds).toContain('title @s actionbar ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]')
+      expect(rawCmds).toContain('title @s title ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]')
+    })
+
     it('lowers summon()', () => {
       const ir = compile('fn test() { summon("zombie"); }')
       const fn = getFunction(ir, 'test')!

package/src/__tests__/mc-syntax.test.ts

@@ -62,6 +62,20 @@ fn chat() {
     expect(errors).toHaveLength(0)
   })
 
+  test('f-strings generate valid tellraw/title commands', () => {
+    const errors = validateSource(validator, `
+fn chat() {
+    let score: int = 7;
+    say(f"You have {score} points");
+    tellraw(@a, f"Score: {score}");
+    actionbar(@s, f"Score: {score}");
+    title(@s, f"Score: {score}");
+}
+`, 'f-string')
+
+    expect(errors).toHaveLength(0)
+  })
+
   test('array operations generate valid data commands', () => {
     const errors = validateSource(validator, `
 fn arrays() {

package/src/__tests__/parser.test.ts

@@ -481,6 +481,17 @@ impl Point {
       })
     })
 
+    it('parses f-string literal', () => {
+      const expr = parseExpr('f"Score: {x}"')
+      expect(expr).toEqual({
+        kind: 'f_string',
+        parts: [
+          { kind: 'text', value: 'Score: ' },
+          { kind: 'expr', expr: { kind: 'ident', name: 'x' } },
+        ],
+      })
+    })
+
       it('parses boolean literals', () => {
         expect(parseExpr('true')).toEqual({ kind: 'bool_lit', value: true })
         expect(parseExpr('false')).toEqual({ kind: 'bool_lit', value: false })

package/src/__tests__/runtime.test.ts

@@ -97,6 +97,22 @@ fn chat() {
     ])
   })
 
+  it('renders f-strings through tellraw score components', () => {
+    const runtime = loadCompiledProgram(`
+fn chat() {
+    let score: int = 7;
+    say(f"You have {score} points");
+}
+`)
+
+    runtime.load()
+    runtime.execFunction('chat')
+
+    expect(runtime.getChatLog()).toEqual([
+      'You have 7 points',
+    ])
+  })
+
   it('kills only entities matched by a foreach selector', () => {
     const runtime = loadCompiledProgram(`
 fn purge_zombies() {

package/src/__tests__/typechecker.test.ts

@@ -120,6 +120,39 @@ fn test() {
       expect(errors).toHaveLength(0)
     })
 
+    it('allows f-strings in runtime output builtins', () => {
+      const errors = typeCheck(`
+fn test() {
+    let score: int = 5;
+    say(f"Score: {score}");
+    tellraw(@a, f"Score: {score}");
+    actionbar(@s, f"Score: {score}");
+    title(@s, f"Score: {score}");
+}
+`)
+      expect(errors).toHaveLength(0)
+    })
+
+    it('rejects f-strings outside runtime output builtins', () => {
+      const errors = typeCheck(`
+fn test() {
+    let msg: string = f"Score";
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('expected string, got format_string')
+    })
+
+    it('rejects unsupported f-string placeholder types', () => {
+      const errors = typeCheck(`
+fn test() {
+    say(f"Flag: {true}");
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('f-string placeholder must be int or string')
+    })
+
     it('detects too many arguments', () => {
       const errors = typeCheck(`
 fn greet() {

package/src/ast/types.ts

@@ -22,7 +22,7 @@ export interface Span {
 // Type Nodes
 // ---------------------------------------------------------------------------
 
-export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double'
+export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string'
 
 // Entity type hierarchy
 export type EntityTypeName = 
@@ -57,6 +57,16 @@ export interface LambdaExpr {
   body: Expr | Block
 }
 
+export type FStringPart =
+  | { kind: 'text'; value: string }
+  | { kind: 'expr'; expr: Expr }
+
+export interface FStringExpr {
+  kind: 'f_string'
+  parts: FStringPart[]
+  span?: Span
+}
+
 // ---------------------------------------------------------------------------
 // Range Expression
 // ---------------------------------------------------------------------------
@@ -129,10 +139,13 @@ export type Expr =
   | { kind: 'short_lit';  value: number; span?: Span }
   | { kind: 'long_lit';   value: number; span?: Span }
   | { kind: 'double_lit'; value: number; span?: Span }
+  | { kind: 'rel_coord';  value: string; span?: Span }   // ~  ~5  ~-3  (relative coordinate)
+  | { kind: 'local_coord'; value: string; span?: Span }  // ^  ^5  ^-3  (local/facing coordinate)
   | { kind: 'bool_lit';   value: boolean; span?: Span }
   | { kind: 'str_lit';    value: string; span?: Span }
   | { kind: 'mc_name';   value: string; span?: Span }  // #health → "health" (MC identifier)
   | { kind: 'str_interp'; parts: Array<string | Expr>; span?: Span }
+  | FStringExpr
   | { kind: 'range_lit';  range: RangeExpr; span?: Span }
   | (BlockPosExpr & { span?: Span })
   | { kind: 'ident';      name: string; span?: Span }

package/src/cli.ts

@@ -26,7 +26,7 @@ function printUsage(): void {
 RedScript Compiler
 
 Usage:
-  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>]
+  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>] [--no-dce]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
   redscript fmt <file.mcrs> [file2.mcrs ...]
@@ -46,6 +46,7 @@ Options:
   --output-nbt <file>    Output .nbt file path for structure target
   --namespace <ns>       Datapack namespace (default: derived from filename)
   --target <target>      Output target: datapack (default), cmdblock, or structure
+  --no-dce               Disable AST dead code elimination
   --stats                Print optimizer statistics
   --hot-reload <url>     After each successful compile, POST to <url>/reload
                          (use with redscript-testharness; e.g. http://localhost:25561)
@@ -78,8 +79,9 @@ function parseArgs(args: string[]): {
   stats?: boolean
   help?: boolean
   hotReload?: string
+  dce?: boolean
 } {
-  const result: ReturnType<typeof parseArgs> = {}
+  const result: ReturnType<typeof parseArgs> = { dce: true }
   let i = 0
 
   while (i < args.length) {
@@ -103,6 +105,9 @@ function parseArgs(args: string[]): {
     } else if (arg === '--stats') {
       result.stats = true
       i++
+    } else if (arg === '--no-dce') {
+      result.dce = false
+      i++
     } else if (arg === '--hot-reload') {
       result.hotReload = args[++i]
       i++
@@ -153,7 +158,14 @@ function printOptimizationStats(stats: OptimizationStats | undefined): void {
   console.log(`  Total mcfunction commands: ${stats.totalCommandsBefore} -> ${stats.totalCommandsAfter} (${formatReduction(stats.totalCommandsBefore, stats.totalCommandsAfter)} reduction)`)
 }
 
-function compileCommand(file: string, output: string, namespace: string, target: string = 'datapack', showStats = false): void {
+function compileCommand(
+  file: string,
+  output: string,
+  namespace: string,
+  target: string = 'datapack',
+  showStats = false,
+  dce = true
+): void {
   // Read source file
   if (!fs.existsSync(file)) {
     console.error(`Error: File not found: ${file}`)
@@ -164,7 +176,7 @@ function compileCommand(file: string, output: string, namespace: string, target:
 
   try {
     if (target === 'cmdblock') {
-      const result = compile(source, { namespace, filePath: file })
+      const result = compile(source, { namespace, filePath: file, dce })
       printWarnings(result.warnings)
 
       // Generate command block JSON
@@ -184,7 +196,7 @@ function compileCommand(file: string, output: string, namespace: string, target:
         printOptimizationStats(result.stats)
       }
     } else if (target === 'structure') {
-      const structure = compileToStructure(source, namespace, file)
+      const structure = compileToStructure(source, namespace, file, { dce })
       fs.mkdirSync(path.dirname(output), { recursive: true })
       fs.writeFileSync(output, structure.buffer)
 
@@ -195,7 +207,7 @@ function compileCommand(file: string, output: string, namespace: string, target:
         printOptimizationStats(structure.stats)
       }
     } else {
-      const result = compile(source, { namespace, filePath: file })
+      const result = compile(source, { namespace, filePath: file, dce })
       printWarnings(result.warnings)
 
       // Default: generate datapack
@@ -255,7 +267,7 @@ async function hotReload(url: string): Promise<void> {
   }
 }
 
-function watchCommand(dir: string, output: string, namespace?: string, hotReloadUrl?: string): void {
+function watchCommand(dir: string, output: string, namespace?: string, hotReloadUrl?: string, dce = true): void {
   // Check if directory exists
   if (!fs.existsSync(dir)) {
     console.error(`Error: Directory not found: ${dir}`)
@@ -290,7 +302,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
       try {
         source = fs.readFileSync(file, 'utf-8')
         const ns = namespace ?? deriveNamespace(file)
-        const result = compile(source, { namespace: ns, filePath: file })
+        const result = compile(source, { namespace: ns, filePath: file, dce })
         printWarnings(result.warnings)
 
         // Create output directory
@@ -382,7 +394,8 @@ async function main(): Promise<void> {
         output,
         namespace,
         target,
-        parsed.stats
+        parsed.stats,
+        parsed.dce
       )
       }
       break
@@ -397,7 +410,8 @@ async function main(): Promise<void> {
         parsed.file,
         parsed.output ?? './dist',
         parsed.namespace,
-        parsed.hotReload
+        parsed.hotReload,
+        parsed.dce
       )
       break
 

package/src/codegen/structure/index.ts

@@ -5,6 +5,7 @@ import { nbt, TagType, writeNbt, type CompoundTag, type NbtTag } from '../../nbt
 import { createEmptyOptimizationStats, mergeOptimizationStats, type OptimizationStats } from '../../optimizer/commands'
 import { optimizeWithStats } from '../../optimizer/passes'
 import { optimizeForStructure, optimizeForStructureWithStats } from '../../optimizer/structure'
+import { eliminateDeadCode } from '../../optimizer/dce'
 import { preprocessSource } from '../../compile'
 import type { IRCommand, IRFunction, IRModule } from '../../ir/types'
 import type { DatapackFile } from '../mcfunction'
@@ -51,6 +52,10 @@ export interface StructureCompileResult {
   stats?: OptimizationStats
 }
 
+export interface StructureCompileOptions {
+  dce?: boolean
+}
+
 function escapeJsonString(value: string): string {
   return JSON.stringify(value).slice(1, -1)
 }
@@ -315,10 +320,16 @@ export function generateStructure(input: IRModule | DatapackFile[]): StructureCo
   }
 }
 
-export function compileToStructure(source: string, namespace: string, filePath?: string): StructureCompileResult {
+export function compileToStructure(
+  source: string,
+  namespace: string,
+  filePath?: string,
+  options: StructureCompileOptions = {}
+): StructureCompileResult {
   const preprocessedSource = preprocessSource(source, { filePath })
   const tokens = new Lexer(preprocessedSource, filePath).tokenize()
-  const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const ast = options.dce ?? true ? eliminateDeadCode(parsedAst) : parsedAst
   const ir = new Lowering(namespace).lower(ast)
   const stats = createEmptyOptimizationStats()
   const optimizedIRFunctions = ir.functions.map(fn => {

package/src/compile.ts

@@ -11,6 +11,7 @@ import { Lexer } from './lexer'
 import { Parser } from './parser'
 import { Lowering } from './lowering'
 import { optimize } from './optimizer/passes'
+import { eliminateDeadCode } from './optimizer/dce'
 import { generateDatapackWithStats, DatapackFile } from './codegen/mcfunction'
 import { DiagnosticError, formatError, parseErrorMessage } from './diagnostics'
 import type { IRModule } from './ir/types'
@@ -24,6 +25,7 @@ export interface CompileOptions {
   namespace?: string
   filePath?: string
   optimize?: boolean
+  dce?: boolean
 }
 
 // ---------------------------------------------------------------------------
@@ -160,6 +162,7 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
 
 export function compile(source: string, options: CompileOptions = {}): CompileResult {
   const { namespace = 'redscript', filePath, optimize: shouldOptimize = true } = options
+  const shouldRunDce = options.dce ?? shouldOptimize
   let sourceLines = source.split('\n')
 
   try {
@@ -171,7 +174,8 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     const tokens = new Lexer(preprocessedSource, filePath).tokenize()
 
     // Parsing
-    const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+    const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+    const ast = shouldRunDce ? eliminateDeadCode(parsedAst) : parsedAst
 
     // Lowering
     const ir = new Lowering(namespace, preprocessed.ranges).lower(ast)

package/src/index.ts

@@ -14,6 +14,7 @@ import {
   copyPropagation,
   deadCodeEliminationWithStats,
 } from './optimizer/passes'
+import { eliminateDeadCode } from './optimizer/dce'
 import {
   countMcfunctionCommands,
   generateDatapackWithStats,
@@ -30,6 +31,7 @@ export interface CompileOptions {
   optimize?: boolean
   typeCheck?: boolean
   filePath?: string
+  dce?: boolean
 }
 
 export interface CompileResult {
@@ -53,6 +55,7 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
   const namespace = options.namespace ?? 'redscript'
   const shouldOptimize = options.optimize ?? true
   const shouldTypeCheck = options.typeCheck ?? true
+  const shouldRunDce = options.dce ?? shouldOptimize
   const filePath = options.filePath
   const preprocessed = preprocessSourceWithMetadata(source, { filePath })
   const preprocessedSource = preprocessed.source
@@ -61,7 +64,8 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
   const tokens = new Lexer(preprocessedSource, filePath).tokenize()
 
   // Parsing
-  const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const ast = shouldRunDce ? eliminateDeadCode(parsedAst) : parsedAst
 
   // Type checking (warn mode - collect errors but don't block)
   let typeErrors: DiagnosticError[] | undefined