redscript-mc 1.2.21 → 1.2.25

package/.github/workflows/publish-extension-on-ci.yml

@@ -0,0 +1,100 @@
+name: Publish VSCode Extension (Auto)
+
+# Triggers when the CI workflow completes successfully on main
+on:
+  workflow_run:
+    workflows: ["CI"]
+    types: [completed]
+    branches: [main]
+
+jobs:
+  publish:
+    # Only run if CI passed
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Need full history to detect changes and push version bump
+          fetch-depth: 0
+          token: ${{ secrets.IDE_DISPATCH_TOKEN }}
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+
+      - name: Install root dependencies
+        run: npm install
+
+      - name: Build compiler
+        run: npm run build
+
+      - name: Install extension dependencies
+        working-directory: editors/vscode
+        run: npm install
+
+      - name: Check if extension needs update
+        id: check
+        run: |
+          # Get last commit that changed the extension publish workflow or core compiler
+          LAST_EXT_PUBLISH=$(git log --oneline --follow -- .github/workflows/publish-extension-on-ci.yml editors/vscode/ | head -1 | awk '{print $1}')
+          CORE_CHANGED=$(git diff --name-only HEAD~1 HEAD -- src/ package.json | head -1)
+          EXT_CHANGED=$(git diff --name-only HEAD~1 HEAD -- editors/vscode/ | head -1)
+          echo "core_changed=${CORE_CHANGED}" >> $GITHUB_OUTPUT
+          echo "ext_changed=${EXT_CHANGED}" >> $GITHUB_OUTPUT
+          if [ -n "$CORE_CHANGED" ] || [ -n "$EXT_CHANGED" ]; then
+            echo "should_publish=true" >> $GITHUB_OUTPUT
+          else
+            echo "should_publish=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Bump extension version and commit first
+        if: steps.check.outputs.should_publish == 'true'
+        run: |
+          cd editors/vscode
+          npm version patch --no-git-tag-version
+          NEW_VER=$(node -p "require('./package.json').version")
+          echo "new_version=${NEW_VER}" >> $GITHUB_OUTPUT
+          cd ../..
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add editors/vscode/package.json editors/vscode/package-lock.json
+          git commit -m "chore: auto-bump vscode extension to ${NEW_VER} [skip ci]" || echo "Nothing to commit"
+          git pull --rebase origin main || true
+          git push
+        id: bump
+
+      - name: Publish npm package (redscript-mc)
+        if: steps.check.outputs.should_publish == 'true'
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          # Check if this version is already published
+          PKG_VER=$(node -p "require('./package.json').version")
+          if npm view "redscript-mc@${PKG_VER}" version &>/dev/null 2>&1; then
+            echo "⏭️  redscript-mc@${PKG_VER} already on npm, skipping"
+          else
+            echo "//registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}" >> ~/.npmrc
+            npm publish --access public
+            echo "✅ Published redscript-mc@${PKG_VER}"
+          fi
+
+      - name: Build and publish extension
+        if: steps.check.outputs.should_publish == 'true'
+        working-directory: editors/vscode
+        env:
+          VSCE_PAT: ${{ secrets.VSCE_PAT }}
+        run: npm run publish -- -p "$VSCE_PAT"
+
+      - name: Trigger IDE rebuild
+        if: steps.check.outputs.should_publish == 'true'
+        env:
+          GH_TOKEN: ${{ secrets.IDE_DISPATCH_TOKEN }}
+        run: |
+          gh api repos/bkmashiro/redscript-ide/dispatches \
+            -f event_type=redscript-updated \
+            -f client_payload[version]="${{ github.sha }}"

