import type {ScopeValueSets, NameValue, ValueScope, ValueScopeName} from "./scope" import {_, nil, _Code, Code, Name, UsedNames, CodeItem, addCodeArg, _CodeOrName} from "./code" import {Scope, varKinds} from "./scope" export {_, str, strConcat, nil, getProperty, stringify, regexpCode, Name, Code} from "./code" export {Scope, ScopeStore, ValueScope, ValueScopeName, ScopeValueSets, varKinds} from "./scope" // type for expressions that can be safely inserted in code without quotes export type SafeExpr = Code | number | boolean | null // type that is either Code of function that adds code to CodeGen instance using its methods export type Block = Code | (() => void) export const operators = { GT: new _Code(">"), GTE: new _Code(">="), LT: new _Code("<"), LTE: new _Code("<="), EQ: new _Code("==="), NEQ: new _Code("!=="), NOT: new _Code("!"), OR: new _Code("||"), AND: new _Code("&&"), ADD: new _Code("+"), } abstract class Node { abstract readonly names: UsedNames optimizeNodes(): this | ChildNode | ChildNode[] | undefined { return this } optimizeNames(_names: UsedNames, _constants: Constants): this | undefined { return this } // get count(): number { // return 1 // } } class Def extends Node { constructor(private readonly varKind: Name, private readonly name: Name, private rhs?: SafeExpr) { super() } render({es5, _n}: CGOptions): string { const varKind = es5 ? varKinds.var : this.varKind const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}` return `${varKind} ${this.name}${rhs};` + _n } optimizeNames(names: UsedNames, constants: Constants): this | undefined { if (!names[this.name.str]) return if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants) return this } get names(): UsedNames { return this.rhs instanceof _CodeOrName ? this.rhs.names : {} } } class Assign extends Node { constructor(readonly lhs: Code, public rhs: SafeExpr, private readonly sideEffects?: boolean) { super() } render({_n}: CGOptions): string { return `${this.lhs} = ${this.rhs};` + _n } optimizeNames(names: UsedNames, constants: Constants): this | undefined { if (this.lhs instanceof Name && !names[this.lhs.str] && !this.sideEffects) return this.rhs = optimizeExpr(this.rhs, names, constants) return this } get names(): UsedNames { const names = this.lhs instanceof Name ? {} : {...this.lhs.names} return addExprNames(names, this.rhs) } } class AssignOp extends Assign { constructor(lhs: Code, private readonly op: Code, rhs: SafeExpr, sideEffects?: boolean) { super(lhs, rhs, sideEffects) } render({_n}: CGOptions): string { return `${this.lhs} ${this.op}= ${this.rhs};` + _n } } class Label extends Node { readonly names: UsedNames = {} constructor(readonly label: Name) { super() } render({_n}: CGOptions): string { return `${this.label}:` + _n } } class Break extends Node { readonly names: UsedNames = {} constructor(readonly label?: Code) { super() } render({_n}: CGOptions): string { const label = this.label ? ` ${this.label}` : "" return `break${label};` + _n } } class Throw extends Node { constructor(readonly error: Code) { super() } render({_n}: CGOptions): string { return `throw ${this.error};` + _n } get names(): UsedNames { return this.error.names } } class AnyCode extends Node { constructor(private code: SafeExpr) { super() } render({_n}: CGOptions): string { return `${this.code};` + _n } optimizeNodes(): this | undefined { return `${this.code}` ? this : undefined } optimizeNames(names: UsedNames, constants: Constants): this { this.code = optimizeExpr(this.code, names, constants) return this } get names(): UsedNames { return this.code instanceof _CodeOrName ? this.code.names : {} } } abstract class ParentNode extends Node { constructor(readonly nodes: ChildNode[] = []) { super() } render(opts: CGOptions): string { return this.nodes.reduce((code, n) => code + n.render(opts), "") } optimizeNodes(): this | ChildNode | ChildNode[] | undefined { const {nodes} = this let i = nodes.length while (i--) { const n = nodes[i].optimizeNodes() if (Array.isArray(n)) nodes.splice(i, 1, ...n) else if (n) nodes[i] = n else nodes.splice(i, 1) } return nodes.length > 0 ? this : undefined } optimizeNames(names: UsedNames, constants: Constants): this | undefined { const {nodes} = this let i = nodes.length while (i--) { // iterating backwards improves 1-pass optimization const n = nodes[i] if (n.optimizeNames(names, constants)) continue subtractNames(names, n.names) nodes.splice(i, 1) } return nodes.length > 0 ? this : undefined } get names(): UsedNames { return this.nodes.reduce((names: UsedNames, n) => addNames(names, n.names), {}) } // get count(): number { // return this.nodes.reduce((c, n) => c + n.count, 1) // } } abstract class BlockNode extends ParentNode { render(opts: CGOptions): string { return "{" + opts._n + super.render(opts) + "}" + opts._n } } class Root extends ParentNode {} class Else extends BlockNode { static readonly kind = "else" } class If extends BlockNode { static readonly kind = "if" else?: If | Else constructor(private condition: Code | boolean, nodes?: ChildNode[]) { super(nodes) } render(opts: CGOptions): string { let code = `if(${this.condition})` + super.render(opts) if (this.else) code += "else " + this.else.render(opts) return code } optimizeNodes(): If | ChildNode[] | undefined { super.optimizeNodes() const cond = this.condition if (cond === true) return this.nodes // else is ignored here let e = this.else if (e) { const ns = e.optimizeNodes() e = this.else = Array.isArray(ns) ? new Else(ns) : (ns as Else | undefined) } if (e) { if (cond === false) return e instanceof If ? e : e.nodes if (this.nodes.length) return this return new If(not(cond), e instanceof If ? [e] : e.nodes) } if (cond === false || !this.nodes.length) return undefined return this } optimizeNames(names: UsedNames, constants: Constants): this | undefined { this.else = this.else?.optimizeNames(names, constants) if (!(super.optimizeNames(names, constants) || this.else)) return this.condition = optimizeExpr(this.condition, names, constants) return this } get names(): UsedNames { const names = super.names addExprNames(names, this.condition) if (this.else) addNames(names, this.else.names) return names } // get count(): number { // return super.count + (this.else?.count || 0) // } } abstract class For extends BlockNode { static readonly kind = "for" } class ForLoop extends For { constructor(private iteration: Code) { super() } render(opts: CGOptions): string { return `for(${this.iteration})` + super.render(opts) } optimizeNames(names: UsedNames, constants: Constants): this | undefined { if (!super.optimizeNames(names, constants)) return this.iteration = optimizeExpr(this.iteration, names, constants) return this } get names(): UsedNames { return addNames(super.names, this.iteration.names) } } class ForRange extends For { constructor( private readonly varKind: Name, private readonly name: Name, private readonly from: SafeExpr, private readonly to: SafeExpr ) { super() } render(opts: CGOptions): string { const varKind = opts.es5 ? varKinds.var : this.varKind const {name, from, to} = this return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts) } get names(): UsedNames { const names = addExprNames(super.names, this.from) return addExprNames(names, this.to) } } class ForIter extends For { constructor( private readonly loop: "of" | "in", private readonly varKind: Name, private readonly name: Name, private iterable: Code ) { super() } render(opts: CGOptions): string { return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts) } optimizeNames(names: UsedNames, constants: Constants): this | undefined { if (!super.optimizeNames(names, constants)) return this.iterable = optimizeExpr(this.iterable, names, constants) return this } get names(): UsedNames { return addNames(super.names, this.iterable.names) } } class Func extends BlockNode { static readonly kind = "func" constructor(public name: Name, public args: Code, public async?: boolean) { super() } render(opts: CGOptions): string { const _async = this.async ? "async " : "" return `${_async}function ${this.name}(${this.args})` + super.render(opts) } } class Return extends ParentNode { static readonly kind = "return" render(opts: CGOptions): string { return "return " + super.render(opts) } } class Try extends BlockNode { catch?: Catch finally?: Finally render(opts: CGOptions): string { let code = "try" + super.render(opts) if (this.catch) code += this.catch.render(opts) if (this.finally) code += this.finally.render(opts) return code } optimizeNodes(): this { super.optimizeNodes() this.catch?.optimizeNodes() as Catch | undefined this.finally?.optimizeNodes() as Finally | undefined return this } optimizeNames(names: UsedNames, constants: Constants): this { super.optimizeNames(names, constants) this.catch?.optimizeNames(names, constants) this.finally?.optimizeNames(names, constants) return this } get names(): UsedNames { const names = super.names if (this.catch) addNames(names, this.catch.names) if (this.finally) addNames(names, this.finally.names) return names } // get count(): number { // return super.count + (this.catch?.count || 0) + (this.finally?.count || 0) // } } class Catch extends BlockNode { static readonly kind = "catch" constructor(readonly error: Name) { super() } render(opts: CGOptions): string { return `catch(${this.error})` + super.render(opts) } } class Finally extends BlockNode { static readonly kind = "finally" render(opts: CGOptions): string { return "finally" + super.render(opts) } } type StartBlockNode = If | For | Func | Return | Try type LeafNode = Def | Assign | Label | Break | Throw | AnyCode type ChildNode = StartBlockNode | LeafNode type EndBlockNodeType = | typeof If | typeof Else | typeof For | typeof Func | typeof Return | typeof Catch | typeof Finally type Constants = Record export interface CodeGenOptions { es5?: boolean lines?: boolean ownProperties?: boolean } interface CGOptions extends CodeGenOptions { _n: "\n" | "" } export class CodeGen { readonly _scope: Scope readonly _extScope: ValueScope readonly _values: ScopeValueSets = {} private readonly _nodes: ParentNode[] private readonly _blockStarts: number[] = [] private readonly _constants: Constants = {} private readonly opts: CGOptions constructor(extScope: ValueScope, opts: CodeGenOptions = {}) { this.opts = {...opts, _n: opts.lines ? "\n" : ""} this._extScope = extScope this._scope = new Scope({parent: extScope}) this._nodes = [new Root()] } toString(): string { return this._root.render(this.opts) } // returns unique name in the internal scope name(prefix: string): Name { return this._scope.name(prefix) } // reserves unique name in the external scope scopeName(prefix: string): ValueScopeName { return this._extScope.name(prefix) } // reserves unique name in the external scope and assigns value to it scopeValue(prefixOrName: ValueScopeName | string, value: NameValue): Name { const name = this._extScope.value(prefixOrName, value) const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set()) vs.add(name) return name } getScopeValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined { return this._extScope.getValue(prefix, keyOrRef) } // return code that assigns values in the external scope to the names that are used internally // (same names that were returned by gen.scopeName or gen.scopeValue) scopeRefs(scopeName: Name): Code { return this._extScope.scopeRefs(scopeName, this._values) } scopeCode(): Code { return this._extScope.scopeCode(this._values) } private _def( varKind: Name, nameOrPrefix: Name | string, rhs?: SafeExpr, constant?: boolean ): Name { const name = this._scope.toName(nameOrPrefix) if (rhs !== undefined && constant) this._constants[name.str] = rhs this._leafNode(new Def(varKind, name, rhs)) return name } // `const` declaration (`var` in es5 mode) const(nameOrPrefix: Name | string, rhs: SafeExpr, _constant?: boolean): Name { return this._def(varKinds.const, nameOrPrefix, rhs, _constant) } // `let` declaration with optional assignment (`var` in es5 mode) let(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name { return this._def(varKinds.let, nameOrPrefix, rhs, _constant) } // `var` declaration with optional assignment var(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name { return this._def(varKinds.var, nameOrPrefix, rhs, _constant) } // assignment code assign(lhs: Code, rhs: SafeExpr, sideEffects?: boolean): CodeGen { return this._leafNode(new Assign(lhs, rhs, sideEffects)) } // `+=` code add(lhs: Code, rhs: SafeExpr): CodeGen { return this._leafNode(new AssignOp(lhs, operators.ADD, rhs)) } // appends passed SafeExpr to code or executes Block code(c: Block | SafeExpr): CodeGen { if (typeof c == "function") c() else if (c !== nil) this._leafNode(new AnyCode(c)) return this } // returns code for object literal for the passed argument list of key-value pairs object(...keyValues: [Name | string, SafeExpr | string][]): _Code { const code: CodeItem[] = ["{"] for (const [key, value] of keyValues) { if (code.length > 1) code.push(",") code.push(key) if (key !== value || this.opts.es5) { code.push(":") addCodeArg(code, value) } } code.push("}") return new _Code(code) } // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed) if(condition: Code | boolean, thenBody?: Block, elseBody?: Block): CodeGen { this._blockNode(new If(condition)) if (thenBody && elseBody) { this.code(thenBody).else().code(elseBody).endIf() } else if (thenBody) { this.code(thenBody).endIf() } else if (elseBody) { throw new Error('CodeGen: "else" body without "then" body') } return this } // `else if` clause - invalid without `if` or after `else` clauses elseIf(condition: Code | boolean): CodeGen { return this._elseNode(new If(condition)) } // `else` clause - only valid after `if` or `else if` clauses else(): CodeGen { return this._elseNode(new Else()) } // end `if` statement (needed if gen.if was used only with condition) endIf(): CodeGen { return this._endBlockNode(If, Else) } private _for(node: For, forBody?: Block): CodeGen { this._blockNode(node) if (forBody) this.code(forBody).endFor() return this } // a generic `for` clause (or statement if `forBody` is passed) for(iteration: Code, forBody?: Block): CodeGen { return this._for(new ForLoop(iteration), forBody) } // `for` statement for a range of values forRange( nameOrPrefix: Name | string, from: SafeExpr, to: SafeExpr, forBody: (index: Name) => void, varKind: Code = this.opts.es5 ? varKinds.var : varKinds.let ): CodeGen { const name = this._scope.toName(nameOrPrefix) return this._for(new ForRange(varKind, name, from, to), () => forBody(name)) } // `for-of` statement (in es5 mode replace with a normal for loop) forOf( nameOrPrefix: Name | string, iterable: Code, forBody: (item: Name) => void, varKind: Code = varKinds.const ): CodeGen { const name = this._scope.toName(nameOrPrefix) if (this.opts.es5) { const arr = iterable instanceof Name ? iterable : this.var("_arr", iterable) return this.forRange("_i", 0, _`${arr}.length`, (i) => { this.var(name, _`${arr}[${i}]`) forBody(name) }) } return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name)) } // `for-in` statement. // With option `ownProperties` replaced with a `for-of` loop for object keys forIn( nameOrPrefix: Name | string, obj: Code, forBody: (item: Name) => void, varKind: Code = this.opts.es5 ? varKinds.var : varKinds.const ): CodeGen { if (this.opts.ownProperties) { return this.forOf(nameOrPrefix, _`Object.keys(${obj})`, forBody) } const name = this._scope.toName(nameOrPrefix) return this._for(new ForIter("in", varKind, name, obj), () => forBody(name)) } // end `for` loop endFor(): CodeGen { return this._endBlockNode(For) } // `label` statement label(label: Name): CodeGen { return this._leafNode(new Label(label)) } // `break` statement break(label?: Code): CodeGen { return this._leafNode(new Break(label)) } // `return` statement return(value: Block | SafeExpr): CodeGen { const node = new Return() this._blockNode(node) this.code(value) if (node.nodes.length !== 1) throw new Error('CodeGen: "return" should have one node') return this._endBlockNode(Return) } // `try` statement try(tryBody: Block, catchCode?: (e: Name) => void, finallyCode?: Block): CodeGen { if (!catchCode && !finallyCode) throw new Error('CodeGen: "try" without "catch" and "finally"') const node = new Try() this._blockNode(node) this.code(tryBody) if (catchCode) { const error = this.name("e") this._currNode = node.catch = new Catch(error) catchCode(error) } if (finallyCode) { this._currNode = node.finally = new Finally() this.code(finallyCode) } return this._endBlockNode(Catch, Finally) } // `throw` statement throw(error: Code): CodeGen { return this._leafNode(new Throw(error)) } // start self-balancing block block(body?: Block, nodeCount?: number): CodeGen { this._blockStarts.push(this._nodes.length) if (body) this.code(body).endBlock(nodeCount) return this } // end the current self-balancing block endBlock(nodeCount?: number): CodeGen { const len = this._blockStarts.pop() if (len === undefined) throw new Error("CodeGen: not in self-balancing block") const toClose = this._nodes.length - len if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) { throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`) } this._nodes.length = len return this } // `function` heading (or definition if funcBody is passed) func(name: Name, args: Code = nil, async?: boolean, funcBody?: Block): CodeGen { this._blockNode(new Func(name, args, async)) if (funcBody) this.code(funcBody).endFunc() return this } // end function definition endFunc(): CodeGen { return this._endBlockNode(Func) } optimize(n = 1): void { while (n-- > 0) { this._root.optimizeNodes() this._root.optimizeNames(this._root.names, this._constants) } } private _leafNode(node: LeafNode): CodeGen { this._currNode.nodes.push(node) return this } private _blockNode(node: StartBlockNode): void { this._currNode.nodes.push(node) this._nodes.push(node) } private _endBlockNode(N1: EndBlockNodeType, N2?: EndBlockNodeType): CodeGen { const n = this._currNode if (n instanceof N1 || (N2 && n instanceof N2)) { this._nodes.pop() return this } throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`) } private _elseNode(node: If | Else): CodeGen { const n = this._currNode if (!(n instanceof If)) { throw new Error('CodeGen: "else" without "if"') } this._currNode = n.else = node return this } private get _root(): Root { return this._nodes[0] as Root } private get _currNode(): ParentNode { const ns = this._nodes return ns[ns.length - 1] } private set _currNode(node: ParentNode) { const ns = this._nodes ns[ns.length - 1] = node } // get nodeCount(): number { // return this._root.count // } } function addNames(names: UsedNames, from: UsedNames): UsedNames { for (const n in from) names[n] = (names[n] || 0) + (from[n] || 0) return names } function addExprNames(names: UsedNames, from: SafeExpr): UsedNames { return from instanceof _CodeOrName ? addNames(names, from.names) : names } function optimizeExpr(expr: T, names: UsedNames, constants: Constants): T function optimizeExpr(expr: SafeExpr, names: UsedNames, constants: Constants): SafeExpr { if (expr instanceof Name) return replaceName(expr) if (!canOptimize(expr)) return expr return new _Code( expr._items.reduce((items: CodeItem[], c: SafeExpr | string) => { if (c instanceof Name) c = replaceName(c) if (c instanceof _Code) items.push(...c._items) else items.push(c) return items }, []) ) function replaceName(n: Name): SafeExpr { const c = constants[n.str] if (c === undefined || names[n.str] !== 1) return n delete names[n.str] return c } function canOptimize(e: SafeExpr): e is _Code { return ( e instanceof _Code && e._items.some( (c) => c instanceof Name && names[c.str] === 1 && constants[c.str] !== undefined ) ) } } function subtractNames(names: UsedNames, from: UsedNames): void { for (const n in from) names[n] = (names[n] || 0) - (from[n] || 0) } export function not(x: T): T export function not(x: Code | SafeExpr): Code | SafeExpr { return typeof x == "boolean" || typeof x == "number" || x === null ? !x : _`!${par(x)}` } const andCode = mappend(operators.AND) // boolean AND (&&) expression with the passed arguments export function and(...args: Code[]): Code { return args.reduce(andCode) } const orCode = mappend(operators.OR) // boolean OR (||) expression with the passed arguments export function or(...args: Code[]): Code { return args.reduce(orCode) } type MAppend = (x: Code, y: Code) => Code function mappend(op: Code): MAppend { return (x, y) => (x === nil ? y : y === nil ? x : _`${par(x)} ${op} ${par(y)}`) } function par(x: Code): Code { return x instanceof Name ? x : _`(${x})` }