swf-toolkit 0.0.0-stage → 0.1.0

package/dist/cjs/compiler/class-compiler.js

@@ -0,0 +1,440 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileClassSource = compileClassSource;
+const abc_file_js_1 = require("../abc/abc-file.js");
+const constants_js_1 = require("../abc/constants.js");
+const code_js_1 = require("../abc/code.js");
+const analysis_js_1 = require("../abc/analysis.js");
+const interner_js_1 = require("../abc/interner.js");
+const opcodes_js_1 = require("../abc/opcodes.js");
+const class_printer_js_1 = require("../decompiler/class-printer.js");
+const codegen_js_1 = require("./codegen.js");
+const lexer_js_1 = require("./lexer.js");
+const parser_js_1 = require("./parser.js");
+const scope_js_1 = require("./scope.js");
+function normalizedSpan(src, span) {
+    try {
+        return (0, lexer_js_1.tokenize)(src.slice(span[0], span[1]))
+            .map((t) => `${t.kind}:${t.value}${t.flags ?? ''}`)
+            .join(' ');
+    }
+    catch {
+        return src.slice(span[0], span[1]);
+    }
+}
+function memberKey(m) {
+    if (m.k === 'field')
+        return `${m.isStatic ? 's' : 'i'}:field:${m.name}`;
+    if (m.k === 'static')
+        return 'static-block';
+    return `${m.isStatic ? 's' : 'i'}:${m.kind}:${m.name}`;
+}
+const TRAIT_KIND = { method: constants_js_1.TraitKind.Method, get: constants_js_1.TraitKind.Getter, set: constants_js_1.TraitKind.Setter };
+function isConstant(e) {
+    return e.k === 'num' || e.k === 'str' || e.k === 'bool' || e.k === 'null' || e.k === 'undefined' || (e.k === 'id' && (e.name === 'NaN' || e.name === 'Infinity'));
+}
+/** Compiles every class in `source` into `abc`. */
+function compileClassSource(abc, source, options = {}) {
+    const unit = (0, parser_js_1.parseAs3)(source, options.source);
+    const pool = options.interner ?? new interner_js_1.Interner(abc);
+    const result = { changes: [] };
+    for (const cls of unit.classes) {
+        const qualified = unit.package ? `${unit.package}.${cls.name}` : cls.name;
+        let ci = options.classIndex !== undefined && unit.classes.length === 1 ? options.classIndex : abc.findClass(qualified);
+        if (options.classIndex !== undefined && abc.className(ci) !== qualified) {
+            throw new lexer_js_1.CompileError(`Class index ${ci} is ${abc.className(ci)}, not ${qualified}`, cls.pos.line, cls.pos.col, options.source);
+        }
+        let isNew = false;
+        if (ci < 0) {
+            ci = createClass(abc, pool, unit, cls, options);
+            isNew = true;
+            result.changes.push({ className: qualified, member: '<class>', action: 'added' });
+        }
+        let baselineMembers = new Map();
+        if (isNew) {
+            // Everything is new; only the default constructor / cinit exist.
+            baselineMembers.set('static-block', '');
+        }
+        else if (options.baseline !== null) {
+            const baseText = options.baseline ?? (0, class_printer_js_1.decompileClass)(abc, ci);
+            try {
+                const baseUnit = (0, parser_js_1.parseAs3)(baseText);
+                const baseCls = baseUnit.classes.find((c) => c.name === cls.name);
+                if (baseCls)
+                    baselineMembers = memberTexts(baseText, baseCls);
+            }
+            catch {
+                baselineMembers = new Map();
+            }
+        }
+        compileIntoClass(abc, pool, unit, cls, ci, source, baselineMembers, options, result);
+    }
+    return result;
+}
+function memberTexts(src, cls) {
+    const map = new Map();
+    const statics = [];
+    for (const m of cls.members) {
+        const text = normalizedSpan(src, m.span);
+        if (m.k === 'static')
+            statics.push(text);
+        else if (m.k === 'field' && m.isStatic) {
+            map.set(memberKey(m), text);
+            // Only non-constant initialisers run in the static initialiser.
+            if (m.init && !isConstant(m.init))
+                statics.push(text);
+        }
+        else
+            map.set(memberKey(m), text);
+    }
+    map.set('static-block', statics.join('\n'));
+    return map;
+}
+function compileIntoClass(abc, pool, unit, cls, ci, src, baseline, options, result) {
+    const inst = abc.instances[ci];
+    const klass = abc.classes[ci];
+    const className = abc.className(ci);
+    const memberNames = new Set();
+    for (const t of [...inst.traits, ...klass.traits])
+        memberNames.add(abc.multinameName(t.name));
+    for (const m of cls.members)
+        if (m.k !== 'static')
+            memberNames.add(m.name);
+    const scope = (0, scope_js_1.buildClassScope)({
+        abc,
+        pool,
+        pkg: unit.package,
+        imports: unit.imports,
+        useNamespaces: unit.useNamespaces,
+        classIndex: ci,
+        memberNames,
+        source: options.source,
+    });
+    const edited = memberTexts(src, cls);
+    const changed = (m) => baseline.get(memberKey(m)) !== edited.get(memberKey(m));
+    // Scope depths taken from existing bodies.
+    const iinitBody = abc.methodBody(inst.iinit);
+    const cinitBody = abc.methodBody(klass.cinit);
+    const instanceDepth = iinitBody?.initScopeDepth ?? (cinitBody ? cinitBody.initScopeDepth + 1 : 1);
+    const findTrait = (traits, name, kinds) => traits.find((t) => kinds.includes(t.kind) && abc.multinameName(t.name) === name);
+    // ---- Fields --------------------------------------------------------------
+    const newInstanceInits = [];
+    for (const m of cls.members) {
+        if (m.k !== 'field')
+            continue;
+        const traits = m.isStatic ? klass.traits : inst.traits;
+        const existing = findTrait(traits, m.name, [constants_js_1.TraitKind.Slot, constants_js_1.TraitKind.Const]);
+        if (existing && !changed(m))
+            continue;
+        const typeName = m.type ? scope.resolveType(m.type) : 0;
+        const fc = new codegen_js_1.FunctionCompiler(scope, { params: [], pos: m.pos }, { initScopeDepth: 0 });
+        const value = m.init && isConstant(m.init) ? fc.constantValue(m.init) : undefined;
+        if (existing) {
+            existing.typeName = typeName;
+            existing.kind = m.isConst ? constants_js_1.TraitKind.Const : constants_js_1.TraitKind.Slot;
+            existing.valueKind = value?.kind ?? 0;
+            existing.valueIndex = value ? value.value || 0 : 0;
+            if (value && value.value === 0 && value.kind !== 0)
+                existing.valueIndex = value.kind;
+            result.changes.push({ className, member: m.name, action: 'replaced' });
+        }
+        else {
+            const ns = nsFor(scope, m.isStatic && m.access === 'protected' ? 'static protected' : m.access, inst.protectedNs, m.pos);
+            const t = (0, abc_file_js_1.newTrait)({ kind: m.isConst ? constants_js_1.TraitKind.Const : constants_js_1.TraitKind.Slot, name: pool.qname(ns, m.name), typeName });
+            if (value) {
+                t.valueKind = value.kind;
+                t.valueIndex = value.value || value.kind;
+            }
+            traits.push(t);
+            result.changes.push({ className, member: m.name, action: 'added' });
+        }
+        if (m.init && !isConstant(m.init) && !m.isStatic)
+            newInstanceInits.push(m);
+    }
+    // ---- Static initialiser --------------------------------------------------
+    const staticChanged = baseline.get('static-block') !== edited.get('static-block');
+    if (staticChanged) {
+        const body = [];
+        for (const m of cls.members) {
+            if (m.k === 'static')
+                body.push(...m.body);
+            else if (m.k === 'field' && m.isStatic && m.init && !isConstant(m.init)) {
+                body.push({ k: 'expr', pos: m.pos, e: { k: 'assign', op: '', target: { k: 'id', name: m.name, pos: m.pos }, v: m.init, pos: m.pos } });
+            }
+        }
+        const staticConsts = new Set();
+        for (const t of klass.traits)
+            if (t.kind === constants_js_1.TraitKind.Const)
+                staticConsts.add(abc.multinameName(t.name));
+        const fc = new codegen_js_1.FunctionCompiler(scope, { params: [], body, pos: cls.pos }, {
+            constTargets: staticConsts,
+            methodIndex: klass.cinit,
+            initScopeDepth: cinitBody?.initScopeDepth ?? Math.max(0, instanceDepth - 1),
+            name: '',
+        });
+        fc.compile();
+        result.changes.push({ className, member: '<static initializer>', action: 'replaced', methodIndex: klass.cinit });
+    }
+    // ---- Methods -------------------------------------------------------------
+    const instanceConsts = new Set();
+    for (const t of inst.traits)
+        if (t.kind === constants_js_1.TraitKind.Const)
+            instanceConsts.add(abc.multinameName(t.name));
+    /** Instance field initialisers run at the start of the constructor, before `super()` (as ASC does). */
+    const fieldInitPrologue = (f) => {
+        for (const fld of newInstanceInits) {
+            f.emit(opcodes_js_1.Op.getlocal0);
+            f.expr(fld.init);
+            if (fld.type)
+                f.coerceTo(scope.resolveType(fld.type));
+            f.emit(opcodes_js_1.Op.initproperty, f.mn(fld.name));
+        }
+    };
+    const compileConstructor = (fn) => {
+        const fc = new codegen_js_1.FunctionCompiler(scope, fn, {
+            constTargets: instanceConsts,
+            methodIndex: inst.iinit,
+            initScopeDepth: instanceDepth,
+            name: abc.strings[abc.methods[inst.iinit]?.name ?? 0] ?? '',
+            isConstructor: true,
+            prologue: fieldInitPrologue,
+        });
+        fc.compile();
+        result.changes.push({ className, member: '<constructor>', action: 'replaced', methodIndex: inst.iinit });
+    };
+    const hasConstructor = cls.members.some((m) => m.k === 'method' && m.kind === 'constructor');
+    if (!hasConstructor && newInstanceInits.length > 0 && !cls.isInterface) {
+        // No constructor in the source: synthesise the implicit one so the
+        // initialisers are not lost. Only safe when the existing constructor is
+        // the compiler-generated default (always true for new classes).
+        if (!isDefaultConstructor(abc, inst.iinit)) {
+            const f = newInstanceInits[0];
+            throw new lexer_js_1.CompileError(`Field '${f.name}' has an initialiser that must run in the constructor, but the source of ${className} has no constructor ` +
+                'and the existing one contains code. Add the constructor to the source.', f.pos.line, f.pos.col, options.source);
+        }
+        compileConstructor({ params: [], body: [], pos: cls.pos });
+    }
+    for (const m of cls.members) {
+        if (m.k !== 'method')
+            continue;
+        if (m.kind === 'constructor') {
+            if (!changed(m) && newInstanceInits.length === 0)
+                continue;
+            compileConstructor(m.fn);
+            continue;
+        }
+        if (!changed(m))
+            continue;
+        // Never replace bytecode with the empty body of a method the decompiler could not handle.
+        if (src.slice(m.span[0], m.span[1]).includes('// Decompilation failed') && !(m.fn.body ?? []).length)
+            continue;
+        if (cls.isInterface) {
+            const kind = TRAIT_KIND[m.kind];
+            if (findTrait(inst.traits, m.name, [kind]))
+                continue;
+            const sig = new codegen_js_1.FunctionCompiler(scope, { ...m.fn, body: undefined }, { initScopeDepth: 0, name: m.name }).method;
+            const idx = abc.methods.length;
+            abc.methods.push(sig);
+            const ifaceNs = pool.namespace(constants_js_1.NamespaceKind.Namespace, unit.package ? `${unit.package}:${cls.name}` : cls.name);
+            inst.traits.push((0, abc_file_js_1.newTrait)({ kind, name: pool.qname(ifaceNs, m.name), method: idx }));
+            result.changes.push({ className, member: describe(m), action: 'added', methodIndex: idx });
+            continue;
+        }
+        if (m.isNative || !m.fn.body) {
+            throw new lexer_js_1.CompileError(`Method ${m.name} has no body`, m.pos.line, m.pos.col, options.source);
+        }
+        const traits = m.isStatic ? klass.traits : inst.traits;
+        const kind = TRAIT_KIND[m.kind];
+        const existing = findTrait(traits, m.name, [kind]);
+        const depthFromExisting = existing ? abc.methodBody(existing.method)?.initScopeDepth : undefined;
+        const fc = new codegen_js_1.FunctionCompiler(scope, m.fn, {
+            methodIndex: existing?.method,
+            initScopeDepth: depthFromExisting ?? instanceDepth,
+            name: m.name,
+        });
+        const idx = fc.compile();
+        if (existing) {
+            result.changes.push({ className, member: describe(m), action: 'replaced', methodIndex: idx });
+        }
+        else {
+            const ns = nsFor(scope, m.isStatic && m.access === 'protected' ? 'static protected' : m.access, inst.protectedNs, m.pos);
+            const t = (0, abc_file_js_1.newTrait)({ kind, name: pool.qname(ns, m.name), method: idx });
+            if (m.isOverride)
+                t.attrs |= constants_js_1.TraitAttr.Override;
+            if (m.isFinal)
+                t.attrs |= constants_js_1.TraitAttr.Final;
+            traits.push(t);
+            result.changes.push({ className, member: describe(m), action: 'added', methodIndex: idx });
+        }
+    }
+}
+/**
+ * True when the constructor only does `super()` (what compilers generate for
+ * classes without an explicit constructor).
+ */
+function isDefaultConstructor(abc, methodIndex) {
+    const body = abc.methodBody(methodIndex);
+    if (!body)
+        return true;
+    let items;
+    try {
+        items = (0, code_js_1.decodeCode)(body.code, body.exceptions).items;
+    }
+    catch {
+        return false;
+    }
+    if (items.some((i) => i.type === 'bytes'))
+        return false;
+    const ignored = new Set([opcodes_js_1.Op.label, opcodes_js_1.Op.nop, opcodes_js_1.Op.debug, opcodes_js_1.Op.debugline, opcodes_js_1.Op.debugfile, opcodes_js_1.Op.kill]);
+    const seq = items.filter((i) => i.type === 'op' && !ignored.has(i.op));
+    const expected = [opcodes_js_1.Op.getlocal0, opcodes_js_1.Op.pushscope, opcodes_js_1.Op.getlocal0, opcodes_js_1.Op.constructsuper, opcodes_js_1.Op.returnvoid];
+    return seq.length === expected.length && seq.every((i, k) => i.op === expected[k] && (i.op !== opcodes_js_1.Op.constructsuper || i.args[0] === 0));
+}
+function describe(m) {
+    return `${m.isStatic ? 'static ' : ''}${m.kind === 'get' ? 'get ' : m.kind === 'set' ? 'set ' : ''}${m.name}`;
+}
+function nsFor(scope, access, protectedNs, pos) {
+    if (access === 'protected' && !protectedNs)
+        throw new lexer_js_1.CompileError('Class has no protected namespace', pos.line, pos.col, scope.source);
+    try {
+        return (0, scope_js_1.memberNamespace)(scope, access);
+    }
+    catch (e) {
+        throw new lexer_js_1.CompileError(e.message, pos.line, pos.col, scope.source);
+    }
+}
+// ---------------------------------------------------------------------------
+// New classes
+// ---------------------------------------------------------------------------
+/**
+ * Superclass chains (Object first) of classes extended somewhere in the ABC,
+ * harvested from existing script initialisers (`getlex A; pushscope; ... newclass`).
+ */
+function knownChains(abc) {
+    const chains = new Map();
+    for (const s of abc.scripts) {
+        const body = abc.methodBody(s.init);
+        if (!body)
+            continue;
+        let items;
+        try {
+            items = (0, code_js_1.decodeCode)(body.code, body.exceptions).items;
+        }
+        catch {
+            continue;
+        }
+        let chain = [];
+        for (const it of items) {
+            if (it.type !== 'op')
+                continue;
+            if (it.op === opcodes_js_1.Op.getlex)
+                chain.push(it.args[0]);
+            else if (it.op === opcodes_js_1.Op.newclass) {
+                // Last getlex is the base class value itself (pushed again for newclass).
+                const unique = chain.filter((x, i) => i === 0 || x !== chain[i - 1]);
+                if (unique.length)
+                    chains.set(abc.qualifiedName(unique[unique.length - 1]), unique);
+                const inst = abc.instances[it.args[0]];
+                if (inst)
+                    chains.set(abc.qualifiedName(inst.name), [...unique, inst.name]);
+                chain = [];
+            }
+            else if (it.op === opcodes_js_1.Op.popscope || it.op === opcodes_js_1.Op.initproperty)
+                chain = [];
+        }
+    }
+    return chains;
+}
+function createClass(abc, pool, unit, cls, options) {
+    const pkg = unit.package;
+    const nsKind = cls.access === 'internal' ? constants_js_1.NamespaceKind.PackageInternalNs : constants_js_1.NamespaceKind.PackageNamespace;
+    const nameMn = pool.qname(pool.namespace(nsKind, pkg), cls.name);
+    const ci = abc.instances.length;
+    const protectedNs = pool.namespace(constants_js_1.NamespaceKind.ProtectedNamespace, pkg ? `${pkg}:${cls.name}` : cls.name);
+    // Provisional scope (for type resolution of extends / implements).
+    abc.instances.push({ name: nameMn, superName: 0, flags: 0, protectedNs,
+        interfaces: [], iinit: 0, traits: [] });
+    abc.classes.push({ cinit: 0, traits: [] });
+    const scope = (0, scope_js_1.buildClassScope)({
+        abc,
+        pool,
+        pkg,
+        imports: unit.imports,
+        useNamespaces: unit.useNamespaces,
+        classIndex: ci,
+        memberNames: new Set(cls.members.filter((m) => m.k !== 'static').map((m) => m.name)),
+        source: options.source,
+    });
+    const inst = abc.instances[ci];
+    const klass = abc.classes[ci];
+    if (cls.isInterface) {
+        inst.flags = constants_js_1.InstanceFlags.Interface | constants_js_1.InstanceFlags.Sealed;
+        inst.superName = 0;
+        inst.protectedNs = 0;
+    }
+    else {
+        inst.flags = (cls.isDynamic ? 0 : constants_js_1.InstanceFlags.Sealed) | (cls.isFinal ? constants_js_1.InstanceFlags.Final : 0) | constants_js_1.InstanceFlags.ProtectedNs;
+        inst.superName = cls.extends ? scope.resolveType(cls.extends) : pool.qname(pool.namespace(constants_js_1.NamespaceKind.PackageNamespace, ''), 'Object');
+    }
+    inst.interfaces = cls.implements.map((t) => scope.resolveType(t));
+    // Superclass chain for the script initialiser.
+    const objectMn = pool.qname(pool.namespace(constants_js_1.NamespaceKind.PackageNamespace, ''), 'Object');
+    let chain;
+    if (cls.isInterface)
+        chain = [];
+    else {
+        const known = knownChains(abc).get(abc.qualifiedName(inst.superName));
+        chain = known ?? (abc.qualifiedName(inst.superName) === 'Object' ? [objectMn] : [objectMn, inst.superName]);
+    }
+    const n = chain.length;
+    // Default constructor and static initialiser (members may replace them).
+    const empty = (isCtor) => new codegen_js_1.FunctionCompiler(scope, { params: [], body: [], pos: cls.pos }, { initScopeDepth: isCtor ? 3 + n : 2 + n, isConstructor: isCtor && !cls.isInterface, name: isCtor ? cls.name : '' });
+    inst.iinit = cls.isInterface ? addSignatureOnly(abc, scope, cls) : empty(true).compile();
+    klass.cinit = empty(false).compile();
+    // Script initialiser.
+    const items = [];
+    const op = (code, ...args) => {
+        items.push((0, code_js_1.insn)(code, args));
+    };
+    op(opcodes_js_1.Op.getlocal0);
+    op(opcodes_js_1.Op.pushscope);
+    op(opcodes_js_1.Op.getscopeobject, 0);
+    if (cls.isInterface)
+        op(opcodes_js_1.Op.pushnull);
+    else {
+        for (const c of chain) {
+            op(opcodes_js_1.Op.getlex, c);
+            op(opcodes_js_1.Op.pushscope);
+        }
+        op(opcodes_js_1.Op.getlex, inst.superName);
+    }
+    op(opcodes_js_1.Op.newclass, ci);
+    for (let i = 0; i < n; i++)
+        op(opcodes_js_1.Op.popscope);
+    op(opcodes_js_1.Op.initproperty, nameMn);
+    op(opcodes_js_1.Op.returnvoid);
+    const encoded = (0, code_js_1.encodeCode)(items);
+    const limits = (0, analysis_js_1.computeLimits)(abc, items);
+    const initMethod = abc.methods.length;
+    abc.methods.push({ paramTypes: [], returnType: 0, name: 0, flags: 0, optional: [], paramNames: [] });
+    abc.bodies.push({
+        method: initMethod,
+        maxStack: limits.maxStack,
+        localCount: 1,
+        initScopeDepth: 1,
+        maxScopeDepth: 1 + limits.maxScope,
+        code: encoded.code,
+        exceptions: [],
+        traits: [],
+    });
+    // Keep the last script last: it is the entry point executed when the ABC loads.
+    const script = { init: initMethod, traits: [(0, abc_file_js_1.newTrait)({ kind: constants_js_1.TraitKind.Class, name: nameMn, id: 1, classIndex: ci })] };
+    abc.scripts.splice(Math.max(0, abc.scripts.length - 1), 0, script);
+    return ci;
+}
+/** Interfaces have an iinit without a body. */
+function addSignatureOnly(abc, scope, cls) {
+    const idx = abc.methods.length;
+    abc.methods.push({ paramTypes: [], returnType: 0, name: scope.pool.string(cls.name), flags: 0, optional: [], paramNames: [] });
+    return idx;
+}