package/dist/__tests__/entity-types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/entity-types.test.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_hierarchy_1 = require("../types/entity-hierarchy");
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lowering_1 = require("../lowering");
+function compileWithWarnings(source, namespace = 'test') {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse(namespace);
+    const lowering = new lowering_1.Lowering(namespace);
+    return { ir: lowering.lower(ast), warnings: lowering.warnings };
+}
+// ---------------------------------------------------------------------------
+// Entity hierarchy utilities
+// ---------------------------------------------------------------------------
+describe('Entity type hierarchy', () => {
+    test('isSubtype: Zombie is a subtype of Mob', () => {
+        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Mob')).toBe(true);
+    });
+    test('isSubtype: Player is NOT a subtype of Mob', () => {
+        expect((0, entity_hierarchy_1.isSubtype)('Player', 'Mob')).toBe(false);
+    });
+    test('isSubtype: Zombie is a subtype of Entity (transitive)', () => {
+        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Entity')).toBe(true);
+    });
+    test('isSubtype: identity — Zombie is subtype of Zombie', () => {
+        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Zombie')).toBe(true);
+    });
+    test('areCompatibleTypes: Player and Zombie are NOT compatible', () => {
+        expect((0, entity_hierarchy_1.areCompatibleTypes)('Player', 'Zombie')).toBe(false);
+    });
+    test('areCompatibleTypes: Zombie and Mob are compatible', () => {
+        expect((0, entity_hierarchy_1.areCompatibleTypes)('Zombie', 'Mob')).toBe(true);
+    });
+    test('areCompatibleTypes: Mob and Zombie are compatible (reverse)', () => {
+        expect((0, entity_hierarchy_1.areCompatibleTypes)('Mob', 'Zombie')).toBe(true);
+    });
+    test('getConcreteSubtypes: HostileMob includes Zombie, Skeleton, Creeper', () => {
+        const subtypes = (0, entity_hierarchy_1.getConcreteSubtypes)('HostileMob');
+        const names = subtypes.map(n => n.name);
+        expect(names).toContain('Zombie');
+        expect(names).toContain('Skeleton');
+        expect(names).toContain('Creeper');
+        expect(names).toContain('Blaze');
+        expect(names).toContain('CaveSpider');
+        // Should NOT include passive mobs
+        expect(names).not.toContain('Pig');
+        expect(names).not.toContain('Player');
+    });
+    test('getConcreteSubtypes: PassiveMob includes Pig, Cow, Villager', () => {
+        const subtypes = (0, entity_hierarchy_1.getConcreteSubtypes)('PassiveMob');
+        const names = subtypes.map(n => n.name);
+        expect(names).toContain('Pig');
+        expect(names).toContain('Cow');
+        expect(names).toContain('Villager');
+        expect(names).toContain('WanderingTrader');
+        expect(names).not.toContain('Zombie');
+    });
+    test('getSelectorEntityType: parses type=zombie', () => {
+        expect((0, entity_hierarchy_1.getSelectorEntityType)('@e[type=zombie]')).toBe('Zombie');
+    });
+    test('getSelectorEntityType: parses type=minecraft:skeleton', () => {
+        expect((0, entity_hierarchy_1.getSelectorEntityType)('@e[type=minecraft:skeleton]')).toBe('Skeleton');
+    });
+    test('getBaseSelectorType: @a → Player', () => {
+        expect((0, entity_hierarchy_1.getBaseSelectorType)('@a')).toBe('Player');
+    });
+    test('getBaseSelectorType: @e → Entity', () => {
+        expect((0, entity_hierarchy_1.getBaseSelectorType)('@e')).toBe('Entity');
+    });
+    test('getBaseSelectorType: @e[type=zombie] → Zombie', () => {
+        expect((0, entity_hierarchy_1.getBaseSelectorType)('@e[type=zombie]')).toBe('Zombie');
+    });
+    test('getBaseSelectorType: @s → null', () => {
+        expect((0, entity_hierarchy_1.getBaseSelectorType)('@s')).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// W_IMPOSSIBLE_AS warning
+// ---------------------------------------------------------------------------
+describe('W_IMPOSSIBLE_AS warning', () => {
+    test('foreach @a with as @e[type=zombie] produces warning', () => {
+        const source = `
+      fn main() {
+        foreach (p in @a) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { warnings } = compileWithWarnings(source);
+        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
+        expect(impossible.length).toBe(1);
+        expect(impossible[0].message).toContain('Player');
+        expect(impossible[0].message).toContain('Zombie');
+    });
+    test('foreach @e[type=zombie] with as @e[type=zombie] produces NO warning', () => {
+        const source = `
+      fn main() {
+        foreach (z in @e[type=minecraft:zombie]) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { warnings } = compileWithWarnings(source);
+        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
+        expect(impossible.length).toBe(0);
+    });
+    test('foreach @e (generic) with as @e[type=zombie] produces NO warning', () => {
+        const source = `
+      fn main() {
+        foreach (e in @e) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { warnings } = compileWithWarnings(source);
+        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
+        expect(impossible.length).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// is_check with abstract types
+// ---------------------------------------------------------------------------
+describe('is_check compilation', () => {
+    test('concrete is_check emits single execute if entity', () => {
+        const source = `
+      fn main() {
+        foreach (e in @e) {
+          if (e is Zombie) {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { ir } = compileWithWarnings(source);
+        const thenFn = ir.functions.find(f => f.name.includes('then_'));
+        expect(thenFn).toBeDefined();
+        // The parent foreach function should contain the execute if entity command
+        const foreachFn = ir.functions.find(f => f.name.includes('foreach_'));
+        expect(foreachFn).toBeDefined();
+        const rawCmds = foreachFn.blocks.flatMap(b => b.instrs)
+            .filter((i) => i.op === 'raw')
+            .map(i => i.cmd);
+        expect(rawCmds.some(c => c.includes('type=minecraft:zombie'))).toBe(true);
+    });
+    test('abstract is_check (HostileMob) emits multiple type checks', () => {
+        const source = `
+      fn main() {
+        foreach (e in @e) {
+          if (e is HostileMob) {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { ir } = compileWithWarnings(source);
+        const foreachFn = ir.functions.find(f => f.name.includes('foreach_'));
+        expect(foreachFn).toBeDefined();
+        const rawCmds = foreachFn.blocks.flatMap(b => b.instrs)
+            .filter((i) => i.op === 'raw')
+            .map(i => i.cmd);
+        // Should have scoreboard setup and multiple type checks
+        expect(rawCmds.some(c => c.includes('scoreboard players set __is_result rs:temp 0'))).toBe(true);
+        expect(rawCmds.some(c => c.includes('type=minecraft:zombie'))).toBe(true);
+        expect(rawCmds.some(c => c.includes('type=minecraft:skeleton'))).toBe(true);
+        expect(rawCmds.some(c => c.includes('type=minecraft:creeper'))).toBe(true);
+        expect(rawCmds.some(c => c.includes('if score __is_result rs:temp matches 1'))).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// selector<T> type annotation
+// ---------------------------------------------------------------------------
+describe('selector<T> type annotation', () => {
+    test('parses selector<Player> type', () => {
+        const source = `
+      fn greet(target: selector<Player>) {
+        say("hello");
+      }
+    `;
+        const tokens = new lexer_1.Lexer(source).tokenize();
+        const ast = new parser_1.Parser(tokens).parse('test');
+        const fn = ast.declarations[0];
+        expect(fn.params[0].type).toEqual({ kind: 'selector', entityType: 'Player' });
+    });
+    test('parses plain selector type', () => {
+        const source = `
+      fn greet(target: selector) {
+        say("hello");
+      }
+    `;
+        const tokens = new lexer_1.Lexer(source).tokenize();
+        const ast = new parser_1.Parser(tokens).parse('test');
+        const fn = ast.declarations[0];
+        expect(fn.params[0].type).toEqual({ kind: 'selector' });
+    });
+});
+//# sourceMappingURL=entity-types.test.js.map

package/dist/__tests__/var-allocator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/var-allocator.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const var_allocator_1 = require("../codegen/var-allocator");
+describe('VarAllocator', () => {
+    describe('mangle mode (default)', () => {
+        it('generates sequential names: a, b, ..., z, aa, ab', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const names = [];
+            for (let i = 0; i < 28; i++) {
+                names.push(alloc.alloc(`var${i}`));
+            }
+            expect(names[0]).toBe('$a');
+            expect(names[1]).toBe('$b');
+            expect(names[25]).toBe('$z');
+            expect(names[26]).toBe('$aa');
+            expect(names[27]).toBe('$ab');
+        });
+        it('caches: same name returns same result', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const first = alloc.alloc('x');
+            const second = alloc.alloc('x');
+            expect(first).toBe(second);
+        });
+        it('constant() is content-addressed: same value returns same result', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const first = alloc.constant(42);
+            const second = alloc.constant(42);
+            expect(first).toBe(second);
+        });
+        it('different variables get different names', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const a = alloc.alloc('foo');
+            const b = alloc.alloc('bar');
+            expect(a).not.toBe(b);
+        });
+        it('alloc, constant, and internal share the same sequential pool', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const v = alloc.alloc('x'); // $a
+            const c = alloc.constant(1); // $b
+            const i = alloc.internal('ret'); // $c
+            expect(v).toBe('$a');
+            expect(c).toBe('$b');
+            expect(i).toBe('$c');
+        });
+        it('strips $ prefix from variable names', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const a = alloc.alloc('$foo');
+            const b = alloc.alloc('foo');
+            expect(a).toBe(b); // same underlying name
+        });
+    });
+    describe('no-mangle mode', () => {
+        it('uses $<name> for user vars', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.alloc('counter')).toBe('$counter');
+        });
+        it('uses $const_<value> for constants', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.constant(10)).toBe('$const_10');
+            expect(alloc.constant(-3)).toBe('$const_-3');
+        });
+        it('uses $<suffix> for internals', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.internal('ret')).toBe('$ret');
+            expect(alloc.internal('p0')).toBe('$p0');
+        });
+    });
+});
+//# sourceMappingURL=var-allocator.test.js.map

package/dist/ast/types.d.ts

@@ -12,7 +12,7 @@ export interface Span {
     endCol?: number;
 }
 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 EntityTypeName = 'entity' | 'Player' | 'Mob' | 'HostileMob' | 'PassiveMob' | 'Zombie' | 'Skeleton' | 'Creeper' | 'Spider' | 'Enderman' | 'Blaze' | 'Witch' | 'Slime' | 'ZombieVillager' | 'Husk' | 'Drowned' | 'Stray' | 'WitherSkeleton' | 'CaveSpider' | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager' | 'WanderingTrader' | 'ArmorStand' | 'Item' | 'Arrow';
 export type TypeNode = {
     kind: 'named';
     name: PrimitiveType;
@@ -34,6 +34,7 @@ export type TypeNode = {
     entityType: EntityTypeName;
 } | {
     kind: 'selector';
+    entityType?: string;
 };
 export interface LambdaParam {
     name: string;

package/dist/cli.js

@@ -84,6 +84,7 @@ Options:
   --namespace <ns>       Datapack namespace (default: derived from filename)
   --target <target>      Output target: datapack (default), cmdblock, or structure
   --no-dce               Disable AST dead code elimination
+  --no-mangle            Disable variable name mangling (use readable names)
   --stats                Print optimizer statistics
   --hot-reload <url>     After each successful compile, POST to <url>/reload
                          (use with redscript-testharness; e.g. http://localhost:25561)
@@ -181,7 +182,7 @@ function upgradeCommand() {
     });
 }
 function parseArgs(args) {
-    const result = { dce: true };
+    const result = { dce: true, mangle: true };
     let i = 0;
     while (i < args.length) {
         const arg = args[i];
@@ -213,6 +214,10 @@ function parseArgs(args) {
             result.dce = false;
             i++;
         }
+        else if (arg === '--no-mangle') {
+            result.mangle = false;
+            i++;
+        }
         else if (arg === '--hot-reload') {
             result.hotReload = args[++i];
             i++;
@@ -266,7 +271,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, dce = true) {
+function compileCommand(file, output, namespace, target = 'datapack', showStats = false, dce = true, mangle = true) {
     // Read source file
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
@@ -275,7 +280,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, dce });
+            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce, mangle });
             printWarnings(result.warnings);
             // Generate command block JSON
             const hasTick = result.files.some(f => f.path.includes('__tick.mcfunction'));
@@ -293,7 +298,7 @@ function compileCommand(file, output, namespace, target = 'datapack', showStats
             }
         }
         else if (target === 'structure') {
-            const structure = (0, structure_1.compileToStructure)(source, namespace, file, { dce });
+            const structure = (0, structure_1.compileToStructure)(source, namespace, file, { dce, mangle });
             fs.mkdirSync(path.dirname(output), { recursive: true });
             fs.writeFileSync(output, structure.buffer);
             console.log(`✓ Generated structure for ${file}`);
@@ -304,7 +309,7 @@ function compileCommand(file, output, namespace, target = 'datapack', showStats
             }
         }
         else {
-            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce });
+            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce, mangle });
             printWarnings(result.warnings);
             // Default: generate datapack
             // Create output directory
@@ -316,6 +321,12 @@ function compileCommand(file, output, namespace, target = 'datapack', showStats
                 fs.mkdirSync(dir, { recursive: true });
                 fs.writeFileSync(filePath, dataFile.content);
             }
+            // Write sourcemap alongside datapack when mangle mode is active
+            if (mangle && result.sourceMap && Object.keys(result.sourceMap).length > 0) {
+                const mapPath = path.join(output, `${namespace}.map.json`);
+                fs.writeFileSync(mapPath, JSON.stringify(result.sourceMap, null, 2));
+                console.log(`  Sourcemap: ${mapPath}`);
+            }
             console.log(`✓ Compiled ${file} to ${output}/`);
             console.log(`  Namespace: ${namespace}`);
             console.log(`  Functions: ${result.ir.functions.length}`);
@@ -472,7 +483,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, parsed.dce);
+                compileCommand(parsed.file, output, namespace, target, parsed.stats, parsed.dce, parsed.mangle);
             }
             break;
         case 'watch':

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

@@ -25,9 +25,11 @@ export interface DatapackGenerationResult {
     files: DatapackFile[];
     advancements: DatapackFile[];
     stats: OptimizationStats;
+    sourceMap?: Record<string, string>;
 }
 export interface DatapackGenerationOptions {
     optimizeCommands?: boolean;
+    mangle?: boolean;
 }
 export declare function countMcfunctionCommands(files: DatapackFile[]): number;
 export declare function generateDatapackWithStats(module: IRModule, options?: DatapackGenerationOptions): DatapackGenerationResult;