redscript-mc 2.4.0 → 2.4.1

package/dist/src2/optimizer/block_merge.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Block Merging — MIR optimization pass.
+ *
+ * Merges a block B into its sole predecessor A when:
+ * - A ends with an unconditional jump to B
+ * - B has exactly one predecessor (A)
+ * - B is not the entry block
+ *
+ * The merged block keeps A's id and combines A's instrs + B's instrs + B's terminator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blockMerge = blockMerge;
+function blockMerge(fn) {
+    let blocks = fn.blocks;
+    // Iterate until no more merges possible
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const blockMap = new Map(blocks.map(b => [b.id, b]));
+        const predCounts = computePredCounts(blocks);
+        const newBlocks = [];
+        const removed = new Set();
+        for (const block of blocks) {
+            if (removed.has(block.id))
+                continue;
+            // Check: does this block jump unconditionally to a single-pred successor?
+            if (block.term.kind === 'jump') {
+                const targetId = block.term.target;
+                const target = blockMap.get(targetId);
+                if (target && targetId !== fn.entry && predCounts.get(targetId) === 1) {
+                    // Merge target into this block
+                    const merged = {
+                        id: block.id,
+                        instrs: [...block.instrs, ...target.instrs],
+                        term: target.term,
+                        preds: block.preds,
+                    };
+                    newBlocks.push(merged);
+                    removed.add(targetId);
+                    changed = true;
+                    continue;
+                }
+            }
+            newBlocks.push(block);
+        }
+        blocks = newBlocks;
+    }
+    // Recompute preds after merging
+    blocks = recomputePreds(blocks);
+    return { ...fn, blocks };
+}
+function computePredCounts(blocks) {
+    const counts = new Map();
+    for (const b of blocks)
+        counts.set(b.id, 0);
+    for (const block of blocks) {
+        for (const target of getTermTargets(block.term)) {
+            counts.set(target, (counts.get(target) ?? 0) + 1);
+        }
+    }
+    return counts;
+}
+function recomputePreds(blocks) {
+    const predMap = new Map();
+    for (const b of blocks)
+        predMap.set(b.id, []);
+    for (const block of blocks) {
+        for (const target of getTermTargets(block.term)) {
+            const preds = predMap.get(target);
+            if (preds)
+                preds.push(block.id);
+        }
+    }
+    return blocks.map(b => ({ ...b, preds: predMap.get(b.id) ?? [] }));
+}
+function getTermTargets(term) {
+    switch (term.kind) {
+        case 'jump': return [term.target];
+        case 'branch': return [term.then, term.else];
+        default: return [];
+    }
+}
+//# sourceMappingURL=block_merge.js.map

package/dist/src2/optimizer/branch_simplify.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Branch Simplification — MIR optimization pass.
+ *
+ * Replaces `branch(const, then, else)` with an unconditional `jump`:
+ * - branch(nonzero, then, else) → jump(then)
+ * - branch(0, then, else) → jump(else)
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function branchSimplify(fn: MIRFunction): MIRFunction;

package/dist/src2/optimizer/branch_simplify.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Branch Simplification — MIR optimization pass.
+ *
+ * Replaces `branch(const, then, else)` with an unconditional `jump`:
+ * - branch(nonzero, then, else) → jump(then)
+ * - branch(0, then, else) → jump(else)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.branchSimplify = branchSimplify;
+function branchSimplify(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(simplifyBlock),
+    };
+}
+function simplifyBlock(block) {
+    if (block.term.kind !== 'branch')
+        return block;
+    if (block.term.cond.kind !== 'const')
+        return block;
+    const target = block.term.cond.value !== 0 ? block.term.then : block.term.else;
+    return {
+        ...block,
+        term: { kind: 'jump', target },
+    };
+}
+//# sourceMappingURL=branch_simplify.js.map

package/dist/src2/optimizer/constant_fold.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Constant Folding — MIR optimization pass.
+ *
+ * Folds instructions where all operands are constants:
+ * - Arithmetic: add(3, 4) → 7, neg(5) → -5
+ * - Comparison: cmp(lt, 3, 4) → 1
+ * - Boolean: and(1, 0) → 0, not(0) → 1
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function constantFold(fn: MIRFunction): MIRFunction;

