vigla 0.0.0 → 0.1.0

package/dist/compiler/analysis/validate/scope.js

@@ -0,0 +1,187 @@
+export class Binding {
+    scope;
+    node;
+    declaration;
+    kind;
+    initial;
+    references = [];
+    reassigned = false;
+    mutated = false;
+    insideRest = false;
+    templateDeclaration = false;
+    constructor(scope, node, kind, declaration, initial) {
+        this.scope = scope;
+        this.node = node;
+        this.kind = kind;
+        this.declaration = declaration;
+        this.initial = initial;
+    }
+    get updated() {
+        return this.mutated || this.reassigned;
+    }
+    isFunction() {
+        if (this.updated)
+            return false;
+        const type = this.initial?.type;
+        return (type === 'ArrowFunctionExpression' ||
+            type === 'FunctionExpression' ||
+            type === 'FunctionDeclaration');
+    }
+}
+export class Scope {
+    parent;
+    porous;
+    depth;
+    declarations = new Map();
+    references = new Map();
+    #duplicate;
+    constructor(parent, porous, duplicate) {
+        this.parent = parent;
+        this.porous = porous;
+        this.depth = parent === null ? 0 : parent.depth + (porous ? 0 : 1);
+        this.#duplicate = duplicate;
+    }
+    child(porous = false) {
+        return new Scope(this, porous, this.#duplicate);
+    }
+    declare(node, kind, declaration, initial = null) {
+        if (this.parent !== null) {
+            if (declaration === 'var' && this.porous)
+                return this.parent.declare(node, kind, declaration);
+            if (declaration === 'import')
+                return this.parent.declare(node, kind, declaration, initial);
+        }
+        const existing = this.declarations.get(node.name);
+        if (existing !== undefined && existing.declaration !== 'var' && declaration !== 'var') {
+            this.#duplicate(node);
+        }
+        const binding = new Binding(this, node, kind, declaration, initial);
+        this.declarations.set(node.name, binding);
+        return binding;
+    }
+    get(name) {
+        for (let scope = this; scope !== null; scope = scope.parent) {
+            const binding = scope.declarations.get(name);
+            if (binding !== undefined)
+                return binding;
+        }
+        return null;
+    }
+    owner(name) {
+        for (let scope = this; scope !== null; scope = scope.parent) {
+            if (scope.declarations.has(name))
+                return scope;
+        }
+        return null;
+    }
+    reference(reference) {
+        const name = reference.node.name;
+        for (let scope = this; scope !== null; scope = scope.parent) {
+            let list = scope.references.get(name);
+            if (list === undefined)
+                scope.references.set(name, (list = []));
+            list.push(reference);
+            const binding = scope.declarations.get(name);
+            if (binding !== undefined) {
+                binding.references.push(reference);
+                return;
+            }
+        }
+    }
+}
+export function typeOf(node) {
+    if ('type' in node)
+        return node.type;
+    if ('kind' in node)
+        return node.kind;
+    return 'fragment';
+}
+export function isReference(node, parent) {
+    if (node.type === 'MemberExpression')
+        return !node.computed && isReference(node.object, node);
+    if (node.type !== 'Identifier')
+        return false;
+    if (parent === null || parent === undefined)
+        return true;
+    switch (parent.type) {
+        case 'MemberExpression':
+            return parent.computed || node === parent.object;
+        case 'MethodDefinition':
+            return parent.computed;
+        case 'MetaProperty':
+            return parent.meta === node;
+        case 'PropertyDefinition':
+            return parent.computed || node === parent.value;
+        case 'Property':
+            return parent.computed || node === parent.value;
+        case 'ExportSpecifier':
+        case 'ImportSpecifier':
+            return node === parent.local;
+        case 'LabeledStatement':
+        case 'BreakStatement':
+        case 'ContinueStatement':
+            return false;
+        default:
+            return true;
+    }
+}
+export function identifiers(pattern, into = []) {
+    switch (pattern.type) {
+        case 'Identifier':
+            into.push(pattern);
+            break;
+        case 'ObjectPattern':
+            for (const property of pattern.properties) {
+                identifiers(property.type === 'RestElement' ? property : property.value, into);
+            }
+            break;
+        case 'ArrayPattern':
+            for (const element of pattern.elements)
+                if (element !== null)
+                    identifiers(element, into);
+            break;
+        case 'RestElement':
+            identifiers(pattern.argument, into);
+            break;
+        case 'AssignmentPattern':
+            identifiers(pattern.left, into);
+            break;
+        default:
+            break;
+    }
+    return into;
+}
+export function leaves(pattern, into = []) {
+    switch (pattern.type) {
+        case 'ObjectPattern':
+            for (const property of pattern.properties) {
+                leaves(property.type === 'RestElement' ? property : property.value, into);
+            }
+            break;
+        case 'ArrayPattern':
+            for (const element of pattern.elements)
+                if (element !== null)
+                    leaves(element, into);
+            break;
+        case 'RestElement':
+            leaves(pattern.argument, into);
+            break;
+        case 'AssignmentPattern':
+            leaves(pattern.left, into);
+            break;
+        case 'Identifier':
+        case 'MemberExpression':
+            into.push(pattern);
+            break;
+        default:
+            break;
+    }
+    return into;
+}
+export function base(expression) {
+    let node = expression;
+    while (node.type === 'MemberExpression')
+        node = node.object;
+    return node.type === 'Identifier' ? node : null;
+}
+//# sourceMappingURL=scope.js.map

package/dist/compiler/analysis/validate/scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.js","sourceRoot":"","sources":["../../../../src/compiler/analysis/validate/scope.ts"],"names":[],"mappings":"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"}

package/dist/compiler/analysis/validate/scopes.d.ts

@@ -0,0 +1,23 @@
+import type * as ES from 'estree';
+import type * as IR from '../../ir/nodes.ts';
+import type { Runes } from '../../ir/port.ts';
+import { Scope, type Duplicate, type PathNode } from './scope.ts';
+export declare function runeOf(runes: Runes, node: ES.Node | null | undefined): string | null;
+export declare function settle(declarator: ES.VariableDeclarator, scope: Scope, runes: Runes, rune: string | null): void;
+export declare class Scopes {
+    #private;
+    readonly map: Map<object, Scope>;
+    readonly runes: Runes;
+    readonly path: PathNode[];
+    constructor(runes: Runes, duplicate: Duplicate);
+    root(parent: Scope | null): Scope;
+    program(program: ES.Program, scope: Scope): void;
+    declarator(declarator: ES.VariableDeclarator, scope: Scope, kind: ES.VariableDeclaration['kind'], template: boolean): void;
+    es(node: ES.Node, scope: Scope): void;
+    expression(node: ES.Node, scope: Scope): void;
+    fragment(fragment: IR.Fragment, scope: Scope, transparent: boolean): Scope;
+    attribute(attribute: IR.Attribute, scope: Scope): void;
+    node(node: IR.Node, scope: Scope): void;
+    finish(): void;
+}
+//# sourceMappingURL=scopes.d.ts.map

package/dist/compiler/analysis/validate/scopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../../../../src/compiler/analysis/validate/scopes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAKN,KAAK,EAEL,KAAK,SAAS,EACd,KAAK,QAAQ,EAEb,MAAM,YAAY,CAAC;AAapB,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAGpF;AAmCD,wBAAgB,MAAM,CACrB,UAAU,EAAE,EAAE,CAAC,kBAAkB,EACjC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,MAAM,GAAG,IAAI,GACjB,IAAI,CAiBN;AAED,qBAAa,MAAM;;IAClB,QAAQ,CAAC,GAAG,qBAA4B;IACxC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAM;IAK/B,YAAY,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAG7C;IAED,IAAI,CAAC,MAAM,EAAE,KAAK,GAAG,IAAI,GAAG,KAAK,CAEhC;IAED,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAG/C;IAqBD,UAAU,CACT,UAAU,EAAE,EAAE,CAAC,kBAAkB,EACjC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,EACpC,QAAQ,EAAE,OAAO,GACf,IAAI,CAUN;IAED,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAmEpC;IAQD,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAE5C;IAED,QAAQ,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,GAAG,KAAK,CAKzE;IAkBD,SAAS,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAgCrD;IA2DD,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAgFtC;IAED,MAAM,IAAI,IAAI,CAWb;CACD"}

package/dist/compiler/analysis/validate/scopes.js

@@ -0,0 +1,436 @@
+import { children } from '../../ir/estree.js';
+import { base, identifiers, isReference, leaves, Scope } from './scope.js';
+function isCallable(node) {
+    const type = node?.type;
+    return (type === 'FunctionDeclaration' ||
+        type === 'FunctionExpression' ||
+        type === 'ArrowFunctionExpression');
+}
+export function runeOf(runes, node) {
+    if (node?.type !== 'CallExpression')
+        return null;
+    return runes.get(node.callee) ?? null;
+}
+function settleProps(pattern, scope, runes) {
+    if (pattern.type === 'Identifier') {
+        const binding = scope.get(pattern.name);
+        if (binding !== null) {
+            binding.initial = null;
+            binding.kind = 'rest_prop';
+        }
+        return;
+    }
+    if (pattern.type !== 'ObjectPattern')
+        return;
+    for (const property of pattern.properties) {
+        if (property.type === 'RestElement') {
+            for (const id of identifiers(property)) {
+                const binding = scope.get(id.name);
+                if (binding !== null)
+                    binding.kind = 'rest_prop';
+            }
+            continue;
+        }
+        const value = property.value.type === 'AssignmentPattern' ? property.value.left : property.value;
+        if (value.type !== 'Identifier')
+            continue;
+        const binding = scope.get(value.name);
+        if (binding === null)
+            continue;
+        const initial = property.value.type === 'AssignmentPattern' ? property.value.right : null;
+        if (initial?.type === 'CallExpression' && runes.get(initial.callee) === '$bindable') {
+            binding.initial = initial.arguments[0] ?? null;
+            binding.kind = 'bindable_prop';
+        }
+        else {
+            binding.initial = initial;
+        }
+    }
+}
+export function settle(declarator, scope, runes, rune) {
+    const kind = rune === '$state'
+        ? 'state'
+        : rune === '$state.raw'
+            ? 'raw_state'
+            : rune === '$derived' || rune === '$derived.by'
+                ? 'derived'
+                : rune === '$props'
+                    ? 'prop'
+                    : null;
+    if (kind === null)
+        return;
+    for (const id of identifiers(declarator.id)) {
+        const binding = scope.get(id.name);
+        if (binding !== null)
+            binding.kind = kind;
+    }
+    if (rune === '$props')
+        settleProps(declarator.id, scope, runes);
+}
+export class Scopes {
+    map = new Map();
+    runes;
+    path = [];
+    #references = [];
+    #updates = [];
+    #duplicate;
+    constructor(runes, duplicate) {
+        this.runes = runes;
+        this.#duplicate = duplicate;
+    }
+    root(parent) {
+        return parent === null ? new Scope(null, false, this.#duplicate) : parent.child();
+    }
+    program(program, scope) {
+        this.map.set(program, scope);
+        this.es(program, scope);
+    }
+    #params(scope, params) {
+        for (const param of params) {
+            for (const id of identifiers(param)) {
+                scope.declare(id, 'normal', param.type === 'RestElement' ? 'rest_param' : 'param');
+            }
+        }
+    }
+    #children(node, scope) {
+        this.path.push(node);
+        children(node, (child) => this.es(child, scope));
+        this.path.pop();
+    }
+    #scoped(node, scope) {
+        this.map.set(node, scope);
+        this.#children(node, scope);
+    }
+    declarator(declarator, scope, kind, template) {
+        for (const id of identifiers(declarator.id)) {
+            const binding = scope.declare(id, template ? 'template' : 'normal', kind, declarator.init ?? null);
+            binding.templateDeclaration = true;
+        }
+    }
+    es(node, scope) {
+        switch (node.type) {
+            case 'Identifier': {
+                const parent = this.path.at(-1);
+                if (parent !== undefined && isReference(node, parent)) {
+                    this.#references.push([scope, { node, path: this.path.slice() }]);
+                }
+                return;
+            }
+            case 'AssignmentExpression':
+                this.#updates.push([scope, node.left]);
+                break;
+            case 'UpdateExpression':
+                this.#updates.push([scope, node.argument]);
+                break;
+            case 'ImportDeclaration':
+                for (const specifier of node.specifiers)
+                    scope.declare(specifier.local, 'normal', 'import', node);
+                return;
+            case 'FunctionExpression': {
+                const inner = scope.child(true);
+                if (node.id)
+                    inner.declare(node.id, 'normal', 'function');
+                this.#params(inner, node.params);
+                this.#scoped(node, inner);
+                return;
+            }
+            case 'FunctionDeclaration': {
+                if (node.id)
+                    scope.declare(node.id, 'normal', 'function', node);
+                const inner = scope.child(true);
+                this.#params(inner, node.params);
+                this.#scoped(node, inner);
+                return;
+            }
+            case 'ArrowFunctionExpression': {
+                const inner = scope.child(true);
+                this.#params(inner, node.params);
+                this.#scoped(node, inner);
+                return;
+            }
+            case 'ForStatement':
+            case 'ForInStatement':
+            case 'ForOfStatement':
+            case 'SwitchStatement':
+                this.#scoped(node, scope.child(true));
+                return;
+            case 'BlockStatement':
+                this.#scoped(node, scope.child(!isCallable(this.path.at(-1))));
+                return;
+            case 'ClassDeclaration':
+                if (node.id)
+                    scope.declare(node.id, 'normal', 'let', node);
+                break;
+            case 'VariableDeclaration':
+                for (const declarator of node.declarations)
+                    this.declarator(declarator, scope, node.kind, false);
+                break;
+            case 'CatchClause':
+                if (node.param) {
+                    const inner = scope.child(true);
+                    for (const id of identifiers(node.param))
+                        inner.declare(id, 'normal', 'let');
+                    this.#scoped(node, inner);
+                    return;
+                }
+                break;
+            default:
+                break;
+        }
+        this.#children(node, scope);
+    }
+    #within(node, run) {
+        this.path.push(node);
+        run();
+        this.path.pop();
+    }
+    expression(node, scope) {
+        this.es(node, scope);
+    }
+    fragment(fragment, scope, transparent) {
+        const inner = scope.child(transparent);
+        this.map.set(fragment, inner);
+        this.#nodes(fragment, inner);
+        return inner;
+    }
+    #nodes(fragment, scope) {
+        this.#within(fragment, () => {
+            for (const node of fragment.nodes)
+                this.node(node, scope);
+        });
+    }
+    #value(value, scope) {
+        if (value.kind === 'expression')
+            this.expression(value.expression, scope);
+        else if (value.kind === 'text') {
+            for (const part of value.parts) {
+                if (part.kind === 'expression')
+                    this.#within(part, () => this.expression(part.expression, scope));
+            }
+        }
+    }
+    attribute(attribute, scope) {
+        this.#within(attribute, () => {
+            switch (attribute.kind) {
+                case 'attribute':
+                case 'style':
+                    this.#value(attribute.value, scope);
+                    return;
+                case 'spread':
+                case 'class':
+                case 'attachment':
+                    this.expression(attribute.expression, scope);
+                    return;
+                case 'binding':
+                    if (attribute.expression.type !== 'SequenceExpression') {
+                        this.#updates.push([scope, attribute.expression]);
+                    }
+                    this.expression(attribute.expression, scope);
+                    return;
+                case 'action':
+                    this.expression(attribute.action, scope);
+                    if (attribute.argument)
+                        this.expression(attribute.argument, scope);
+                    return;
+                case 'transition':
+                    this.expression(attribute.transition, scope);
+                    if (attribute.argument)
+                        this.expression(attribute.argument, scope);
+                    return;
+                case 'animation':
+                    this.expression(attribute.animation, scope);
+                    if (attribute.argument)
+                        this.expression(attribute.argument, scope);
+                    return;
+            }
+        });
+    }
+    #list(node, scope) {
+        this.expression(node.collection, scope);
+        if (node.fallback)
+            this.fragment(node.fallback, scope, false);
+        const inner = scope.child();
+        this.map.set(node, inner);
+        this.map.set(node.body, inner);
+        if (node.item) {
+            const rest = new Set();
+            collectRest(node.item, false, rest);
+            for (const id of identifiers(node.item)) {
+                const binding = inner.declare(id, 'each', 'const');
+                binding.insideRest = rest.has(id);
+            }
+            this.expression(node.item, inner);
+        }
+        if (node.index) {
+            const keyed = node.kind === 'keyed-list' &&
+                (node.key.type !== 'Identifier' || node.key.name !== node.index.name);
+            inner.declare({ type: 'Identifier', name: node.index.name }, keyed ? 'template' : 'static', 'const', node);
+        }
+        if (node.kind === 'keyed-list')
+            this.expression(node.key, inner);
+        this.#nodes(node.body, inner);
+    }
+    #outcome(outcome, scope) {
+        const body = this.fragment(outcome.body, scope, false);
+        if (outcome.binding === null)
+            return;
+        const value = scope.child();
+        this.map.set(outcome.binding, value);
+        this.expression(outcome.binding, value);
+        for (const id of identifiers(outcome.binding)) {
+            body.declare(id, 'template', 'const');
+            value.declare(id, 'normal', 'const');
+        }
+    }
+    #snippet(node, scope) {
+        scope.declare(node.name, 'normal', 'function', node);
+        const inner = scope.child();
+        this.map.set(node, inner);
+        for (const parameter of node.parameters) {
+            for (const id of identifiers(parameter))
+                inner.declare(id, 'snippet', 'let');
+        }
+        this.expression(node.name, inner);
+        for (const parameter of node.parameters)
+            this.expression(parameter, inner);
+        const body = this.fragment(node.body, inner, false);
+        for (const [name, binding] of body.declarations) {
+            if (inner.declarations.has(name))
+                this.#duplicate(binding.node);
+        }
+    }
+    node(node, scope) {
+        this.#within(node, () => {
+            switch (node.kind) {
+                case 'text':
+                case 'comment':
+                    return;
+                case 'expression':
+                case 'raw-html':
+                    this.expression(node.expression, scope);
+                    return;
+                case 'element':
+                case 'special':
+                case 'boundary':
+                    for (const attribute of node.attributes)
+                        this.attribute(attribute, scope);
+                    this.fragment(node.body, scope, true);
+                    return;
+                case 'dynamic-element':
+                    this.expression(node.tag, scope);
+                    for (const attribute of node.attributes)
+                        this.attribute(attribute, scope);
+                    this.fragment(node.body, scope, true);
+                    return;
+                case 'slot':
+                    for (const attribute of node.attributes)
+                        this.attribute(attribute, scope);
+                    this.fragment(node.fallback, scope, true);
+                    return;
+                case 'component': {
+                    for (const attribute of node.attributes)
+                        this.attribute(attribute, scope);
+                    const inner = scope.child();
+                    this.map.set(node.body, inner);
+                    this.#nodes(node.body, inner);
+                    return;
+                }
+                case 'branch':
+                    for (const arm of node.arms) {
+                        this.expression(arm.test, scope);
+                        this.fragment(arm.body, scope, false);
+                    }
+                    if (node.fallback)
+                        this.fragment(node.fallback, scope, false);
+                    return;
+                case 'keyed-list':
+                case 'unkeyed-list':
+                    this.#list(node, scope);
+                    return;
+                case 'keyed-block':
+                    this.expression(node.key, scope);
+                    this.fragment(node.body, scope, false);
+                    return;
+                case 'async-block':
+                    this.expression(node.promise, scope);
+                    if (node.pending)
+                        this.fragment(node.pending, scope, false);
+                    if (node.resolved)
+                        this.#outcome(node.resolved, scope);
+                    if (node.rejected)
+                        this.#outcome(node.rejected, scope);
+                    return;
+                case 'snippet':
+                    this.#snippet(node, scope);
+                    return;
+                case 'render':
+                    this.expression(node.call, scope);
+                    return;
+                case 'constant':
+                    this.declarator(node.declarator, scope, 'const', true);
+                    this.#within(node.declarator, () => {
+                        this.expression(node.declarator.id, scope);
+                        if (node.declarator.init)
+                            this.expression(node.declarator.init, scope);
+                    });
+                    return;
+                case 'declaration':
+                    this.expression(node.declaration, scope);
+                    return;
+                case 'debug':
+                    for (const identifier of node.identifiers)
+                        this.expression(identifier, scope);
+                    return;
+                case 'title':
+                    for (const part of node.parts) {
+                        if (part.kind === 'expression')
+                            this.#within(part, () => this.expression(part.expression, scope));
+                    }
+                    return;
+            }
+        });
+    }
+    finish() {
+        for (const [scope, reference] of this.#references)
+            scope.reference(reference);
+        for (const [scope, node] of this.#updates) {
+            for (const leaf of leaves(node)) {
+                const left = base(leaf);
+                const binding = left === null ? null : scope.get(left.name);
+                if (binding === null || left === binding.node)
+                    continue;
+                if (left === leaf)
+                    binding.reassigned = true;
+                else
+                    binding.mutated = true;
+            }
+        }
+    }
+}
+function collectRest(pattern, inside, into) {
+    switch (pattern.type) {
+        case 'Identifier':
+            if (inside)
+                into.add(pattern);
+            return;
+        case 'ObjectPattern':
+            for (const property of pattern.properties) {
+                collectRest(property.type === 'RestElement' ? property : property.value, inside, into);
+            }
+            return;
+        case 'ArrayPattern':
+            for (const element of pattern.elements)
+                if (element !== null)
+                    collectRest(element, inside, into);
+            return;
+        case 'RestElement':
+            collectRest(pattern.argument, true, into);
+            return;
+        case 'AssignmentPattern':
+            collectRest(pattern.left, inside, into);
+            return;
+        default:
+            return;
+    }
+}
+//# sourceMappingURL=scopes.js.map