package/dist/cjs/compiler/codegen.d.ts

@@ -0,0 +1,144 @@
+/**
+ * AS3 → AVM2 bytecode generation for method bodies.
+ *
+ * Name resolution strategy: locals and parameters are resolved statically to
+ * registers (or activation slots when closures capture them). Every other
+ * name is emitted as a `Multiname(name, openNamespaces)` and resolved by the
+ * VM at runtime through the scope chain, exactly as the Flex compiler does
+ * for names it cannot bind early. Type annotations are resolved to QNames.
+ */
+import type { AbcFile, MethodInfo } from '../abc/abc-file.js';
+import { type CodeItem } from '../abc/code.js';
+import type { Interner } from '../abc/interner.js';
+import type { Expr, FunctionDef, Pos, Stmt, TypeRef } from './ast.js';
+import { CompileError } from './lexer.js';
+/** Names of top-level (public, unnamed package) classes and functions of the Flash runtime. */
+export declare const TOPLEVEL_NAMES: Set<string>;
+export interface ClassScope {
+    abc: AbcFile;
+    pool: Interner;
+    /** Package of the compilation unit. */
+    pkg: string;
+    /** Namespace set used for unqualified / runtime names. */
+    openNsSet: number;
+    /** Namespace indices referenced by `ns` names (private, protected, custom...). */
+    namespaceByName(name: string): number | undefined;
+    /** QName / TypeName for a type annotation. */
+    resolveType(t: TypeRef): number;
+    /** Resolve a short or dotted name used as a value (class reference etc.); undefined = runtime lookup. */
+    resolveName(name: string): number | undefined;
+    source?: string;
+}
+export interface FunctionOptions {
+    /** Index to replace; omitted = append a new method. */
+    methodIndex?: number;
+    initScopeDepth: number;
+    /** Debug name stored in MethodInfo.name. */
+    name?: string;
+    /** Constructor: emits an implicit `super()` call when the body has none. */
+    isConstructor?: boolean;
+    /** Static initialiser / constructor field initialisers to run first. */
+    prologue?: (fc: FunctionCompiler) => void;
+    /** Names of const members that this function initialises (assignments use initproperty). */
+    constTargets?: ReadonlySet<string>;
+}
+/** Compiles one function (method, accessor, constructor or closure). */
+export declare class FunctionCompiler {
+    readonly scope: ClassScope;
+    readonly fn: FunctionDef;
+    readonly options: FunctionOptions;
+    readonly items: CodeItem[];
+    private nextLabelId;
+    private exceptions;
+    private locals;
+    private nextReg;
+    private freeTemps;
+    private loops;
+    private activationReg;
+    private activationTraits;
+    private needsActivation;
+    /** Pending label for the next loop/switch statement. */
+    private pendingLabel;
+    private scopeDepth;
+    readonly method: MethodInfo;
+    constructor(scope: ClassScope, fn: FunctionDef, options: FunctionOptions);
+    err(msg: string, pos?: Pos): CompileError;
+    newLabel(): number;
+    place(label: number): void;
+    emit(op: number, ...args: number[]): void;
+    jump(op: number, label: number): void;
+    private temp;
+    private release;
+    private getReg;
+    private setReg;
+    private declare;
+    private get pool();
+    /** Runtime-resolved name: Multiname(name, open namespaces). */
+    mn(name: string): number;
+    /** Attribute multiname (`@name`). */
+    private mnAttr;
+    /** Late-bound multiname for `obj[expr]`. */
+    private mnLate;
+    /** Name with an explicit namespace (`ns::name`). */
+    private mnQualified;
+    private publicQName;
+    /** Default value for optional parameters / slots. */
+    constantValue(e: Expr): {
+        kind: number;
+        value: number;
+    };
+    /** Compiles the function and installs it in the ABC. Returns the method index. */
+    compile(): number;
+    /** Pushes the default value of a typed local, or returns undefined if none is needed. */
+    private defaultFor;
+    private compileClosure;
+    private lookupLocal;
+    private loadLocal;
+    /** Stores the value on top of the stack into a local (consumes it). */
+    private storeLocal;
+    /** Emits the coercion ASC would insert when storing into a typed location. */
+    coerceTo(type: number): void;
+    private stmts;
+    stmt(s: Stmt): void;
+    private loop;
+    private forIn;
+    /** Compiles `switch` the way ASC does: case bodies first, then a dispatcher feeding lookupswitch. */
+    private switchStmt;
+    private finallyStack;
+    /** Extra scopes (with / catch) currently open: loop depth when pushed and the register holding the object. */
+    private extraScopes;
+    /** Re-establishes the scope stack at an exception handler (the VM clears it). */
+    private restoreScopes;
+    private tryStmt;
+    /** Inlines pending finally blocks when control leaves them via return/break/continue. */
+    private runFinallies;
+    private pushNumber;
+    /** Multiname for a property access expression (member / index / descendants). */
+    private propertyName;
+    /** Name used to look up a bare identifier. */
+    private identName;
+    expr(e: Expr): void;
+    /** Pushes a type as a value (for `as`, `is`, `Vector.<T>`). */
+    private typeValue;
+    /** Evaluates `e` for its side effects only. */
+    exprDiscard(e: Expr): void;
+    private args;
+    private call;
+    private newExpr;
+    private unary;
+    /**
+     * Generic read-modify-write on an lvalue. `compute` receives the old value on
+     * the stack and must leave the new value. When `wantValue`, `resultOld`
+     * selects whether the old (postfix) or new value is left on the stack.
+     */
+    private modify;
+    private update;
+    /** Stores the value on top of the stack into an lvalue (consumes it). */
+    storeTo(target: Expr): void;
+    private assign;
+    private binary;
+    /** Jumps to `label` when `e` is truthy (`onTrue`) or falsy. */
+    condJump(e: Expr, onTrue: boolean, label: number): void;
+    /** E4X filter: `xml.(cond)`. */
+    private filter;
+}