package/dist/src2/optimizer/constant_fold.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Constant Folding — MIR optimization pass.
+ *
+ * Folds instructions where all operands are constants:
+ * - Arithmetic: add(3, 4) → 7, neg(5) → -5
+ * - Comparison: cmp(lt, 3, 4) → 1
+ * - Boolean: and(1, 0) → 0, not(0) → 1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constantFold = constantFold;
+function constantFold(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(foldBlock),
+    };
+}
+function foldBlock(block) {
+    const instrs = [];
+    for (const instr of block.instrs) {
+        const folded = tryFold(instr);
+        instrs.push(folded ?? instr);
+    }
+    return { ...block, instrs };
+}
+function isConst(op) {
+    return op.kind === 'const';
+}
+function tryFold(instr) {
+    switch (instr.kind) {
+        case 'add':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: instr.a.value + instr.b.value };
+            break;
+        case 'sub':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: instr.a.value - instr.b.value };
+            break;
+        case 'mul':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: instr.a.value * instr.b.value };
+            break;
+        case 'div':
+            if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
+                return { kind: 'const', dst: instr.dst, value: Math.trunc(instr.a.value / instr.b.value) };
+            break;
+        case 'mod':
+            if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
+                return { kind: 'const', dst: instr.dst, value: instr.a.value % instr.b.value };
+            break;
+        case 'neg':
+            if (isConst(instr.src))
+                return { kind: 'const', dst: instr.dst, value: -instr.src.value };
+            break;
+        case 'not':
+            if (isConst(instr.src))
+                return { kind: 'const', dst: instr.dst, value: instr.src.value === 0 ? 1 : 0 };
+            break;
+        case 'and':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: (instr.a.value !== 0 && instr.b.value !== 0) ? 1 : 0 };
+            break;
+        case 'or':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: (instr.a.value !== 0 || instr.b.value !== 0) ? 1 : 0 };
+            break;
+        case 'cmp':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: evalCmp(instr.op, instr.a.value, instr.b.value) };
+            break;
+    }
+    return null;
+}
+function evalCmp(op, a, b) {
+    switch (op) {
+        case 'eq': return a === b ? 1 : 0;
+        case 'ne': return a !== b ? 1 : 0;
+        case 'lt': return a < b ? 1 : 0;
+        case 'le': return a <= b ? 1 : 0;
+        case 'gt': return a > b ? 1 : 0;
+        case 'ge': return a >= b ? 1 : 0;
+        default: return 0;
+    }
+}
+//# sourceMappingURL=constant_fold.js.map

package/dist/src2/optimizer/copy_prop.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copy Propagation — MIR optimization pass.
+ *
+ * Within each block, tracks `copy dst, src` and `const dst, value` instructions
+ * and replaces subsequent uses of `dst` with the known operand.
+ * Invalidates mappings when a temp is redefined (written to).
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function copyProp(fn: MIRFunction): MIRFunction;

