Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
export function idTok(pos, sym) {
return tok(pos, Tag.Identifier, { sym });
}
if (i.enter && i.pos !== Tag.top) {
switch (i.type) {
case Tag.FunctionDeclaration:
if (i.leave) {
yield Kit.enter(i.pos, Tag.ExpressionStatement);
yield Kit.tok(Tag.expression, Tag.Identifier, {
node: { name: "$$$" }
});
yield Kit.leave(i.pos, Tag.ExpressionStatement);
continue;
}
break;
case Tag.FunctionExpression:
case Tag.ArrowFunctionExpression:
if (i.leave) {
yield Kit.tok(i.pos, Tag.Identifier, { node: { name: "$$$" } });
continue;
}
}
}
yield i;
}
}
case Tag.TryStatement:
if (!i.value.eff) {
yield i;
yield* _saveDecls(true);
continue;
}
break;
case Tag.CatchClause:
if (sl.cur().pos === Tag.param) {
if (pureTry) {
yield i;
for (const k of sl.one()) {
yield k;
if (
k.enter &&
k.type === Tag.Identifier &&
k.value.sym &&
k.value.decl
) {
k.value.sym.interpr = null;
}
}
} else {
const ids = [];
for (const j of sl.one()) {
if (j.enter && j.type === Tag.Identifier && j.value.decl) {
const { sym } = j.value;
if (!decls.has(sym)) decls.set(sym, { raw: null });
j.value.lhs = true;
j.value.rhs = false;
j.value.decl = false;
}
continue;
case Tag.CallExpression:
if (s.cur().type !== Tag.MemberExpression) break;
const m = s.take();
if (s.cur().type !== Tag.Super) {
yield i;
yield m;
continue;
}
yield i;
yield s.enter(Tag.callee, Tag.MemberExpression);
yield s.enter(Tag.object, Tag.MemberExpression, m.value);
yield* walk();
yield* s.leave();
s.close(m);
yield s.tok(Tag.property, Tag.Identifier, {
node: { name: "call" }
});
yield* s.leave();
yield* s.till(i => i.pos === Tag.arguments);
yield s.tok(Tag.push, Tag.Identifier, {
sym: thisSym,
lhs: false,
rhs: true,
decl: false
});
continue;
case Tag.Super:
if (!root.ref) break;
let classSym = root.ref.classId;
if (!classSym) classSym = root.ref.classId = Kit.scope.newSym("C");
yield* s.toks(
function* _restoreLabeledStatements() {
for (const i of s.sub()) {
if (
i.enter &&
i.value.stmt &&
!i.value.eff &&
i.value.savedLabs &&
i.value.savedLabs.length
) {
const lab = s.label();
let pos = i.pos;
for (const j of i.value.savedLabs) {
yield s.enter(pos, Tag.LabeledStatement);
yield s.tok(Tag.label, Tag.Identifier, { node: { name: j } });
pos = Tag.body;
}
yield s.peel(Kit.setPos(i, Tag.body));
yield* _restoreLabeledStatements();
yield* lab();
continue;
}
yield i;
}
}
}
function* walk() {
for (const i of s.sub()) {
if (i.enter) {
switch (i.type) {
case byVal:
case byRef:
for (const i of s.sub()) {
if (i.enter) {
if (i.type !== Tag.Identifier || i.value.sym)
throw s.error("expected list of declared identifiers");
i.value.sym.byVal = i.type === byVal;
i.value.sym.byValStrict = true;
}
}
s.close(i);
continue;
case Tag.Identifier:
const si = i.value.sym;
if (si != null && si.decl) {
const symRoot = si.declScope;
si.global = !symRoot || symRoot === top;
si.track = !!s.track;
if (si.byVal == null) si.byVal = !si.global && s.opts.state;
si.singleAssign = undefined;
}
root.track = false;
for (const i of s.sub()) {
if (i.enter) {
switch (i.type) {
case Tag.Super:
supers.add(root);
break;
case Tag.FunctionDeclaration:
case Tag.ArrowFunctionExpression:
case Tag.FunctionExpression:
case Tag.ObjectMethod:
case Tag.ClassMethod:
i.value.parentScope = root;
collectScopes(i.value);
break;
case Tag.Identifier:
const si = i.value.sym;
if (si != null) {
const { lhs } = i.value;
const symRoot = si.declScope;
if (!symRoot) break;
if (i.value.decl) {
symRoot.scopeDecls.add(si);
allDecls.push(i.value);
si.singleAssign = si.singleAssign == null ? lhs : false;
} else {
i.value.ext = false;
if (lhs) si.singleAssign = false;
const decl = si.declScope;
if (decl !== root) {
(si.refScopes || (si.refScopes = new Set())).add(root);
capt.add(si);
case Tag.VariableDeclaration:
const kind = i.value.node.kind;
i.value.node.kind = "var";
const declarators = [];
const stmt = i.pos !== Tag.init && i.pos !== Tag.left;
sl.peel(i);
sl.peel();
for (const j of sl.sub()) {
invariant(j.enter);
invariant(j.type === Tag.VariableDeclarator);
let hasInit = false;
const asgn = [];
const id = [...sl.one()];
asgn.push(...id);
for (const j of id) {
if (j.enter && j.type === Tag.Identifier && j.value.decl) {
const sym = j.value.sym;
if (!sym.noDecl && !decls.has(sym)) {
decls.set(sym, { raw: null, node: j.value.node });
}
j.value.decl = false;
}
}
if (sl.cur().pos === Tag.init) {
asgn.push(...Kit.reposOne(sl.one(), Tag.right));
hasInit = true;
} else if (kind === "let" && i.pos !== Tag.left) {
asgn.push(
sl.tok(Tag.right, Tag.Identifier, {
sym: Kit.scope.undefinedSym
})
);
function* prepare(s) {
const stack = [];
const si = lookahead(s);
for (const i of si) {
let key = false;
switch (i.pos) {
case Tag.label:
if (i.enter) skip(sub(si));
continue;
case Tag.id:
key = true;
break;
case Tag.property:
case Tag.key:
if (i.enter && i.type === Tag.Identifier) {
const f = stack[0];
if (f && f.computed) key = true;
}
break;
}
if (i.enter) {
const tv = tagValue(i.pos, i.type, { node: i.value.node });
if (key) tv.expr = false;
stack.unshift(tv);
}
yield {
enter: i.enter,
leave: i.leave,
type: i.type,
pos: i.pos,
value: stack[0]