redscript-mc 1.2.20 → 1.2.24

package/dist/optimizer/dce.d.ts

@@ -4,6 +4,7 @@ export interface DCEWarning {
     code: string;
     line?: number;
     col?: number;
+    filePath?: string;
 }
 export declare class DeadCodeEliminator {
     private readonly functionMap;
@@ -27,7 +28,7 @@ export declare class DeadCodeEliminator {
     private transformStmt;
     private transformExpr;
 }
-export declare function eliminateDeadCode(program: Program): {
+export declare function eliminateDeadCode(program: Program, sourceRanges?: import('../compile').SourceRange[]): {
     program: Program;
     warnings: DCEWarning[];
 };

package/dist/optimizer/dce.js

@@ -604,9 +604,20 @@ class DeadCodeEliminator {
     }
 }
 exports.DeadCodeEliminator = DeadCodeEliminator;
-function eliminateDeadCode(program) {
+function eliminateDeadCode(program, sourceRanges) {
     const eliminator = new DeadCodeEliminator();
     const result = eliminator.eliminate(program);
-    return { program: result, warnings: eliminator.warnings };
+    let warnings = eliminator.warnings;
+    // Resolve combined-source line numbers back to original file + line
+    if (sourceRanges && sourceRanges.length > 0) {
+        const { resolveSourceLine } = require('../compile');
+        warnings = warnings.map(w => {
+            if (w.line == null)
+                return w;
+            const resolved = resolveSourceLine(w.line, sourceRanges);
+            return { ...w, line: resolved.line, filePath: resolved.filePath ?? w.filePath };
+        });
+    }
+    return { program: result, warnings };
 }
 //# sourceMappingURL=dce.js.map

package/dist/parser/index.js

@@ -32,11 +32,21 @@ const ENTITY_TYPE_NAMES = new Set([
     'Creeper',
     'Spider',
     'Enderman',
+    'Blaze',
+    'Witch',
+    'Slime',
+    'ZombieVillager',
+    'Husk',
+    'Drowned',
+    'Stray',
+    'WitherSkeleton',
+    'CaveSpider',
     'Pig',
     'Cow',
     'Sheep',
     'Chicken',
     'Villager',
+    'WanderingTrader',
     'ArmorStand',
     'Item',
     'Arrow',
@@ -384,7 +394,18 @@ class Parser {
         }
         else if (token.kind === 'ident') {
             this.advance();
-            type = { kind: 'struct', name: token.value };
+            if (token.value === 'selector' && this.check('<')) {
+                this.advance(); // consume <
+                const entityType = this.expect('ident').value;
+                this.expect('>');
+                type = { kind: 'selector', entityType };
+            }
+            else if (token.value === 'selector') {
+                type = { kind: 'selector' };
+            }
+            else {
+                type = { kind: 'struct', name: token.value };
+            }
         }
         else {
             this.error(`Expected type, got '${token.kind}'`);

package/dist/typechecker/index.js

@@ -21,11 +21,21 @@ const ENTITY_HIERARCHY = {
     'Creeper': 'HostileMob',
     'Spider': 'HostileMob',
     'Enderman': 'HostileMob',
+    'Blaze': 'HostileMob',
+    'Witch': 'HostileMob',
+    'Slime': 'HostileMob',
+    'ZombieVillager': 'HostileMob',
+    'Husk': 'HostileMob',
+    'Drowned': 'HostileMob',
+    'Stray': 'HostileMob',
+    'WitherSkeleton': 'HostileMob',
+    'CaveSpider': 'HostileMob',
     'Pig': 'PassiveMob',
     'Cow': 'PassiveMob',
     'Sheep': 'PassiveMob',
     'Chicken': 'PassiveMob',
     'Villager': 'PassiveMob',
+    'WanderingTrader': 'PassiveMob',
     'ArmorStand': 'entity',
     'Item': 'entity',
     'Arrow': 'entity',
@@ -42,6 +52,24 @@ const MC_TYPE_TO_ENTITY = {
     'minecraft:spider': 'Spider',
     'enderman': 'Enderman',
     'minecraft:enderman': 'Enderman',
+    'blaze': 'Blaze',
+    'minecraft:blaze': 'Blaze',
+    'witch': 'Witch',
+    'minecraft:witch': 'Witch',
+    'slime': 'Slime',
+    'minecraft:slime': 'Slime',
+    'zombie_villager': 'ZombieVillager',
+    'minecraft:zombie_villager': 'ZombieVillager',
+    'husk': 'Husk',
+    'minecraft:husk': 'Husk',
+    'drowned': 'Drowned',
+    'minecraft:drowned': 'Drowned',
+    'stray': 'Stray',
+    'minecraft:stray': 'Stray',
+    'wither_skeleton': 'WitherSkeleton',
+    'minecraft:wither_skeleton': 'WitherSkeleton',
+    'cave_spider': 'CaveSpider',
+    'minecraft:cave_spider': 'CaveSpider',
     'pig': 'Pig',
     'minecraft:pig': 'Pig',
     'cow': 'Cow',
@@ -52,6 +80,8 @@ const MC_TYPE_TO_ENTITY = {
     'minecraft:chicken': 'Chicken',
     'villager': 'Villager',
     'minecraft:villager': 'Villager',
+    'wandering_trader': 'WanderingTrader',
+    'minecraft:wandering_trader': 'WanderingTrader',
     'armor_stand': 'ArmorStand',
     'minecraft:armor_stand': 'ArmorStand',
     'item': 'Item',

package/dist/types/entity-hierarchy.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Entity Type Hierarchy
+ *
+ * Closed inheritance tree mapping to Minecraft's entity registry.
+ * Used for type narrowing (is checks), selector<T> annotations,
+ * and W_IMPOSSIBLE_AS warnings.
+ */
+export interface EntityTypeNode {
+    name: string;
+    mcId: string | null;
+    abstract: boolean;
+    parent: string | null;
+}
+export declare const ENTITY_TYPES: EntityTypeNode[];
+/** Map from lowercase name → EntityTypeNode */
+export declare const ENTITY_TYPE_MAP: Map<string, EntityTypeNode>;
+/** Map from mcId (without namespace) → EntityTypeNode */
+export declare const ENTITY_TYPE_BY_MCID: Map<string, EntityTypeNode>;
+/** Check if typeA is a subtype of typeB (recursive ancestry) */
+export declare function isSubtype(typeA: string, typeB: string): boolean;
+/** True if one type is a subtype of the other (in either direction) */
+export declare function areCompatibleTypes(outerType: string, innerType: string): boolean;
+/** Get all non-abstract leaf types under a given node */
+export declare function getConcreteSubtypes(typeName: string): EntityTypeNode[];
+/** Parse "type=zombie" from a selector string, return the entity type name or null */
+export declare function getSelectorEntityType(selector: string): string | null;
+/** Determine the base entity type from a selector kind:
+ *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
+export declare function getBaseSelectorType(selector: string): string | null;

package/dist/types/entity-hierarchy.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Entity Type Hierarchy
+ *
+ * Closed inheritance tree mapping to Minecraft's entity registry.
+ * Used for type narrowing (is checks), selector<T> annotations,
+ * and W_IMPOSSIBLE_AS warnings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTITY_TYPE_BY_MCID = exports.ENTITY_TYPE_MAP = exports.ENTITY_TYPES = void 0;
+exports.isSubtype = isSubtype;
+exports.areCompatibleTypes = areCompatibleTypes;
+exports.getConcreteSubtypes = getConcreteSubtypes;
+exports.getSelectorEntityType = getSelectorEntityType;
+exports.getBaseSelectorType = getBaseSelectorType;
+exports.ENTITY_TYPES = [
+    // Root
+    { name: 'Entity', mcId: null, abstract: true, parent: null },
+    // Direct children of Entity
+    { name: 'Player', mcId: 'minecraft:player', abstract: false, parent: 'Entity' },
+    { name: 'ArmorStand', mcId: 'minecraft:armor_stand', abstract: false, parent: 'Entity' },
+    { name: 'Item', mcId: 'minecraft:item', abstract: false, parent: 'Entity' },
+    { name: 'Arrow', mcId: 'minecraft:arrow', abstract: false, parent: 'Entity' },
+    // Mob hierarchy
+    { name: 'Mob', mcId: null, abstract: true, parent: 'Entity' },
+    // Hostile mobs
+    { name: 'HostileMob', mcId: null, abstract: true, parent: 'Mob' },
+    { name: 'Zombie', mcId: 'minecraft:zombie', abstract: false, parent: 'HostileMob' },
+    { name: 'Skeleton', mcId: 'minecraft:skeleton', abstract: false, parent: 'HostileMob' },
+    { name: 'Creeper', mcId: 'minecraft:creeper', abstract: false, parent: 'HostileMob' },
+    { name: 'Spider', mcId: 'minecraft:spider', abstract: false, parent: 'HostileMob' },
+    { name: 'Enderman', mcId: 'minecraft:enderman', abstract: false, parent: 'HostileMob' },
+    { name: 'Blaze', mcId: 'minecraft:blaze', abstract: false, parent: 'HostileMob' },
+    { name: 'Witch', mcId: 'minecraft:witch', abstract: false, parent: 'HostileMob' },
+    { name: 'Slime', mcId: 'minecraft:slime', abstract: false, parent: 'HostileMob' },
+    { name: 'ZombieVillager', mcId: 'minecraft:zombie_villager', abstract: false, parent: 'HostileMob' },
+    { name: 'Husk', mcId: 'minecraft:husk', abstract: false, parent: 'HostileMob' },
+    { name: 'Drowned', mcId: 'minecraft:drowned', abstract: false, parent: 'HostileMob' },
+    { name: 'Stray', mcId: 'minecraft:stray', abstract: false, parent: 'HostileMob' },
+    { name: 'WitherSkeleton', mcId: 'minecraft:wither_skeleton', abstract: false, parent: 'HostileMob' },
+    { name: 'CaveSpider', mcId: 'minecraft:cave_spider', abstract: false, parent: 'HostileMob' },
+    // Passive mobs
+    { name: 'PassiveMob', mcId: null, abstract: true, parent: 'Mob' },
+    { name: 'Pig', mcId: 'minecraft:pig', abstract: false, parent: 'PassiveMob' },
+    { name: 'Cow', mcId: 'minecraft:cow', abstract: false, parent: 'PassiveMob' },
+    { name: 'Sheep', mcId: 'minecraft:sheep', abstract: false, parent: 'PassiveMob' },
+    { name: 'Chicken', mcId: 'minecraft:chicken', abstract: false, parent: 'PassiveMob' },
+    { name: 'Villager', mcId: 'minecraft:villager', abstract: false, parent: 'PassiveMob' },
+    { name: 'WanderingTrader', mcId: 'minecraft:wandering_trader', abstract: false, parent: 'PassiveMob' },
+];
+/** Map from lowercase name → EntityTypeNode */
+exports.ENTITY_TYPE_MAP = new Map(exports.ENTITY_TYPES.map(t => [t.name.toLowerCase(), t]));
+/** Map from mcId (without namespace) → EntityTypeNode */
+exports.ENTITY_TYPE_BY_MCID = new Map(exports.ENTITY_TYPES
+    .filter(t => t.mcId !== null)
+    .map(t => [t.mcId.replace('minecraft:', ''), t]));
+/** Check if typeA is a subtype of typeB (recursive ancestry) */
+function isSubtype(typeA, typeB) {
+    if (typeA === typeB)
+        return true;
+    const node = exports.ENTITY_TYPE_MAP.get(typeA.toLowerCase());
+    if (!node || !node.parent)
+        return false;
+    return isSubtype(node.parent, typeB);
+}
+/** True if one type is a subtype of the other (in either direction) */
+function areCompatibleTypes(outerType, innerType) {
+    return isSubtype(outerType, innerType) || isSubtype(innerType, outerType);
+}
+/** Get all non-abstract leaf types under a given node */
+function getConcreteSubtypes(typeName) {
+    const results = [];
+    for (const node of exports.ENTITY_TYPES) {
+        if (!node.abstract && isSubtype(node.name, typeName)) {
+            results.push(node);
+        }
+    }
+    return results;
+}
+/** Parse "type=zombie" from a selector string, return the entity type name or null */
+function getSelectorEntityType(selector) {
+    const match = selector.match(/type=(?:minecraft:)?([a-z_]+)/);
+    if (!match)
+        return null;
+    const mcId = match[1];
+    const node = exports.ENTITY_TYPE_BY_MCID.get(mcId);
+    return node ? node.name : null;
+}
+/** Determine the base entity type from a selector kind:
+ *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
+function getBaseSelectorType(selector) {
+    const trimmed = selector.trim();
+    // Check for type filter first (works for any selector)
+    const typeFromFilter = getSelectorEntityType(trimmed);
+    if (trimmed.startsWith('@a') || trimmed.startsWith('@p') || trimmed.startsWith('@r')) {
+        return typeFromFilter ?? 'Player';
+    }
+    if (trimmed.startsWith('@e')) {
+        return typeFromFilter ?? 'Entity';
+    }
+    // @s — context-dependent, we don't know unless there's a type filter
+    if (trimmed.startsWith('@s')) {
+        return typeFromFilter ?? null;
+    }
+    return null;
+}
+//# sourceMappingURL=entity-hierarchy.js.map

package/editors/vscode/out/extension.js

@@ -1193,10 +1193,22 @@ var require_parser = __commonJS({
       parseForRangeStmt(forToken) {
         const varName = this.expect("ident").value;
         this.expect("in");
-        const rangeToken = this.expect("range_lit");
-        const range = this.parseRangeValue(rangeToken.value);
-        const start = this.withLoc({ kind: "int_lit", value: range.min ?? 0 }, rangeToken);
-        const end = this.withLoc({ kind: "int_lit", value: range.max ?? 0 }, rangeToken);
+        let start;
+        let end;
+        if (this.check("range_lit")) {
+          const rangeToken = this.advance();
+          const range = this.parseRangeValue(rangeToken.value);
+          start = this.withLoc({ kind: "int_lit", value: range.min ?? 0 }, rangeToken);
+          if (range.max !== null && range.max !== void 0) {
+            end = this.withLoc({ kind: "int_lit", value: range.max }, rangeToken);
+          } else {
+            end = this.parseUnaryExpr();
+          }
+        } else {
+          start = this.withLoc({ kind: "int_lit", value: 0 }, this.peek());
+          end = this.withLoc({ kind: "int_lit", value: 0 }, this.peek());
+          this.error("Dynamic range start requires a literal integer (e.g. 0..count)");
+        }
         const body = this.parseBlock();
         return this.withLoc({ kind: "for_range", varName, start, end, body }, forToken);
       }
@@ -1656,6 +1668,19 @@ var require_parser = __commonJS({
         this.error(`Unexpected token '${token.kind}'`);
       }
       parseLiteralExpr() {
+        if (this.check("-")) {
+          this.advance();
+          const token = this.peek();
+          if (token.kind === "int_lit") {
+            this.advance();
+            return this.withLoc({ kind: "int_lit", value: -Number(token.value) }, token);
+          }
+          if (token.kind === "float_lit") {
+            this.advance();
+            return this.withLoc({ kind: "float_lit", value: -Number(token.value) }, token);
+          }
+          this.error("Expected number after unary -");
+        }
         const expr = this.parsePrimaryExpr();
         if (expr.kind === "int_lit" || expr.kind === "float_lit" || expr.kind === "bool_lit" || expr.kind === "str_lit") {
           return expr;

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.0.11",
+      "version": "1.0.13",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"
@@ -22,10 +22,12 @@
       }
     },
     "../..": {
-      "version": "0.1.0",
+      "name": "redscript-mc",
+      "version": "1.2.24",
       "license": "MIT",
       "bin": {
-        "redscript": "dist/cli.js"
+        "redscript": "dist/cli.js",
+        "rsc": "dist/cli.js"
       },
       "devDependencies": {
         "@types/jest": "^29.5.0",

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.11",
+  "version": "1.0.13",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",
@@ -129,8 +129,8 @@
     "compile": "node build.mjs",
     "watch": "node build.mjs --watch",
     "build": "npm run compile",
-    "package": "npm run build && vsce package --no-dependencies",
-    "publish": "npm run build && vsce publish --no-dependencies"
+    "package": "npm run build && npx @vscode/vsce package --no-dependencies",
+    "publish": "npm run build && npx @vscode/vsce publish --no-dependencies"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/package.json

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

package/src/__tests__/compile-all.test.ts

@@ -16,6 +16,12 @@ import * as os from 'os'
 const REPO_ROOT = path.resolve(__dirname, '../../')
 const CLI = path.join(REPO_ROOT, 'dist', 'cli.js')
 
+// Ensure dist/cli.js exists — build first if not (e.g. in CI)
+if (!fs.existsSync(CLI)) {
+  console.log('[compile-all] dist/cli.js not found, running npm run build...')
+  execSync('npm run build', { cwd: REPO_ROOT, stdio: 'inherit' })
+}
+
 /** Patterns to skip */
 const SKIP_GLOBS = [
   'node_modules',

package/src/__tests__/entity-types.test.ts

@@ -0,0 +1,236 @@
+import {
+  isSubtype,
+  areCompatibleTypes,
+  getConcreteSubtypes,
+  getSelectorEntityType,
+  getBaseSelectorType,
+} from '../types/entity-hierarchy'
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { Lowering } from '../lowering'
+import type { IRModule } from '../ir/types'
+
+function compileWithWarnings(source: string, namespace = 'test'): { ir: IRModule; warnings: Lowering['warnings'] } {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse(namespace)
+  const lowering = new 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(isSubtype('Zombie', 'Mob')).toBe(true)
+  })
+
+  test('isSubtype: Player is NOT a subtype of Mob', () => {
+    expect(isSubtype('Player', 'Mob')).toBe(false)
+  })
+
+  test('isSubtype: Zombie is a subtype of Entity (transitive)', () => {
+    expect(isSubtype('Zombie', 'Entity')).toBe(true)
+  })
+
+  test('isSubtype: identity — Zombie is subtype of Zombie', () => {
+    expect(isSubtype('Zombie', 'Zombie')).toBe(true)
+  })
+
+  test('areCompatibleTypes: Player and Zombie are NOT compatible', () => {
+    expect(areCompatibleTypes('Player', 'Zombie')).toBe(false)
+  })
+
+  test('areCompatibleTypes: Zombie and Mob are compatible', () => {
+    expect(areCompatibleTypes('Zombie', 'Mob')).toBe(true)
+  })
+
+  test('areCompatibleTypes: Mob and Zombie are compatible (reverse)', () => {
+    expect(areCompatibleTypes('Mob', 'Zombie')).toBe(true)
+  })
+
+  test('getConcreteSubtypes: HostileMob includes Zombie, Skeleton, Creeper', () => {
+    const subtypes = 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 = 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(getSelectorEntityType('@e[type=zombie]')).toBe('Zombie')
+  })
+
+  test('getSelectorEntityType: parses type=minecraft:skeleton', () => {
+    expect(getSelectorEntityType('@e[type=minecraft:skeleton]')).toBe('Skeleton')
+  })
+
+  test('getBaseSelectorType: @a → Player', () => {
+    expect(getBaseSelectorType('@a')).toBe('Player')
+  })
+
+  test('getBaseSelectorType: @e → Entity', () => {
+    expect(getBaseSelectorType('@e')).toBe('Entity')
+  })
+
+  test('getBaseSelectorType: @e[type=zombie] → Zombie', () => {
+    expect(getBaseSelectorType('@e[type=zombie]')).toBe('Zombie')
+  })
+
+  test('getBaseSelectorType: @s → null', () => {
+    expect(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 is any => 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 is any => 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(source).tokenize()
+    const ast = new 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(source).tokenize()
+    const ast = new Parser(tokens).parse('test')
+    const fn = ast.declarations[0]
+    expect(fn.params[0].type).toEqual({ kind: 'selector' })
+  })
+})