package/dist/src2/optimizer/copy_prop.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Copy Propagation — MIR optimization pass.
+ *
+ * Within each block, tracks `copy dst, src` and `const dst, value` instructions
+ * and replaces subsequent uses of `dst` with the known operand.
+ * Invalidates mappings when a temp is redefined (written to).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyProp = copyProp;
+function copyProp(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(propBlock),
+    };
+}
+function propBlock(block) {
+    // Map from temp → the operand it was copied from
+    const copies = new Map();
+    const instrs = [];
+    for (const instr of block.instrs) {
+        // Rewrite uses first
+        const rewritten = rewriteUses(instr, copies);
+        // Invalidate any mapping whose source was just redefined
+        const dst = getDst(rewritten);
+        if (dst) {
+            // Remove any mapping that points TO this dst (as a temp source)
+            for (const [k, v] of copies) {
+                if (v.kind === 'temp' && v.name === dst) {
+                    copies.delete(k);
+                }
+            }
+            // Remove dst's own previous mapping (will be re-added below if applicable)
+            copies.delete(dst);
+        }
+        // Track new propagatable definitions
+        if (rewritten.kind === 'const') {
+            // const dst, value → record dst → const operand
+            copies.set(rewritten.dst, { kind: 'const', value: rewritten.value });
+        }
+        else if (rewritten.kind === 'copy') {
+            // copy dst, src → record dst → src (temp or const)
+            copies.set(rewritten.dst, rewritten.src);
+        }
+        instrs.push(rewritten);
+    }
+    // Also rewrite terminator uses
+    const term = rewriteUses(block.term, copies);
+    return { ...block, instrs, term };
+}
+function resolve(op, copies) {
+    if (op.kind === 'temp') {
+        const replacement = copies.get(op.name);
+        if (replacement)
+            return replacement;
+    }
+    return op;
+}
+function rewriteUses(instr, copies) {
+    switch (instr.kind) {
+        case 'copy':
+            return { ...instr, src: resolve(instr.src, copies) };
+        case 'neg':
+        case 'not':
+            return { ...instr, src: resolve(instr.src, copies) };
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'and':
+        case 'or':
+            return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) };
+        case 'cmp':
+            return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) };
+        case 'nbt_write':
+            return { ...instr, src: resolve(instr.src, copies) };
+        case 'call':
+            return { ...instr, args: instr.args.map(a => resolve(a, copies)) };
+        case 'call_macro':
+            return { ...instr, args: instr.args.map(a => ({ ...a, value: resolve(a.value, copies) })) };
+        case 'branch':
+            return { ...instr, cond: resolve(instr.cond, copies) };
+        case 'return':
+            return { ...instr, value: instr.value ? resolve(instr.value, copies) : null };
+        default:
+            return instr;
+    }
+}
+function getDst(instr) {
+    switch (instr.kind) {
+        case 'const':
+        case 'copy':
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'neg':
+        case 'cmp':
+        case 'and':
+        case 'or':
+        case 'not':
+        case 'nbt_read':
+            return instr.dst;
+        case 'call':
+        case 'call_macro':
+            return instr.dst;
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=copy_prop.js.map

package/dist/src2/optimizer/dce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dead Code Elimination — MIR optimization pass.
+ *
+ * 1. Removes definitions of temps that are never used anywhere in the function.
+ * 2. Removes unreachable blocks (no predecessors and not the entry block).
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function dce(fn: MIRFunction): MIRFunction;

package/dist/src2/optimizer/dce.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * Dead Code Elimination — MIR optimization pass.
+ *
+ * 1. Removes definitions of temps that are never used anywhere in the function.
+ * 2. Removes unreachable blocks (no predecessors and not the entry block).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dce = dce;
+function dce(fn) {
+    // Phase 1: Remove unreachable blocks
+    let blocks = removeUnreachable(fn);
+    // Phase 2: Remove unused temp definitions
+    blocks = removeDeadDefs(fn.params, blocks);
+    // Phase 3: Recompute preds after block removal
+    blocks = recomputePreds(blocks);
+    return { ...fn, blocks };
+}
+function removeUnreachable(fn) {
+    const reachable = new Set();
+    const queue = [fn.entry];
+    const blockMap = new Map(fn.blocks.map(b => [b.id, b]));
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (reachable.has(id))
+            continue;
+        reachable.add(id);
+        const block = blockMap.get(id);
+        if (block) {
+            for (const target of getTermTargets(block.term)) {
+                if (!reachable.has(target))
+                    queue.push(target);
+            }
+        }
+    }
+    return fn.blocks.filter(b => reachable.has(b.id));
+}
+function removeDeadDefs(params, blocks) {
+    // Collect all used temps across the entire function
+    const used = new Set();
+    for (const block of blocks) {
+        for (const instr of block.instrs) {
+            for (const t of getUsedTemps(instr))
+                used.add(t);
+        }
+        for (const t of getUsedTemps(block.term))
+            used.add(t);
+    }
+    // Remove instructions whose dst is never used, unless they have side effects
+    return blocks.map(block => ({
+        ...block,
+        instrs: block.instrs.filter(instr => {
+            const dst = getDst(instr);
+            if (dst === null)
+                return true; // no dst → keep (side-effectful)
+            if (hasSideEffects(instr))
+                return true;
+            return used.has(dst);
+        }),
+    }));
+}
+function recomputePreds(blocks) {
+    const predMap = new Map();
+    for (const b of blocks)
+        predMap.set(b.id, []);
+    for (const block of blocks) {
+        for (const target of getTermTargets(block.term)) {
+            const preds = predMap.get(target);
+            if (preds)
+                preds.push(block.id);
+        }
+    }
+    return blocks.map(b => ({ ...b, preds: predMap.get(b.id) ?? [] }));
+}
+function hasSideEffects(instr) {
+    if (instr.kind === 'call' || instr.kind === 'call_macro' ||
+        instr.kind === 'call_context' || instr.kind === 'nbt_write')
+        return true;
+    // Return field temps (__rf_) write to global return slots — not dead even if unused locally
+    const dst = getDst(instr);
+    if (dst && dst.startsWith('__rf_'))
+        return true;
+    return false;
+}
+function getTermTargets(term) {
+    switch (term.kind) {
+        case 'jump': return [term.target];
+        case 'branch': return [term.then, term.else];
+        default: return [];
+    }
+}
+function getDst(instr) {
+    switch (instr.kind) {
+        case 'const':
+        case 'copy':
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'neg':
+        case 'cmp':
+        case 'and':
+        case 'or':
+        case 'not':
+        case 'nbt_read':
+            return instr.dst;
+        case 'call':
+        case 'call_macro':
+            return instr.dst;
+        default:
+            return null;
+    }
+}
+function getUsedTemps(instr) {
+    const temps = [];
+    const addOp = (op) => { if (op.kind === 'temp')
+        temps.push(op.name); };
+    switch (instr.kind) {
+        case 'copy':
+        case 'neg':
+        case 'not':
+            addOp(instr.src);
+            break;
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'cmp':
+        case 'and':
+        case 'or':
+            addOp(instr.a);
+            addOp(instr.b);
+            break;
+        case 'nbt_write':
+            addOp(instr.src);
+            break;
+        case 'call':
+            instr.args.forEach(addOp);
+            break;
+        case 'call_macro':
+            instr.args.forEach(a => addOp(a.value));
+            break;
+        case 'branch':
+            addOp(instr.cond);
+            break;
+        case 'return':
+            if (instr.value)
+                addOp(instr.value);
+            break;
+    }
+    return temps;
+}
+//# sourceMappingURL=dce.js.map

package/dist/src2/optimizer/pipeline.d.ts

@@ -0,0 +1,10 @@
+/**
+ * MIR Optimization Pipeline — runs all passes to a fixpoint.
+ *
+ * Each pass is a function MIRFunction → MIRFunction.
+ * The pipeline iterates until no pass changes the function (fixpoint).
+ */
+import type { MIRFunction, MIRModule } from '../mir/types';
+export type Pass = (fn: MIRFunction) => MIRFunction;
+export declare function optimizeFunction(fn: MIRFunction, passes?: Pass[]): MIRFunction;
+export declare function optimizeModule(mod: MIRModule, passes?: Pass[]): MIRModule;

package/dist/src2/optimizer/pipeline.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * MIR Optimization Pipeline — runs all passes to a fixpoint.
+ *
+ * Each pass is a function MIRFunction → MIRFunction.
+ * The pipeline iterates until no pass changes the function (fixpoint).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeFunction = optimizeFunction;
+exports.optimizeModule = optimizeModule;
+const constant_fold_1 = require("./constant_fold");
+const copy_prop_1 = require("./copy_prop");
+const dce_1 = require("./dce");
+const block_merge_1 = require("./block_merge");
+const branch_simplify_1 = require("./branch_simplify");
+const defaultPasses = [
+    constant_fold_1.constantFold,
+    copy_prop_1.copyProp,
+    branch_simplify_1.branchSimplify,
+    dce_1.dce,
+    block_merge_1.blockMerge,
+];
+const MAX_ITERATIONS = 20;
+function optimizeFunction(fn, passes = defaultPasses) {
+    let current = fn;
+    for (let i = 0; i < MAX_ITERATIONS; i++) {
+        const before = JSON.stringify(current);
+        for (const pass of passes) {
+            current = pass(current);
+        }
+        if (JSON.stringify(current) === before)
+            break;
+    }
+    return current;
+}
+function optimizeModule(mod, passes) {
+    return {
+        ...mod,
+        functions: mod.functions.map(fn => optimizeFunction(fn, passes)),
+    };
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/swap_test.map.json

@@ -0,0 +1,14 @@
+{
+  "$b": "a",
+  "$d": "b",
+  "$f": "p0",
+  "$g": "p1",
+  "$h": "x",
+  "$i": "y",
+  "$k": "tmp",
+  "$n": "m",
+  "$a": "const:0",
+  "$c": "internal:p0",
+  "$e": "internal:p1",
+  "$m": "internal:ret"
+}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/cli.ts","../src/compile.ts","../src/index.ts","../src/repl.ts","../src/__tests__/cli.test.ts","../src/__tests__/codegen.test.ts","../src/__tests__/compile-all.test.ts","../src/__tests__/dce.test.ts","../src/__tests__/diagnostics.test.ts","../src/__tests__/e2e.test.ts","../src/__tests__/entity-types.test.ts","../src/__tests__/formatter.test.ts","../src/__tests__/lexer.test.ts","../src/__tests__/lowering.test.ts","../src/__tests__/macro.test.ts","../src/__tests__/mc-integration.test.ts","../src/__tests__/mc-syntax.test.ts","../src/__tests__/nbt.test.ts","../src/__tests__/optimizer-advanced.test.ts","../src/__tests__/optimizer.test.ts","../src/__tests__/parser.test.ts","../src/__tests__/repl.test.ts","../src/__tests__/runtime.test.ts","../src/__tests__/stdlib-advanced.test.ts","../src/__tests__/stdlib-bigint.test.ts","../src/__tests__/stdlib-math.test.ts","../src/__tests__/stdlib-vec.test.ts","../src/__tests__/structure-optimizer.test.ts","../src/__tests__/typechecker.test.ts","../src/__tests__/var-allocator.test.ts","../src/ast/types.ts","../src/builtins/metadata.ts","../src/codegen/var-allocator.ts","../src/codegen/cmdblock/index.ts","../src/codegen/mcfunction/index.ts","../src/codegen/structure/index.ts","../src/diagnostics/index.ts","../src/events/types.ts","../src/formatter/index.ts","../src/ir/builder.ts","../src/ir/types.ts","../src/lexer/index.ts","../src/lowering/index.ts","../src/mc-test/client.ts","../src/mc-test/runner.ts","../src/mc-test/setup.ts","../src/mc-validator/index.ts","../src/nbt/index.ts","../src/optimizer/commands.ts","../src/optimizer/dce.ts","../src/optimizer/passes.ts","../src/optimizer/structure.ts","../src/parser/index.ts","../src/runtime/index.ts","../src/typechecker/index.ts","../src/types/entity-hierarchy.ts","../src2/__tests__/e2e/basic.test.ts","../src2/__tests__/e2e/macros.test.ts","../src2/__tests__/e2e/migrate.test.ts","../src2/__tests__/hir/desugar.test.ts","../src2/__tests__/lir/lower.test.ts","../src2/__tests__/lir/types.test.ts","../src2/__tests__/lir/verify.test.ts","../src2/__tests__/mir/arithmetic.test.ts","../src2/__tests__/mir/control-flow.test.ts","../src2/__tests__/mir/verify.test.ts","../src2/__tests__/optimizer/block_merge.test.ts","../src2/__tests__/optimizer/branch_simplify.test.ts","../src2/__tests__/optimizer/constant_fold.test.ts","../src2/__tests__/optimizer/copy_prop.test.ts","../src2/__tests__/optimizer/dce.test.ts","../src2/__tests__/optimizer/pipeline.test.ts","../src2/emit/compile.ts","../src2/emit/index.ts","../src2/hir/lower.ts","../src2/hir/types.ts","../src2/lir/lower.ts","../src2/lir/types.ts","../src2/lir/verify.ts","../src2/mir/lower.ts","../src2/mir/macro.ts","../src2/mir/types.ts","../src2/mir/verify.ts","../src2/optimizer/block_merge.ts","../src2/optimizer/branch_simplify.ts","../src2/optimizer/constant_fold.ts","../src2/optimizer/copy_prop.ts","../src2/optimizer/dce.ts","../src2/optimizer/pipeline.ts"],"version":"5.9.3"}

package/dist/typechecker/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * RedScript Type Checker
+ *
+ * Performs basic type checking between Parser and Lowering phases.
+ * Collects errors but doesn't block compilation (warn mode).
+ */
+import type { Program } from '../ast/types';
+import { DiagnosticError } from '../diagnostics';
+export declare class TypeChecker {
+    private collector;
+    private functions;
+    private implMethods;
+    private structs;
+    private enums;
+    private consts;
+    private currentFn;
+    private currentReturnType;
+    private scope;
+    private selfTypeStack;
+    private readonly richTextBuiltins;
+    constructor(source?: string, filePath?: string);
+    private getNodeLocation;
+    private report;
+    /**
+     * Type check a program. Returns collected errors.
+     */
+    check(program: Program): DiagnosticError[];
+    private checkFunction;
+    private checkFunctionDecorators;
+    private checkBlock;
+    private checkStmt;
+    private checkLetStmt;
+    private checkReturnStmt;
+    private checkExpr;
+    private checkCallExpr;
+    private checkRichTextBuiltinCall;
+    private checkInvokeExpr;
+    private checkFunctionCallArgs;
+    private checkTpCall;
+    private checkMemberExpr;
+    private checkStaticCallExpr;
+    private checkLambdaExpr;
+    private checkIfBranches;
+    private getThenBranchNarrowing;
+    private inferType;
+    private inferLambdaType;
+    /** Infer entity type from a selector */
+    private inferEntityTypeFromSelector;
+    private resolveInstanceMethod;
+    /** Check if childType is a subtype of parentType */
+    private isEntitySubtype;
+    /** Push a new self type context */
+    private pushSelfType;
+    /** Pop self type context */
+    private popSelfType;
+    /** Get current @s type */
+    private getCurrentSelfType;
+    private typesMatch;
+    private typeToString;
+    private normalizeType;
+}