redscript-mc 2.0.0 → 2.1.0

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

@@ -1,29 +0,0 @@
-/**
- * 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

@@ -1,107 +0,0 @@
-"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/src2/emit/compile.ts

@@ -1,99 +0,0 @@
-/**
- * Top-level compile function for the v2 pipeline.
- *
- * Pipeline: source → Lexer → Parser → HIR → MIR → optimize → LIR → emit
- */
-
-import { Lexer } from '../../src/lexer'
-import { Parser } from '../../src/parser'
-import { preprocessSourceWithMetadata } from '../../src/compile'
-import { lowerToHIR } from '../hir/lower'
-import { lowerToMIR } from '../mir/lower'
-import { optimizeModule } from '../optimizer/pipeline'
-import { lowerToLIR } from '../lir/lower'
-import { emit, type DatapackFile } from './index'
-
-export interface CompileOptions {
-  namespace?: string
-  filePath?: string
-  /** v1 compat: inline library sources (treated as `module library;` imports) */
-  librarySources?: string[]
-}
-
-export interface CompileResult {
-  files: DatapackFile[]
-  warnings: string[]
-  /** Always true — v1 compat shim (compile() throws on error) */
-  readonly success: true
-}
-
-export function compile(source: string, options: CompileOptions = {}): CompileResult {
-  const { namespace = 'redscript', filePath } = options
-  const warnings: string[] = []
-
-  // Preprocess: resolve import directives, merge imported sources
-  const preprocessed = preprocessSourceWithMetadata(source, { filePath })
-  const processedSource = preprocessed.source
-
-  // Stage 1: Lex + Parse → AST
-  const lexer = new Lexer(processedSource)
-  const tokens = lexer.tokenize()
-  const parser = new Parser(tokens, processedSource, filePath)
-  const ast = parser.parse(namespace)
-
-  // Merge library imports (files with `module library;`) into AST
-  for (const li of preprocessed.libraryImports ?? []) {
-    const libPreprocessed = preprocessSourceWithMetadata(li.source, { filePath: li.filePath })
-    const libTokens = new Lexer(libPreprocessed.source, li.filePath).tokenize()
-    const libAst = new Parser(libTokens, libPreprocessed.source, li.filePath).parse(namespace)
-    for (const fn of libAst.declarations) fn.isLibraryFn = true
-    ast.declarations.push(...libAst.declarations)
-    ast.structs.push(...libAst.structs)
-    ast.implBlocks.push(...libAst.implBlocks)
-    ast.enums.push(...libAst.enums)
-    ast.consts.push(...libAst.consts)
-    ast.globals.push(...libAst.globals)
-  }
-
-  // Merge librarySources (v1 compat: inline library strings) before HIR
-  if (options.librarySources) {
-    for (const libSrc of options.librarySources) {
-      const libTokens = new Lexer(libSrc).tokenize()
-      const libAst = new Parser(libTokens, libSrc).parse(namespace)
-      for (const fn of libAst.declarations) fn.isLibraryFn = true
-      ast.declarations.push(...libAst.declarations)
-      ast.structs.push(...libAst.structs)
-      ast.implBlocks.push(...libAst.implBlocks)
-      ast.enums.push(...libAst.enums)
-      ast.consts.push(...libAst.consts)
-      ast.globals.push(...libAst.globals)
-    }
-  }
-
-  // Stage 2: AST → HIR
-  const hir = lowerToHIR(ast)
-
-  // Extract @tick and @load functions from HIR (before decorator info is lost)
-  const tickFunctions: string[] = []
-  const loadFunctions: string[] = []
-  for (const fn of hir.functions) {
-    for (const dec of fn.decorators) {
-      if (dec.name === 'tick') tickFunctions.push(fn.name)
-      if (dec.name === 'load') loadFunctions.push(fn.name)
-    }
-  }
-
-  // Stage 3: HIR → MIR
-  const mir = lowerToMIR(hir)
-
-  // Stage 4: MIR optimization
-  const mirOpt = optimizeModule(mir)
-
-  // Stage 5: MIR → LIR
-  const lir = lowerToLIR(mirOpt)
-
-  // Stage 7: LIR → .mcfunction
-  const files = emit(lir, { namespace, tickFunctions, loadFunctions })
-
-  return { files, warnings, success: true as const }
-}