redscript-mc 1.1.0 → 1.2.1

package/dist/__tests__/typechecker.test.js

@@ -110,6 +110,36 @@ 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() {
@@ -193,6 +223,137 @@ fn test() {
 `);
             expect(errors).toHaveLength(0);
         });
+        it('type checks timer builtins with void callbacks and interval IDs', () => {
+            const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => {
+        say("later");
+    });
+    let intervalId: int = setInterval(20, () => {
+        say("tick");
+    });
+    clearInterval(intervalId);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects timer callbacks with the wrong return type', () => {
+            const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => 1);
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('Return type mismatch: expected void, got int');
+        });
+        it('allows impl instance methods with inferred self type', () => {
+            const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+
+fn test() {
+  let timer: Timer = { duration: 10 };
+  let value: int = timer.elapsed();
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('records then-branch entity narrowing for is-checks', () => {
+            const source = `
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(e);
+        }
+    }
+}
+`;
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const ast = new parser_1.Parser(tokens).parse('test');
+            const checker = new typechecker_1.TypeChecker(source);
+            checker.check(ast);
+            const foreachStmt = ast.declarations[0].body[0];
+            const ifStmt = foreachStmt.body[0];
+            expect(checker.getThenBranchNarrowing(ifStmt.cond)).toEqual({
+                name: 'e',
+                type: { kind: 'entity', entityType: 'Player' },
+                mutable: false,
+            });
+        });
+        it('allows static impl method calls', () => {
+            const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int) -> Timer {
+    return { duration: duration };
+  }
+}
+
+fn test() {
+  let timer: Timer = Timer::new(10);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects using is-checks on non-entity values', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {
+        say("nope");
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'is' checks require an entity expression, got int");
+        });
+        it('rejects calling instance impl methods as static methods', () => {
+            const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+
+fn test() {
+  let total: int = Point::distance();
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Method 'Point::distance' is an instance method");
+        });
+    });
+    describe('entity is-check narrowing', () => {
+        it('allows entity type checks on foreach bindings', () => {
+            const errors = typeCheck(`
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(@s);
+        }
+    }
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects is-checks on non-entity expressions', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {}
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'is' checks require an entity expression");
+        });
     });
     describe('return type checking', () => {
         it('allows matching return type', () => {
@@ -360,5 +521,32 @@ fn broken() -> int {
             expect(errors.length).toBeGreaterThanOrEqual(3);
         });
     });
+    describe('event handlers', () => {
+        it('accepts matching @on event signatures', () => {
+            const errors = typeCheck(`
+@on(PlayerDeath)
+fn handle_death(player: Player) {
+    tp(player, @p);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects unknown event types', () => {
+            const errors = typeCheck(`
+@on(NotARealEvent)
+fn handle(player: Player) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Unknown event type 'NotARealEvent'");
+        });
+        it('rejects mismatched event signatures', () => {
+            const errors = typeCheck(`
+@on(BlockBreak)
+fn handle_break(player: Player) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('must declare 2 parameter(s)');
+        });
+    });
 });
 //# sourceMappingURL=typechecker.test.js.map

package/dist/ast/types.d.ts

@@ -11,7 +11,8 @@ export interface Span {
     endLine?: number;
     endCol?: number;
 }
-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';
+export type EntityTypeName = 'entity' | 'Player' | 'Mob' | 'HostileMob' | 'PassiveMob' | 'Zombie' | 'Skeleton' | 'Creeper' | 'Spider' | 'Enderman' | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager' | 'ArmorStand' | 'Item' | 'Arrow';
 export type TypeNode = {
     kind: 'named';
     name: PrimitiveType;
@@ -28,6 +29,11 @@ export type TypeNode = {
     kind: 'function_type';
     params: TypeNode[];
     return: TypeNode;
+} | {
+    kind: 'entity';
+    entityType: EntityTypeName;
+} | {
+    kind: 'selector';
 };
 export interface LambdaParam {
     name: string;
@@ -39,6 +45,18 @@ export interface LambdaExpr {
     returnType?: TypeNode;
     body: Expr | Block;
 }
+export type FStringPart = {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'expr';
+    expr: Expr;
+};
+export interface FStringExpr {
+    kind: 'f_string';
+    parts: FStringPart[];
+    span?: Span;
+}
 export interface RangeExpr {
     min?: number;
     max?: number;
@@ -105,6 +123,14 @@ export type Expr = {
     kind: 'double_lit';
     value: number;
     span?: Span;
+} | {
+    kind: 'rel_coord';
+    value: string;
+    span?: Span;
+} | {
+    kind: 'local_coord';
+    value: string;
+    span?: Span;
 } | {
     kind: 'bool_lit';
     value: boolean;
@@ -121,7 +147,7 @@ export type Expr = {
     kind: 'str_interp';
     parts: Array<string | Expr>;
     span?: Span;
-} | {
+} | FStringExpr | {
     kind: 'range_lit';
     range: RangeExpr;
     span?: Span;
@@ -143,6 +169,11 @@ export type Expr = {
     left: Expr;
     right: Expr;
     span?: Span;
+} | {
+    kind: 'is_check';
+    expr: Expr;
+    entityType: EntityTypeName;
+    span?: Span;
 } | {
     kind: 'unary';
     op: '!' | '-';
@@ -311,9 +342,10 @@ export type Stmt = {
 };
 export type Block = Stmt[];
 export interface Decorator {
-    name: 'tick' | 'load' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team';
+    name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team';
     args?: {
         rate?: number;
+        eventType?: string;
         trigger?: string;
         advancement?: string;
         item?: string;
@@ -342,6 +374,12 @@ export interface StructDecl {
     fields: StructField[];
     span?: Span;
 }
+export interface ImplBlock {
+    kind: 'impl_block';
+    typeName: string;
+    methods: FnDecl[];
+    span?: Span;
+}
 export interface EnumVariant {
     name: string;
     value?: number;
@@ -370,6 +408,7 @@ export interface Program {
     globals: GlobalDecl[];
     declarations: FnDecl[];
     structs: StructDecl[];
+    implBlocks: ImplBlock[];
     enums: EnumDecl[];
     consts: ConstDecl[];
 }

package/dist/cli.js

@@ -57,7 +57,7 @@ function printUsage() {
 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 ...]
@@ -77,6 +77,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)
@@ -99,7 +100,7 @@ function printVersion() {
     }
 }
 function parseArgs(args) {
-    const result = {};
+    const result = { dce: true };
     let i = 0;
     while (i < args.length) {
         const arg = args[i];
@@ -127,6 +128,10 @@ function parseArgs(args) {
             result.stats = true;
             i++;
         }
+        else if (arg === '--no-dce') {
+            result.dce = false;
+            i++;
+        }
         else if (arg === '--hot-reload') {
             result.hotReload = args[++i];
             i++;
@@ -174,7 +179,7 @@ function printOptimizationStats(stats) {
     console.log(`  constant folding: ${stats.constantFolds} constants folded`);
     console.log(`  Total mcfunction commands: ${stats.totalCommandsBefore} -> ${stats.totalCommandsAfter} (${formatReduction(stats.totalCommandsBefore, stats.totalCommandsAfter)} reduction)`);
 }
-function compileCommand(file, output, namespace, target = 'datapack', showStats = false) {
+function compileCommand(file, output, namespace, target = 'datapack', showStats = false, dce = true) {
     // Read source file
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
@@ -183,7 +188,7 @@ function compileCommand(file, output, namespace, target = 'datapack', showStats
     const source = fs.readFileSync(file, 'utf-8');
     try {
         if (target === 'cmdblock') {
-            const result = (0, index_1.compile)(source, { namespace, filePath: file });
+            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce });
             printWarnings(result.warnings);
             // Generate command block JSON
             const hasTick = result.files.some(f => f.path.includes('__tick.mcfunction'));
@@ -201,7 +206,7 @@ function compileCommand(file, output, namespace, target = 'datapack', showStats
             }
         }
         else if (target === 'structure') {
-            const structure = (0, structure_1.compileToStructure)(source, namespace, file);
+            const structure = (0, structure_1.compileToStructure)(source, namespace, file, { dce });
             fs.mkdirSync(path.dirname(output), { recursive: true });
             fs.writeFileSync(output, structure.buffer);
             console.log(`✓ Generated structure for ${file}`);
@@ -212,7 +217,7 @@ function compileCommand(file, output, namespace, target = 'datapack', showStats
             }
         }
         else {
-            const result = (0, index_1.compile)(source, { namespace, filePath: file });
+            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce });
             printWarnings(result.warnings);
             // Default: generate datapack
             // Create output directory
@@ -266,7 +271,7 @@ async function hotReload(url) {
         console.warn(`⚠  Hot reload failed (is the server running?): ${e.message}`);
     }
 }
-function watchCommand(dir, output, namespace, hotReloadUrl) {
+function watchCommand(dir, output, namespace, hotReloadUrl, dce = true) {
     // Check if directory exists
     if (!fs.existsSync(dir)) {
         console.error(`Error: Directory not found: ${dir}`);
@@ -297,7 +302,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
             try {
                 source = fs.readFileSync(file, 'utf-8');
                 const ns = namespace ?? deriveNamespace(file);
-                const result = (0, index_1.compile)(source, { namespace: ns, filePath: file });
+                const result = (0, index_1.compile)(source, { namespace: ns, filePath: file, dce });
                 printWarnings(result.warnings);
                 // Create output directory
                 fs.mkdirSync(output, { recursive: true });
@@ -374,7 +379,7 @@ async function main() {
                 const output = target === 'structure'
                     ? (parsed.outputNbt ?? parsed.output ?? `./${namespace}.nbt`)
                     : (parsed.output ?? './dist');
-                compileCommand(parsed.file, output, namespace, target, parsed.stats);
+                compileCommand(parsed.file, output, namespace, target, parsed.stats, parsed.dce);
             }
             break;
         case 'watch':
@@ -383,7 +388,7 @@ async function main() {
                 printUsage();
                 process.exit(1);
             }
-            watchCommand(parsed.file, parsed.output ?? './dist', parsed.namespace, parsed.hotReload);
+            watchCommand(parsed.file, parsed.output ?? './dist', parsed.namespace, parsed.hotReload, parsed.dce);
             break;
         case 'check':
             if (!parsed.file) {

package/dist/codegen/mcfunction/index.js

@@ -21,6 +21,7 @@ exports.countMcfunctionCommands = countMcfunctionCommands;
 exports.generateDatapackWithStats = generateDatapackWithStats;
 exports.generateDatapack = generateDatapack;
 const commands_1 = require("../../optimizer/commands");
+const types_1 = require("../../events/types");
 // ---------------------------------------------------------------------------
 // Utilities
 // ---------------------------------------------------------------------------
@@ -238,6 +239,8 @@ function generateDatapackWithStats(module, options = {}) {
     // Collect all trigger handlers
     const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
     const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
+    const eventHandlers = module.functions.filter((fn) => !!fn.eventHandler && (0, types_1.isEventTypeName)(fn.eventHandler.eventType));
+    const eventTypes = new Set(eventHandlers.map(fn => fn.eventHandler.eventType));
     // Collect all tick functions
     const tickFunctionNames = [];
     for (const fn of module.functions) {
@@ -265,6 +268,21 @@ function generateDatapackWithStats(module, options = {}) {
         loadLines.push(`scoreboard objectives add ${triggerName} trigger`);
         loadLines.push(`scoreboard players enable @a ${triggerName}`);
     }
+    for (const eventType of eventTypes) {
+        const detection = types_1.EVENT_TYPES[eventType].detection;
+        if (eventType === 'PlayerDeath') {
+            loadLines.push('scoreboard objectives add rs.deaths deathCount');
+        }
+        else if (eventType === 'EntityKill') {
+            loadLines.push('scoreboard objectives add rs.kills totalKillCount');
+        }
+        else if (eventType === 'ItemUse') {
+            loadLines.push('# ItemUse detection requires a project-specific objective/tag setup');
+        }
+        else if (detection === 'tag' || detection === 'advancement') {
+            loadLines.push(`# ${eventType} detection expects tag ${types_1.EVENT_TYPES[eventType].tag} to be set externally`);
+        }
+    }
     // Generate trigger dispatch functions
     for (const triggerName of triggerNames) {
         const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName);
@@ -339,8 +357,19 @@ function generateDatapackWithStats(module, options = {}) {
             tickLines.push(`execute as @a[scores={${triggerName}=1..}] run function ${ns}:__trigger_${triggerName}_dispatch`);
         }
     }
+    if (eventHandlers.length > 0) {
+        tickLines.push('# Event checks');
+        for (const eventType of eventTypes) {
+            const tag = types_1.EVENT_TYPES[eventType].tag;
+            const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType);
+            for (const handler of handlers) {
+                tickLines.push(`execute as @a[tag=${tag}] run function ${ns}:${handler.name}`);
+            }
+            tickLines.push(`tag @a[tag=${tag}] remove ${tag}`);
+        }
+    }
     // Only generate __tick if there's something to run
-    if (tickFunctionNames.length > 0 || triggerNames.size > 0) {
+    if (tickFunctionNames.length > 0 || triggerNames.size > 0 || eventHandlers.length > 0) {
         files.push({
             path: `data/${ns}/function/__tick.mcfunction`,
             content: tickLines.join('\n'),

package/dist/codegen/structure/index.d.ts

@@ -14,5 +14,8 @@ export interface StructureCompileResult {
     blocks: StructureBlockInfo[];
     stats?: OptimizationStats;
 }
+export interface StructureCompileOptions {
+    dce?: boolean;
+}
 export declare function generateStructure(input: IRModule | DatapackFile[]): StructureCompileResult;
-export declare function compileToStructure(source: string, namespace: string, filePath?: string): StructureCompileResult;
+export declare function compileToStructure(source: string, namespace: string, filePath?: string, options?: StructureCompileOptions): StructureCompileResult;

package/dist/codegen/structure/index.js

@@ -9,7 +9,9 @@ const nbt_1 = require("../../nbt");
 const commands_1 = require("../../optimizer/commands");
 const passes_1 = require("../../optimizer/passes");
 const structure_1 = require("../../optimizer/structure");
+const dce_1 = require("../../optimizer/dce");
 const compile_1 = require("../../compile");
+const types_1 = require("../../events/types");
 const DATA_VERSION = 3953;
 const MAX_WIDTH = 16;
 const OBJ = 'rs';
@@ -62,6 +64,8 @@ function collectCommandEntriesFromModule(module) {
     const entries = [];
     const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
     const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
+    const eventHandlers = module.functions.filter((fn) => !!fn.eventHandler && (0, types_1.isEventTypeName)(fn.eventHandler.eventType));
+    const eventTypes = new Set(eventHandlers.map(fn => fn.eventHandler.eventType));
     const loadCommands = [
         `scoreboard objectives add ${OBJ} dummy`,
         ...module.globals.map(g => `scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`),
@@ -71,6 +75,14 @@ function collectCommandEntriesFromModule(module) {
         ]),
         ...Array.from(new Set(module.functions.flatMap(fn => Array.from(collectConsts(fn))))).map(constSetup),
     ];
+    for (const eventType of eventTypes) {
+        if (eventType === 'PlayerDeath') {
+            loadCommands.push('scoreboard objectives add rs.deaths deathCount');
+        }
+        else if (eventType === 'EntityKill') {
+            loadCommands.push('scoreboard objectives add rs.kills totalKillCount');
+        }
+    }
     // Call @load functions from __load
     for (const fn of module.functions) {
         if (fn.isLoadInit) {
@@ -114,6 +126,20 @@ function collectCommandEntriesFromModule(module) {
             });
         }
     }
+    if (eventHandlers.length > 0) {
+        for (const eventType of eventTypes) {
+            const tag = types_1.EVENT_TYPES[eventType].tag;
+            const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType);
+            for (const handler of handlers) {
+                tickCommands.push({
+                    cmd: `execute as @a[tag=${tag}] run function ${module.namespace}:${handler.name}`,
+                });
+            }
+            tickCommands.push({
+                cmd: `tag @a[tag=${tag}] remove ${tag}`,
+            });
+        }
+    }
     if (tickCommands.length > 0) {
         sections.push({
             name: '__tick',
@@ -230,10 +256,11 @@ function generateStructure(input) {
         })),
     };
 }
-function compileToStructure(source, namespace, filePath) {
+function compileToStructure(source, namespace, filePath, options = {}) {
     const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
     const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
-    const ast = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+    const parsedAst = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+    const ast = options.dce ?? true ? (0, dce_1.eliminateDeadCode)(parsedAst) : parsedAst;
     const ir = new lowering_1.Lowering(namespace).lower(ast);
     const stats = (0, commands_1.createEmptyOptimizationStats)();
     const optimizedIRFunctions = ir.functions.map(fn => {

package/dist/compile.d.ts

@@ -11,6 +11,7 @@ export interface CompileOptions {
     namespace?: string;
     filePath?: string;
     optimize?: boolean;
+    dce?: boolean;
 }
 export interface CompileResult {
     success: boolean;
@@ -20,10 +21,20 @@ export interface CompileResult {
     ir?: IRModule;
     error?: DiagnosticError;
 }
+export interface SourceRange {
+    startLine: number;
+    endLine: number;
+    filePath: string;
+}
+export interface PreprocessedSource {
+    source: string;
+    ranges: SourceRange[];
+}
 interface PreprocessOptions {
     filePath?: string;
     seen?: Set<string>;
 }
+export declare function preprocessSourceWithMetadata(source: string, options?: PreprocessOptions): PreprocessedSource;
 export declare function preprocessSource(source: string, options?: PreprocessOptions): string;
 export declare function compile(source: string, options?: CompileOptions): CompileResult;
 export declare function formatCompileError(result: CompileResult): string;

package/dist/compile.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessSourceWithMetadata = preprocessSourceWithMetadata;
 exports.preprocessSource = preprocessSource;
 exports.compile = compile;
 exports.formatCompileError = formatCompileError;
@@ -47,10 +48,21 @@ const lexer_1 = require("./lexer");
 const parser_1 = require("./parser");
 const lowering_1 = require("./lowering");
 const passes_1 = require("./optimizer/passes");
+const dce_1 = require("./optimizer/dce");
 const mcfunction_1 = require("./codegen/mcfunction");
 const diagnostics_1 = require("./diagnostics");
 const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/;
-function preprocessSource(source, options = {}) {
+function countLines(source) {
+    return source === '' ? 0 : source.split('\n').length;
+}
+function offsetRanges(ranges, lineOffset) {
+    return ranges.map(range => ({
+        startLine: range.startLine + lineOffset,
+        endLine: range.endLine + lineOffset,
+        filePath: range.filePath,
+    }));
+}
+function preprocessSourceWithMetadata(source, options = {}) {
     const { filePath } = options;
     const seen = options.seen ?? new Set();
     if (filePath) {
@@ -78,7 +90,7 @@ function preprocessSource(source, options = {}) {
                 catch {
                     throw new diagnostics_1.DiagnosticError('ParseError', `Cannot import '${match[1]}'`, { file: filePath, line: i + 1, col: 1 }, lines);
                 }
-                imports.push(preprocessSource(importedSource, { filePath: importPath, seen }));
+                imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }));
             }
             continue;
         }
@@ -89,23 +101,45 @@ function preprocessSource(source, options = {}) {
         parsingHeader = false;
         bodyLines.push(line);
     }
-    return [...imports, bodyLines.join('\n')].filter(Boolean).join('\n');
+    const body = bodyLines.join('\n');
+    const parts = [...imports.map(entry => entry.source), body].filter(Boolean);
+    const combined = parts.join('\n');
+    const ranges = [];
+    let lineOffset = 0;
+    for (const entry of imports) {
+        ranges.push(...offsetRanges(entry.ranges, lineOffset));
+        lineOffset += countLines(entry.source);
+    }
+    if (filePath && body) {
+        ranges.push({
+            startLine: lineOffset + 1,
+            endLine: lineOffset + countLines(body),
+            filePath: path.resolve(filePath),
+        });
+    }
+    return { source: combined, ranges };
+}
+function preprocessSource(source, options = {}) {
+    return preprocessSourceWithMetadata(source, options).source;
 }
 // ---------------------------------------------------------------------------
 // Main Compile Function
 // ---------------------------------------------------------------------------
 function compile(source, options = {}) {
     const { namespace = 'redscript', filePath, optimize: shouldOptimize = true } = options;
+    const shouldRunDce = options.dce ?? shouldOptimize;
     let sourceLines = source.split('\n');
     try {
-        const preprocessedSource = preprocessSource(source, { filePath });
+        const preprocessed = preprocessSourceWithMetadata(source, { filePath });
+        const preprocessedSource = preprocessed.source;
         sourceLines = preprocessedSource.split('\n');
         // Lexing
         const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
         // Parsing
-        const ast = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+        const parsedAst = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+        const ast = shouldRunDce ? (0, dce_1.eliminateDeadCode)(parsedAst) : parsedAst;
         // Lowering
-        const ir = new lowering_1.Lowering(namespace).lower(ast);
+        const ir = new lowering_1.Lowering(namespace, preprocessed.ranges).lower(ast);
         // Optimization
         const optimized = shouldOptimize
             ? { ...ir, functions: ir.functions.map(fn => (0, passes_1.optimize)(fn)) }