@awayfl/avm2/dist/lib/abc/lazy/Traits.d.ts

Virtual machine for executing AS3 code

import { TraitInfo } from './TraitInfo';
import { IndentingWriter } from '@awayfl/swf-loader';
import { Multiname } from './Multiname';
import { RuntimeTraits } from './RuntimeTraits';
import { Namespace } from './Namespace';
import { Scope } from '../../run/Scope';
import { ILocalInfo } from './ILocalInfo';
/**
 * The Traits class represents the collection of compile-time traits associated with a type.
 * It's not used for runtime name resolution on instances; instead, the combined traits for
 * a type and all its super types is resolved and translated to an instance of RuntimeTraits.
 */
export declare class Traits {
    readonly traits: TraitInfo[];
    private _multinames;
    constructor(traits: TraitInfo[], global?: boolean);
    attachHolder(holder: ILocalInfo): void;
    trace(writer?: IndentingWriter): void;
    private static _globalMultinames;
    static getGlobalTrait(mn: Multiname): TraitInfo;
    getTrait(mn: Multiname): TraitInfo;
    /**
     * Turns a list of compile-time traits into runtime traits with resolved bindings.
     *
     * Runtime traits are stored in 2-dimensional maps. The outer dimension is keyed on the
     * trait's local name. The inner dimension is a map of mangled namespace names to traits.
     *
     * Lookups are thus O(n) in the number of namespaces present in the query, instead of O(n+m)
     * in the number of traits (n) on the type times the number of namespaces present in the
     * query (m).
     *
     * Negative result note: an implementation with ECMAScript Maps with Namespace objects as
     * keys was tried and found to be much slower than the Object-based one implemented here.
     * Mostly, the difference was in how well accesses are optimized in JS engines, with Maps
     * being new-ish and less well-optimized.
     *
     * Additionally, all protected traits get added to a map with their unqualified name as key.
     * That map is created with the super type's map on its prototype chain. If a type overrides
     * a protected trait, it gets set as that type's value for the unqualified name. Additionally,
     * its name is canonicalized to use the namespace used in the initially introducing type.
     * During name lookup, we first check for a hit in that map and (after verifying that the mn
     * has a correct protected name in its namespaces set) return the most recent trait. That way,
     * all lookups always get the most recent trait, even if they originate from a super class.
     */
    resolveRuntimeTraits(superTraits: RuntimeTraits, protectedNs: Namespace, scope: Scope, forceNativeMethods?: boolean): RuntimeTraits;
}
//# sourceMappingURL=Traits.d.ts.map