@effectful/transducers-loose
Version:
@effectful/transducers built with faster generators
1,224 lines (1,211 loc) • 39 kB
JavaScript
"use strict";
exports.__esModule = true;
exports.argumentsSym = exports.SymbolSym = exports.ObjectSym = exports.ArraySym = void 0;
exports.assignBody = assignBody;
exports.assignSym = void 0;
exports.calcRefScopes = calcRefScopes;
exports.cloneSym = cloneSym;
exports.collectBlockDirectives = collectBlockDirectives;
exports.emitTempVar = emitTempVar;
exports.emitUndefined = emitUndefined;
exports.namePos = namePos;
exports.newSym = newSym;
exports.prepare = void 0;
exports.replaceUndefined = replaceUndefined;
exports.resolveTempVars = exports.resolve = exports.reset = exports.reserved = void 0;
exports.tempNames = tempNames;
exports.undefinedSym = exports.tempVar = void 0;
var Kit = require("./kit");
var _core = require("./core");
var M = require("@effectful/es-rt/opts/loose");
(0, _core.symInfo)(_core.Tag.ClassDeclaration).funDecl = true;
(0, _core.symInfo)(_core.Tag.FunctionDeclaration).funDecl = true;
let symNum = 0;
const nameOpts = ["a", "b", "c", "d", "e", "f", "g", "h", "k", "m", "n", "x", "y", "z"];
function namePos(n, pos) {
if (!n.length) {
const len = nameOpts.length;
if (pos < len) return nameOpts[pos];
return `${nameOpts[pos % len]}${Math.floor(pos / len)}`;
}
if (n[n.length - 1] === "_") return n + (pos + 1);
if (pos === 0) {
return reserved.get(n) || n;
}
if (pos === 1) return "_" + n;
return `${n}${pos - 1}`;
}
const reserved = exports.reserved = new Map([["arguments", "args"]]);
// String -> Sym
function newSym(name, strict = false, decl) {
if (!name) name = "";
return {
name,
orig: name,
id: `${name}_${symNum++}`,
strict,
decl,
num: symNum++,
type: null,
emitConstMethod: emitSym
};
}
const undefinedSym = exports.undefinedSym = newSym("undefined", true);
const argumentsSym = exports.argumentsSym = newSym("arguments", true);
const ObjectSym = exports.ObjectSym = newSym("Object", true);
const ArraySym = exports.ArraySym = newSym("Array", true);
const SymbolSym = exports.SymbolSym = newSym("Symbol", true);
const globals = new Map([["undefined", undefinedSym], ["arguments", argumentsSym], ["Object", ObjectSym], ["Array", ArraySym], ["Symbol", SymbolSym]]);
/** `sort` comparator */
function byNum(a, b) {
return a.num - b.num;
}
function cloneSym(sym) {
var res;
res = newSym(sym.orig);
res.declScope = sym.declScope;
res.declLoop = sym.declLoop;
res.captLoop = sym.captLoop;
res.declBlock = sym.declBlock;
res.decl = sym.decl;
res.param = sym.param;
return res;
}
(0, _core.symInfo)(_core.Tag.ClassDeclaration).funDecl = true;
(0, _core.symInfo)(_core.Tag.FunctionDeclaration).funDecl = true;
function emitSym(pos) {
var emitSym = M.generator(),
_this = this,
r,
p;
emitSym.step = emitSym_1;
emitSym.$step = 3;
return emitSym;
function emitSym_1(p) {
var a;
switch (emitSym.$cur = emitSym.$step) {
case 3:
a = (0, _core.tok)(pos, _core.Tag.Identifier, {
node: {},
sym: _this
});
emitSym.$step = 4;
emitSym.value = a;
return emitSym;
case 4:
emitSym.$step = 0;
emitSym.value = void 0;
emitSym.done = true;
return emitSym;
case 0:
emitSym.$step = 0;
emitSym.value = p;
emitSym.done = true;
return emitSym;
case 1:
emitSym.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
/**
* sets temporal `node.name` for each Identifier for debug dumps outputs
*/
function tempNames(s) {
var i,
tempNames = M.generator(),
loop,
r,
p;
tempNames.step = tempNames_1;
tempNames.$step = 3;
return tempNames;
function tempNames_1(p) {
for (;;) {
switch (tempNames.$cur = tempNames.$step) {
case 3:
loop = M.iterator(s);
tempNames.$step = 4;
tempNames.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.enter && i.type === _core.Tag.Identifier && i.value.sym != null && !i.value.node.name) {
i.value.node.name = i.value.sym.strict ? i.value.sym.name : i.value.sym.id;
}
tempNames.$step = 4;
tempNames.value = i;
return tempNames;
} else {
tempNames.$step = 0;
tempNames.value = void 0;
tempNames.done = true;
return tempNames;
}
case 0:
tempNames.$step = 0;
tempNames.value = p;
tempNames.done = true;
return tempNames;
case 1:
tempNames.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
}
/**
* This assigns unique Symbol object for each variable declaration and usage.
* It stores it in `sym` fields, for root value stores map syms mapping the
* sym object to a SymbolInfo structure
*
* interface Sym {
* name: String;
* orig: String;
* num: number;
* sym: Symbol;
* unordered: boolean;
* declScope: TokenValue;
* declLoop?: TokenValue; -- loop scope
* captLoop?: TokenValue; -- loop to be captured in
* declBlock?: TokenValue;
* decl?: TokenValue;
* param?: TokenValue;
* }
*
* for each identifier referening variable:
*
* type Value = Value & {sym:Sym,decl?:true}
* & {decls?:Map<string,Sym>}
* & {root?:boolean}
*
*/
const assignSym = exports.assignSym = Kit.pipe(_core.resetFieldInfo, Kit.toArray,
// collecting each declaration in each block before resolving
// because function's may use the ones declared after
function collectDecls(si) {
var sa,
s,
report,
_collectDecls = function __collectDecls(func, block, funcSyms, funcVars, blockSyms, loop) {
var checkScope = function checkScope(val, syms) {
// checking the scope only the first time
if (report) {
const m = new Map();
var loop = M.iterator(syms);
for (; !(loop = loop.step()).done;) {
const i = loop.value;
if (!i.strict || i.func || i.unordered || i.declScope == null) continue;
let l = m.get(i.orig);
if (l == null) m.set(i.orig, l = []);
l.push(i);
}
var _loop = M.iterator(m.values());
for (; !(_loop = _loop.step()).done;) {
const i = _loop.value;
if (i.length > 1) {
throw s.error(`Identifier ${i[0].orig} has already been declared`, i[i.length - 1].decl);
}
}
}
val.decls = new Set(syms);
},
pat = function _pat(sw, param, params, unordered, nextSyms) {
var k, sym;
var _loop = M.iterator(sw);
for (; !(_loop = _loop.step()).done;) {
k = _loop.value;
if (k.enter) {
// TODO: make it stronger
if (k.pos === _core.Tag.key) {
if (s.curLev()) _collectDecls(func, block, funcSyms, funcVars, blockSyms, loop);
continue;
}
switch (k.type) {
case _core.Tag.Identifier:
if (!k.value.fieldInfo.declVar) break;
sym = id(k, nextSyms, unordered, loop);
if (sym && params) {
params.push(sym);
sym.param = param;
}
break;
case _core.Tag.AssignmentPattern:
pat(s.one(), param, params, unordered, nextSyms);
_collectDecls(func, block, funcSyms, funcVars, blockSyms, loop);
break;
}
}
}
},
id = function id(i, syms, unordered, loop) {
var fi, name, sym;
fi = i.value.fieldInfo;
if (fi.declVar) {
i.value.decl = true;
({
node: {
name
},
sym
} = i.value);
if (sym != null) name = sym.orig;else {
if (unordered && name && name.length) sym = i.value.sym = funcVars.get(name);
if (!sym) sym = i.value.sym = newSym(name, true, i.value);
}
if (unordered) funcVars.set(name, sym);
syms.push(sym);
sym.unordered = unordered;
sym.declScope = func;
sym.declBlock = block;
sym.captLoop = sym.declLoop = unordered ? null : loop;
sym.declRange = unordered ? func : block;
sym.param = null;
sym.func = null;
sym.decl = i;
return sym;
} else if (fi.expr || fi.lval) {
i.value.decl = false;
}
return null;
},
i,
nextSyms,
ini,
j,
_nextSyms,
nextSyms1,
nextSyms2,
params,
_j,
_block,
k,
_k,
nextSyms3,
ti,
j1,
funcId,
fd,
_params,
sloppy,
st,
k1,
unordered,
dstSyms,
j2,
k2,
nextSyms4,
fi;
var _loop = M.iterator(s.sub());
for (; !(_loop = _loop.step()).done;) {
i = _loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.ThisExpression:
break;
case _core.Tag.ForStatement:
{
nextSyms = [];
ini = s.cur();
if (ini.pos === _core.Tag.init && ini.type === _core.Tag.VariableDeclaration && ini.value.node.kind !== "var") {
s.take();
_collectDecls(func, i.value, funcSyms, funcVars, nextSyms, loop);
var loop1 = M.iterator(nextSyms);
for (; !(loop1 = loop1.step()).done;) {
j = loop1.value;
j.captLoop = i.value;
}
s.close(ini);
}
_collectDecls(func, i.value, funcSyms, funcVars, nextSyms, i.value);
checkScope(i.value, nextSyms);
}
break;
case _core.Tag.ForInStatement:
case _core.Tag.ForAwaitStatement:
case _core.Tag.ForOfStatement:
{
_nextSyms = [];
_collectDecls(func, i.value, funcSyms, funcVars, _nextSyms, i.value);
checkScope(i.value, _nextSyms);
}
break;
case _core.Tag.BlockStatement:
case _core.Tag.SwitchStatement:
{
nextSyms1 = [];
_collectDecls(func, i.value, funcSyms, funcVars || new Map(), nextSyms1, loop);
checkScope(i.value, nextSyms1);
}
break;
case _core.Tag.ArrowFunctionExpression:
if (!i.leave && s.curLev()) {
nextSyms2 = [];
params = [];
var loop2 = M.iterator(s.one());
for (; !(loop2 = loop2.step()).done;) {
_j = loop2.value;
if (_j.enter) pat(s.sub(), i.value, params, false, nextSyms2);
}
_block = s.cur();
var loop3 = M.iterator(params);
for (; !(loop3 = loop3.step()).done;) {
k = loop3.value;
k.declScope = i.value;
k.declBlock = _block.value;
}
if (_block.type === _core.Tag.BlockStatement) s.take();
_collectDecls(i.value, _block.value, nextSyms2, new Map(), nextSyms2);
i.value.body = _block.value;
i.value.paramSyms = params;
i.value.parScope = func;
checkScope(_block.value, nextSyms2);
if (_block.type === _core.Tag.BlockStatement) s.close(_block);
s.close(i);
}
break;
case _core.Tag.ClassMethod:
case _core.Tag.ObjectMethod:
_k = s.take();
if (!_k.leave) {
_collectDecls(func, block, funcSyms, funcVars, blockSyms, loop);
s.close(_k);
}
case _core.Tag.File:
case _core.Tag.FunctionExpression:
case _core.Tag.FunctionDeclaration:
if (!i.leave && s.curLev()) {
nextSyms3 = [];
ti = (0, _core.symInfo)(i.type);
j1 = s.peel();
funcId = void 0;
if (j1.pos === _core.Tag.id) {
fd = ti.funDecl;
id(j1, fd && funcSyms != null ? func.sloppy ? funcSyms : blockSyms : nextSyms3, fd);
Kit.skip(s.one());
Kit.skip(s.leave());
funcId = j1.value.sym;
j1 = s.peel();
}
_params = [];
if (j1.pos === _core.Tag.params) {
pat(s.sub(), i.value, _params, false, nextSyms3);
Kit.skip(s.leave());
j1 = s.peel();
}
sloppy = func && func.sloppy;
st = j1.value.node.sourceType;
if (st === "script") sloppy = true;else if (st === "module") sloppy = false;
if (j1.value.blockDirs && j1.value.blockDirs.has("use strict")) sloppy = false;
i.value.sloppy = sloppy;
j1.value.root = true;
_collectDecls(i.value, j1.value, nextSyms3, new Map(), nextSyms3);
var loop4 = M.iterator(_params);
for (; !(loop4 = loop4.step()).done;) {
k1 = loop4.value;
k1.declScope = i.value;
k1.declBlock = j1.value;
}
if (funcId) {
if (!ti.funDecl) {
funcId.declScope = i.value;
funcId.declBlock = j1.value;
}
funcId.func = i.value;
}
if (!i.value.funcId) i.value.funcId = funcId;
i.value.paramSyms = _params;
i.value.parScope = func;
checkScope(j1.value, nextSyms3);
Kit.skip(s.leave());
}
break;
case _core.Tag.VariableDeclaration:
unordered = i.value.node.kind === "var";
dstSyms = unordered ? funcSyms : blockSyms;
var loop5 = M.iterator(s.sub());
for (; !(loop5 = loop5.step()).done;) {
j2 = loop5.value;
if (j2.enter && !j2.leave && j2.type === _core.Tag.VariableDeclarator) {
k2 = s.curLev();
if (k2 && k2.pos === _core.Tag.id) pat(s.one(), null, null, unordered, dstSyms);
_collectDecls(func, block, funcSyms, funcVars, blockSyms, loop);
}
}
break;
case _core.Tag.CatchClause:
if (s.cur().pos === _core.Tag.param) {
nextSyms4 = [];
pat(s.one(), null, null, undefined, nextSyms4);
_collectDecls(func, i.value, funcSyms, funcVars, nextSyms4, loop);
checkScope(i.value, nextSyms4);
}
break;
case _core.Tag.JSXIdentifier:
i.value.decl = false;
break;
case _core.Tag.Identifier:
fi = i.value.fieldInfo;
if (fi.declVar) {
id(i, blockSyms, undefined, loop);
} else if (fi.expr || fi.lval) i.value.decl = false;
break;
}
}
}
};
sa = Kit.toArray(si);
s = Kit.auto(sa);
report = s.first.type === _core.Tag.File && !s.first.value.scopeDone;
s.first.value.scopeDone = true;
_collectDecls(s.first.value.body);
return sa;
}, function assignSym(si) {
var sa,
s,
decls = function _decls(sw, func, scope) {
var i, name, sym, _name, _sym, undef, bscope, sym1;
var loop = M.iterator(sw);
for (; !(loop = loop.step()).done;) {
i = loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.JSXIdentifier:
name = i.value.node.name;
if (i.pos !== _core.Tag.property && name[0].toLowerCase() === name[0]) break;
case _core.Tag.Identifier:
({
sym
} = i.value);
if (i.value.decl === true) {
if (sym.strict && (!sym.unordered || sym.funcId)) scope.set(sym.name, sym);
} else if (i.value.decl === false) {
if (sym == null) {
({
name: _name
} = i.value.node);
_sym = scope.get(_name);
if (_sym == null) {
undef = globals.get(_name);
if (undef == null) {
globals.set(_name, undef = newSym(_name, true, i.value));
undef.num = -1;
undef.unordered = false;
undef.declScope = null;
}
i.value.sym = undef;
break;
}
i.value.sym = _sym;
}
}
break;
case _core.Tag.Program:
case _core.Tag.BlockStatement:
case _core.Tag.SwitchStatement:
case _core.Tag.CatchClause:
case _core.Tag.ForStatement:
case _core.Tag.ForInStatement:
case _core.Tag.ForAwaitStatement:
case _core.Tag.ForOfStatement:
bscope = new Map(scope);
if (i.value.decls) {
var _loop = M.iterator(i.value.decls);
for (; !(_loop = _loop.step()).done;) {
sym1 = _loop.value;
if (sym1.strict) bscope.set(sym1.name, sym1);
}
}
decls(s.sub(), func, bscope);
break;
case _core.Tag.ObjectMethod:
decls(s.one(), func, scope);
case _core.Tag.ArrowFunctionExpression:
case _core.Tag.FunctionExpression:
case _core.Tag.File:
case _core.Tag.FunctionDeclaration:
case _core.Tag.ClassMethod:
case _core.Tag.ClassPrivateMethod:
decls(s.sub(), i.value, new Map(scope));
break;
}
}
}
};
sa = Kit.toArray(si);
s = Kit.auto(sa);
decls(s, s.first.value, new Map(), new Map());
return sa;
});
/** assigns field `body` for each function pointing to its `Tag.body` value */
function assignBody(si) {
var sa, s, i, j;
sa = Kit.toArray(si);
s = Kit.auto(sa);
var loop = M.iterator(s);
for (; !(loop = loop.step()).done;) {
i = loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.FunctionDeclaration:
case _core.Tag.Program:
case _core.Tag.FunctionExpression:
case _core.Tag.ObjectMethod:
case _core.Tag.ClassMethod:
case _core.Tag.ClassPrivateMethod:
case _core.Tag.ArrowFunctionExpression:
var _loop = M.iterator(s);
for (; !(_loop = _loop.step()).done;) {
j = _loop.value;
if (j.enter && j.pos === _core.Tag.body) {
i.value.body = j.value;
break;
}
}
}
}
}
return sa;
}
/**
* for each variable sets its usages scope (list of functions where the
* variable is used except declaration function)
*
* type Sym = Sym & { refScopes: Set<TokenValue> }
*/
function calcRefScopes(si) {
var sa,
s,
scope = function _scope(root) {
var i, si;
var loop = M.iterator(s.sub());
for (; !(loop = loop.step()).done;) {
i = loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.FunctionDeclaration:
Kit.skip(s.one());
case _core.Tag.FunctionExpression:
case _core.Tag.ObjectMethod:
case _core.Tag.ClassMethod:
case _core.Tag.ClassPrivateMethod:
case _core.Tag.ArrowFunctionExpression:
scope(i.value);
break;
case _core.Tag.Identifier:
si = i.value.sym;
if (si != null && si.declScope !== root) (si.refScopes || (si.refScopes = new Set())).add(root);
}
}
}
};
sa = Kit.toArray(si);
s = Kit.auto(sa);
scope(s.first.value);
return sa;
}
/**
* for each block calculates a set of variables referenced in it
*
* type Value = Value * { varRefs?: Set<Sym> }
*/
function calcBlockRefs(si) {
var sa,
s,
walk = function _walk(totDecls) {
var use, i, decls, nextDecls, used, cur, j, _j;
use = new Set();
var loop = M.iterator(s.sub());
for (; !(loop = loop.step()).done;) {
i = loop.value;
if (i.enter) {
if (i.value.decls != null && !i.leave) {
decls = new Set(i.value.decls);
nextDecls = new Set(totDecls);
decls.forEach(nextDecls.add, nextDecls);
used = walk(nextDecls);
cur = i.value.varRefs = new Set();
var _loop = M.iterator(decls);
for (; !(_loop = _loop.step()).done;) {
j = _loop.value;
cur.add(j);
}
var loop1 = M.iterator(used);
for (; !(loop1 = loop1.step()).done;) {
_j = loop1.value;
cur.add(_j);
if (!decls.has(_j)) use.add(_j);
}
}
if (i.type === _core.Tag.Identifier && i.value.sym != null && i.value.decl === false) {
use.add(i.value.sym);
}
}
}
return use;
};
sa = Kit.toArray(si);
s = Kit.auto(sa);
walk(new Set());
return sa;
}
/**
* after adding some names, there may be some naming conflicts
* this pass resolves them by looking for same name but different symbols ids
* and renaming them accordingly
*/
function solve(si) {
var sa, allIds, idToks, decls, scopes, i, namesStore, symsStore, conflicts, _i, names, j, name, syms, _j, table, _name, i1, allSyms, cur, _syms, j1, i2, _cur, name1, rawSets, tup, pos, i3, result, nameScopes, symScopes, j2, j3, opts, fn, i4, _opts, _fn;
sa = Kit.toArray(si);
allIds = new Set();
idToks = [];
decls = new Set();
scopes = [];
var loop = M.iterator(sa);
for (; !(loop = loop.step()).done;) {
i = loop.value;
if (i.enter) {
if (i.value.varRefs != null) scopes.push(i.value);
if (i.type === _core.Tag.Identifier && i.value.sym) {
if (i.value.decl) decls.add(i.value.sym);
idToks.push(i.value);
}
}
}
// each block where name is used
// Map<string,Set<BlockValue>>
namesStore = new Map();
symsStore = new Map();
conflicts = new Map();
var _loop = M.iterator(scopes);
for (; !(_loop = _loop.step()).done;) {
_i = _loop.value;
names = new Map();
var loop1 = M.iterator(_i.varRefs);
for (; !(loop1 = loop1.step()).done;) {
j = loop1.value;
allIds.add(j);
Kit.mapAdd(symsStore, j, _i);
j.hasDecl = decls.has(j);
Kit.mapPush(names, j.orig, j);
}
var loop2 = M.iterator(names);
for (; !(loop2 = loop2.step()).done;) {
[name, syms] = loop2.value;
if (syms.length > 1 || !name.length || reserved.has(name)) Kit.mapPush(conflicts, name, {
syms,
block: _i
});
}
}
var loop3 = M.iterator(allIds);
for (; !(loop3 = loop3.step()).done;) {
_j = loop3.value;
_j.name = _j.orig;
}
if (conflicts.size) {
table = [];
var loop4 = M.iterator(conflicts);
for (; !(loop4 = loop4.step()).done;) {
[_name, i1] = loop4.value;
allSyms = new Set();
cur = {
name: _name,
syms: allSyms,
rawSets: []
};
table.push(cur);
var loop5 = M.iterator(i1);
for (; !(loop5 = loop5.step()).done;) {
({
syms: _syms
} = loop5.value);
cur.rawSets.push(_syms);
_syms.forEach(allSyms.add, allSyms);
}
var loop6 = M.iterator(allSyms);
for (; !(loop6 = loop6.step()).done;) {
j1 = loop6.value;
j1.name = null;
}
}
var loop7 = M.iterator(allIds);
for (; !(loop7 = loop7.step()).done;) {
i2 = loop7.value;
if (i2.name) {
_cur = namesStore.get(i2.name);
if (!_cur) namesStore.set(i2.name, _cur = new Set());
symsStore.get(i2).forEach(_cur.add, _cur);
}
}
var loop8 = M.iterator(table);
for (; !(loop8 = loop8.step()).done;) {
({
name: name1,
rawSets
} = loop8.value);
var loop9 = M.iterator(rawSets);
for (; !(loop9 = loop9.step()).done;) {
tup = loop9.value;
tup.sort(byNum);
pos = 0;
var loop10 = M.iterator(tup);
for (; !(loop10 = loop10.step()).done;) {
i3 = loop10.value;
if (i3.name != null) continue;
result = i3.orig;
nameScopes = void 0;
symScopes = symsStore.get(i3);
if (i3.hasDecl) {
lookup: for (;;) {
result = namePos(name1, pos++);
nameScopes = namesStore.get(result);
if (!nameScopes) break;
var loop11 = M.iterator(symScopes);
for (; !(loop11 = loop11.step()).done;) {
j2 = loop11.value;
if (nameScopes.has(j2)) continue lookup;
}
break;
}
}
if (!nameScopes) namesStore.set(result, nameScopes = new Set());
symScopes.forEach(nameScopes.add, nameScopes);
i3.name = result;
}
}
}
}
var loop12 = M.iterator(allIds);
for (; !(loop12 = loop12.step()).done;) {
j3 = loop12.value;
if (!j3.hasDecl && !j3.strict && !j3.global) {
j3.name = `${j3.name}_UNDECL_${j3.num}`;
opts = sa[0].value.opts;
fn = opts && opts.file && opts.file.filename;
console.warn(`INTERNAL ERROR: not declared generated symbol name ${j3.name}(${fn})`);
}
}
var loop13 = M.iterator(idToks);
for (; !(loop13 = loop13.step()).done;) {
i4 = loop13.value;
if (!i4.sym.name) {
_opts = sa[0].value.opts;
_fn = _opts && _opts.file && _opts.file.filename;
i4.sym.name = `UNKNOWN_${i4.sym.id}`;
console.warn(`INTERNAL ERROR: not resolved symbol name ${i4.sym.name}(${_fn})`);
}
i4.node.name = i4.sym.name || (i4.sym.name = i4.sym.orig);
}
return sa;
}
const prepare = exports.prepare = Kit.pipe(collectBlockDirectives, assignSym);
const reset = exports.reset = assignSym;
const resolve = exports.resolve = Kit.pipe(reset, calcBlockRefs, replaceUndefined, solve);
/** emits `void 0` at `pos` */
function emitUndefined(pos) {
var value,
emitUndefined = M.generator(),
r,
p;
emitUndefined.step = emitUndefined_1;
emitUndefined.$step = 3;
return emitUndefined;
function emitUndefined_1(p) {
var a;
switch (emitUndefined.$cur = emitUndefined.$step) {
case 3:
value = {
node: {
operator: "void",
prefix: true
}
};
a = (0, _core.enter)(pos, _core.Tag.UnaryExpression, value);
emitUndefined.$step = 4;
emitUndefined.value = a;
return emitUndefined;
case 4:
a = (0, _core.tok)(_core.Tag.argument, _core.Tag.NumericLiteral, {
node: {
value: "0"
}
});
emitUndefined.$step = 5;
emitUndefined.value = a;
return emitUndefined;
case 5:
a = (0, _core.leave)(pos, _core.Tag.UnaryExpression, value);
emitUndefined.$step = 6;
emitUndefined.value = a;
return emitUndefined;
case 6:
emitUndefined.$step = 0;
emitUndefined.value = void 0;
emitUndefined.done = true;
return emitUndefined;
case 0:
emitUndefined.$step = 0;
emitUndefined.value = p;
emitUndefined.done = true;
return emitUndefined;
case 1:
emitUndefined.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
/** replaces `undefined` -> `void 0` for generated `undefined` */
function replaceUndefined(s) {
var p,
i,
replaceUndefined = M.generator(),
loop,
r,
_p;
replaceUndefined.step = replaceUndefined_1;
replaceUndefined.$step = 3;
return replaceUndefined;
function replaceUndefined_1(_p) {
var a;
for (;;) {
switch (replaceUndefined.$cur = replaceUndefined.$step) {
case 3:
p = void 0;
loop = M.iterator(s);
replaceUndefined.$step = 4;
replaceUndefined.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.type === _core.Tag.Identifier && i.value.sym === undefinedSym && !i.value.node.loc) {
if (p && i.pos === _core.Tag.argument) {
switch (p.type) {
case _core.Tag.ReturnStatement:
case _core.Tag.YieldExpression:
i.value.node.argument = null;
replaceUndefined.$step = 4;
replaceUndefined.$step = 4;
continue;
default:
replaceUndefined.$step = 5;
replaceUndefined.$step = 5;
continue;
}
} else {
replaceUndefined.$step = 5;
replaceUndefined.$step = 5;
continue;
}
} else {
a = p = i;
replaceUndefined.$step = 4;
replaceUndefined.value = a;
return replaceUndefined;
}
} else {
replaceUndefined.$step = 0;
replaceUndefined.value = void 0;
replaceUndefined.done = true;
return replaceUndefined;
}
case 5:
if (i.enter) {
a = emitUndefined(i.pos);
replaceUndefined.$step = 4;
return replaceUndefined.$delegate(a);
} else {
replaceUndefined.$step = 4;
replaceUndefined.$step = 4;
continue;
}
case 0:
replaceUndefined.$step = 0;
replaceUndefined.value = _p;
replaceUndefined.done = true;
return replaceUndefined;
case 1:
replaceUndefined.$step = 0;
throw _p;
case 2:
return replaceUndefined.$redir(_p);
default:
throw new Error("invalid state");
}
}
}
}
const tempVar = exports.tempVar = (0, _core.symbol)("tempVar");
function emitTempVar() {
var sym,
emitTempVar = M.generator(),
r,
p;
emitTempVar.step = emitTempVar_1;
emitTempVar.$step = 3;
return emitTempVar;
function emitTempVar_1(p) {
var a;
switch (emitTempVar.$cur = emitTempVar.$step) {
case 3:
sym = newSym("_temp");
a = (0, _core.tok)(tempVar, tempVar, {
sym
});
emitTempVar.$step = 4;
emitTempVar.value = a;
return emitTempVar;
case 4:
emitTempVar.$step = 0;
emitTempVar.value = sym;
emitTempVar.done = true;
return emitTempVar;
case 0:
emitTempVar.$step = 0;
emitTempVar.value = p;
emitTempVar.done = true;
return emitTempVar;
case 1:
emitTempVar.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
/** emit `var` declarations for each `tempVar` */
const resolveTempVars = exports.resolveTempVars = Kit.pipe(function collectTempVars(si) {
var s,
walk = function walk1(b) {
var i,
_walk = M.generator(),
loop,
r,
p;
_walk.step = walk_1;
_walk.$step = 3;
return _walk;
function walk_1(p) {
for (;;) {
switch (_walk.$cur = _walk.$step) {
case 3:
loop = M.iterator(s.sub());
_walk.$step = 4;
_walk.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.BlockStatement:
case _core.Tag.Program:
_walk.$step = 5;
_walk.value = i;
return _walk;
case tempVar:
b.push(i.value.sym);
s.close(i);
_walk.$step = 4;
_walk.$step = 4;
continue;
default:
_walk.$step = 6;
_walk.$step = 6;
continue;
}
} else {
_walk.$step = 6;
_walk.$step = 6;
continue;
}
} else {
_walk.$step = 0;
_walk.value = void 0;
_walk.done = true;
return _walk;
}
case 5:
walk(i.value.tempVars = []);
_walk.$step = 4;
_walk.$step = 4;
continue;
case 6:
_walk.$step = 4;
_walk.value = i;
return _walk;
case 0:
_walk.$step = 0;
_walk.value = p;
_walk.done = true;
return _walk;
case 1:
_walk.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
};
s = Kit.auto(si);
return walk([]);
}, Kit.toArray, function emplaceTempVars(si) {
var s,
i,
lab,
sym,
_emplaceTempVars = M.generator(),
loop,
_loop,
r,
p;
_emplaceTempVars.step = emplaceTempVars_1;
_emplaceTempVars.$step = 3;
return _emplaceTempVars;
function emplaceTempVars_1(p) {
var a, b;
for (;;) {
switch (_emplaceTempVars.$cur = _emplaceTempVars.$step) {
case 3:
s = Kit.auto(si);
loop = M.iterator(s);
_emplaceTempVars.$step = 4;
_emplaceTempVars.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
_emplaceTempVars.$step = 5;
_emplaceTempVars.value = i;
return _emplaceTempVars;
} else {
_emplaceTempVars.$step = 0;
_emplaceTempVars.value = void 0;
_emplaceTempVars.done = true;
return _emplaceTempVars;
}
case 5:
if (i.enter) {
switch (i.type) {
case _core.Tag.BlockStatement:
case _core.Tag.Program:
if (i.value.tempVars && i.value.tempVars.length) {
lab = s.label();
a = s.peelTo(_core.Tag.body);
_emplaceTempVars.$step = 6;
return _emplaceTempVars.$delegate(a);
} else {
_emplaceTempVars.$step = 4;
_emplaceTempVars.$step = 4;
continue;
}
default:
_emplaceTempVars.$step = 4;
_emplaceTempVars.$step = 4;
continue;
}
} else {
_emplaceTempVars.$step = 4;
_emplaceTempVars.$step = 4;
continue;
}
case 6:
a = s.enter(_core.Tag.push, _core.Tag.VariableDeclaration, {
node: {
kind: "var"
}
});
_emplaceTempVars.$step = 7;
_emplaceTempVars.value = a;
return _emplaceTempVars;
case 7:
a = s.enter(_core.Tag.declarations, _core.Tag.Array);
_emplaceTempVars.$step = 8;
_emplaceTempVars.value = a;
return _emplaceTempVars;
case 8:
_loop = M.iterator(i.value.tempVars);
_emplaceTempVars.$step = 9;
_emplaceTempVars.$step = 9;
continue;
case 9:
if (!(_loop = _loop.step()).done) {
sym = _loop.value;
a = s.enter(_core.Tag.push, _core.Tag.VariableDeclarator);
_emplaceTempVars.$step = 10;
_emplaceTempVars.value = a;
return _emplaceTempVars;
} else {
b = lab();
_emplaceTempVars.$step = 4;
return _emplaceTempVars.$delegate(b);
}
case 10:
a = s.tok(_core.Tag.id, _core.Tag.Identifier, {
sym
});
_emplaceTempVars.$step = 11;
_emplaceTempVars.value = a;
return _emplaceTempVars;
case 11:
a = s.leave();
_emplaceTempVars.$step = 9;
return _emplaceTempVars.$delegate(a);
case 0:
_emplaceTempVars.$step = 0;
_emplaceTempVars.value = p;
_emplaceTempVars.done = true;
return _emplaceTempVars;
case 1:
_emplaceTempVars.$step = 0;
throw p;
case 2:
return _emplaceTempVars.$redir(p);
default:
throw new Error("invalid state");
}
}
}
});
/** collects JS directives (strings in beginnigs of the block),
* to block's blockDirs field
*/
function collectBlockDirectives(si) {
var sa,
s,
_collectDirectives = function __collectDirectives(block, dirs) {
var i;
var loop = M.iterator(s.sub());
for (; !(loop = loop.step()).done;) {
i = loop.value;
if (i.enter) {
i.value.parentBlock = block;
switch (i.type) {
case _core.Tag.Program:
case _core.Tag.BlockStatement:
_collectDirectives(i.value, i.value.blockDirs = new Set());
break;
case _core.Tag.DirectiveLiteral:
dirs.add(i.value.node.value);
break;
case _core.Tag.ExpressionStatement:
if (s.cur().type === _core.Tag.StringLiteral) dirs.add(i, s.cur().value.node.value);
break;
}
}
}
};
sa = Kit.toArray(si);
s = Kit.auto(sa);
_collectDirectives();
return sa;
}