You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
343 lines
9.9 KiB
343 lines
9.9 KiB
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports._getKey = _getKey;
|
|
exports._getPattern = _getPattern;
|
|
exports.get = get;
|
|
exports.getAllNextSiblings = getAllNextSiblings;
|
|
exports.getAllPrevSiblings = getAllPrevSiblings;
|
|
exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
|
|
exports.getBindingIdentifiers = getBindingIdentifiers;
|
|
exports.getCompletionRecords = getCompletionRecords;
|
|
exports.getNextSibling = getNextSibling;
|
|
exports.getOpposite = getOpposite;
|
|
exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
|
|
exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
|
|
exports.getPrevSibling = getPrevSibling;
|
|
exports.getSibling = getSibling;
|
|
var _index = require("./index");
|
|
var _t = require("@babel/types");
|
|
const {
|
|
getBindingIdentifiers: _getBindingIdentifiers,
|
|
getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
|
|
isDeclaration,
|
|
numericLiteral,
|
|
unaryExpression
|
|
} = _t;
|
|
const NORMAL_COMPLETION = 0;
|
|
const BREAK_COMPLETION = 1;
|
|
function NormalCompletion(path) {
|
|
return {
|
|
type: NORMAL_COMPLETION,
|
|
path
|
|
};
|
|
}
|
|
function BreakCompletion(path) {
|
|
return {
|
|
type: BREAK_COMPLETION,
|
|
path
|
|
};
|
|
}
|
|
function getOpposite() {
|
|
if (this.key === "left") {
|
|
return this.getSibling("right");
|
|
} else if (this.key === "right") {
|
|
return this.getSibling("left");
|
|
}
|
|
return null;
|
|
}
|
|
function addCompletionRecords(path, records, context) {
|
|
if (path) {
|
|
records.push(..._getCompletionRecords(path, context));
|
|
}
|
|
return records;
|
|
}
|
|
function completionRecordForSwitch(cases, records, context) {
|
|
let lastNormalCompletions = [];
|
|
for (let i = 0; i < cases.length; i++) {
|
|
const casePath = cases[i];
|
|
const caseCompletions = _getCompletionRecords(casePath, context);
|
|
const normalCompletions = [];
|
|
const breakCompletions = [];
|
|
for (const c of caseCompletions) {
|
|
if (c.type === NORMAL_COMPLETION) {
|
|
normalCompletions.push(c);
|
|
}
|
|
if (c.type === BREAK_COMPLETION) {
|
|
breakCompletions.push(c);
|
|
}
|
|
}
|
|
if (normalCompletions.length) {
|
|
lastNormalCompletions = normalCompletions;
|
|
}
|
|
records.push(...breakCompletions);
|
|
}
|
|
records.push(...lastNormalCompletions);
|
|
return records;
|
|
}
|
|
function normalCompletionToBreak(completions) {
|
|
completions.forEach(c => {
|
|
c.type = BREAK_COMPLETION;
|
|
});
|
|
}
|
|
|
|
function replaceBreakStatementInBreakCompletion(completions, reachable) {
|
|
completions.forEach(c => {
|
|
if (c.path.isBreakStatement({
|
|
label: null
|
|
})) {
|
|
if (reachable) {
|
|
c.path.replaceWith(unaryExpression("void", numericLiteral(0)));
|
|
} else {
|
|
c.path.remove();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function getStatementListCompletion(paths, context) {
|
|
const completions = [];
|
|
if (context.canHaveBreak) {
|
|
let lastNormalCompletions = [];
|
|
for (let i = 0; i < paths.length; i++) {
|
|
const path = paths[i];
|
|
const newContext = Object.assign({}, context, {
|
|
inCaseClause: false
|
|
});
|
|
if (path.isBlockStatement() && (context.inCaseClause ||
|
|
context.shouldPopulateBreak)) {
|
|
newContext.shouldPopulateBreak = true;
|
|
} else {
|
|
newContext.shouldPopulateBreak = false;
|
|
}
|
|
const statementCompletions = _getCompletionRecords(path, newContext);
|
|
if (statementCompletions.length > 0 &&
|
|
statementCompletions.every(c => c.type === BREAK_COMPLETION)) {
|
|
if (lastNormalCompletions.length > 0 && statementCompletions.every(c => c.path.isBreakStatement({
|
|
label: null
|
|
}))) {
|
|
normalCompletionToBreak(lastNormalCompletions);
|
|
completions.push(...lastNormalCompletions);
|
|
if (lastNormalCompletions.some(c => c.path.isDeclaration())) {
|
|
completions.push(...statementCompletions);
|
|
replaceBreakStatementInBreakCompletion(statementCompletions, true);
|
|
}
|
|
replaceBreakStatementInBreakCompletion(statementCompletions, false);
|
|
} else {
|
|
completions.push(...statementCompletions);
|
|
if (!context.shouldPopulateBreak) {
|
|
replaceBreakStatementInBreakCompletion(statementCompletions, true);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (i === paths.length - 1) {
|
|
completions.push(...statementCompletions);
|
|
} else {
|
|
lastNormalCompletions = [];
|
|
for (let i = 0; i < statementCompletions.length; i++) {
|
|
const c = statementCompletions[i];
|
|
if (c.type === BREAK_COMPLETION) {
|
|
completions.push(c);
|
|
}
|
|
if (c.type === NORMAL_COMPLETION) {
|
|
lastNormalCompletions.push(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (paths.length) {
|
|
for (let i = paths.length - 1; i >= 0; i--) {
|
|
const pathCompletions = _getCompletionRecords(paths[i], context);
|
|
if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration()) {
|
|
completions.push(...pathCompletions);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return completions;
|
|
}
|
|
function _getCompletionRecords(path, context) {
|
|
let records = [];
|
|
if (path.isIfStatement()) {
|
|
records = addCompletionRecords(path.get("consequent"), records, context);
|
|
records = addCompletionRecords(path.get("alternate"), records, context);
|
|
} else if (path.isDoExpression() || path.isFor() || path.isWhile() || path.isLabeledStatement()) {
|
|
return addCompletionRecords(path.get("body"), records, context);
|
|
} else if (path.isProgram() || path.isBlockStatement()) {
|
|
return getStatementListCompletion(path.get("body"), context);
|
|
} else if (path.isFunction()) {
|
|
return _getCompletionRecords(path.get("body"), context);
|
|
} else if (path.isTryStatement()) {
|
|
records = addCompletionRecords(path.get("block"), records, context);
|
|
records = addCompletionRecords(path.get("handler"), records, context);
|
|
} else if (path.isCatchClause()) {
|
|
return addCompletionRecords(path.get("body"), records, context);
|
|
} else if (path.isSwitchStatement()) {
|
|
return completionRecordForSwitch(path.get("cases"), records, context);
|
|
} else if (path.isSwitchCase()) {
|
|
return getStatementListCompletion(path.get("consequent"), {
|
|
canHaveBreak: true,
|
|
shouldPopulateBreak: false,
|
|
inCaseClause: true
|
|
});
|
|
} else if (path.isBreakStatement()) {
|
|
records.push(BreakCompletion(path));
|
|
} else {
|
|
records.push(NormalCompletion(path));
|
|
}
|
|
return records;
|
|
}
|
|
|
|
function getCompletionRecords() {
|
|
const records = _getCompletionRecords(this, {
|
|
canHaveBreak: false,
|
|
shouldPopulateBreak: false,
|
|
inCaseClause: false
|
|
});
|
|
return records.map(r => r.path);
|
|
}
|
|
function getSibling(key) {
|
|
return _index.default.get({
|
|
parentPath: this.parentPath,
|
|
parent: this.parent,
|
|
container: this.container,
|
|
listKey: this.listKey,
|
|
key: key
|
|
}).setContext(this.context);
|
|
}
|
|
function getPrevSibling() {
|
|
return this.getSibling(this.key - 1);
|
|
}
|
|
function getNextSibling() {
|
|
return this.getSibling(this.key + 1);
|
|
}
|
|
function getAllNextSiblings() {
|
|
let _key = this.key;
|
|
let sibling = this.getSibling(++_key);
|
|
const siblings = [];
|
|
while (sibling.node) {
|
|
siblings.push(sibling);
|
|
sibling = this.getSibling(++_key);
|
|
}
|
|
return siblings;
|
|
}
|
|
function getAllPrevSiblings() {
|
|
let _key = this.key;
|
|
let sibling = this.getSibling(--_key);
|
|
const siblings = [];
|
|
while (sibling.node) {
|
|
siblings.push(sibling);
|
|
sibling = this.getSibling(--_key);
|
|
}
|
|
return siblings;
|
|
}
|
|
|
|
function get(key, context = true) {
|
|
if (context === true) context = this.context;
|
|
const parts = key.split(".");
|
|
if (parts.length === 1) {
|
|
return this._getKey(key, context);
|
|
} else {
|
|
return this._getPattern(parts, context);
|
|
}
|
|
}
|
|
function _getKey(key, context) {
|
|
const node = this.node;
|
|
const container = node[key];
|
|
if (Array.isArray(container)) {
|
|
return container.map((_, i) => {
|
|
return _index.default.get({
|
|
listKey: key,
|
|
parentPath: this,
|
|
parent: node,
|
|
container: container,
|
|
key: i
|
|
}).setContext(context);
|
|
});
|
|
} else {
|
|
return _index.default.get({
|
|
parentPath: this,
|
|
parent: node,
|
|
container: node,
|
|
key: key
|
|
}).setContext(context);
|
|
}
|
|
}
|
|
function _getPattern(parts, context) {
|
|
let path = this;
|
|
for (const part of parts) {
|
|
if (part === ".") {
|
|
path = path.parentPath;
|
|
} else {
|
|
if (Array.isArray(path)) {
|
|
path = path[part];
|
|
} else {
|
|
path = path.get(part, context);
|
|
}
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
function getBindingIdentifiers(duplicates) {
|
|
return _getBindingIdentifiers(this.node, duplicates);
|
|
}
|
|
function getOuterBindingIdentifiers(duplicates) {
|
|
return _getOuterBindingIdentifiers(this.node, duplicates);
|
|
}
|
|
function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
|
|
const path = this;
|
|
const search = [path];
|
|
const ids = Object.create(null);
|
|
while (search.length) {
|
|
const id = search.shift();
|
|
if (!id) continue;
|
|
if (!id.node) continue;
|
|
const keys =
|
|
_getBindingIdentifiers.keys[id.node.type];
|
|
if (id.isIdentifier()) {
|
|
if (duplicates) {
|
|
const _ids = ids[id.node.name] = ids[id.node.name] || [];
|
|
_ids.push(id);
|
|
} else {
|
|
ids[id.node.name] = id;
|
|
}
|
|
continue;
|
|
}
|
|
if (id.isExportDeclaration()) {
|
|
const declaration = id.get("declaration");
|
|
if (isDeclaration(declaration)) {
|
|
search.push(declaration);
|
|
}
|
|
continue;
|
|
}
|
|
if (outerOnly) {
|
|
if (id.isFunctionDeclaration()) {
|
|
search.push(id.get("id"));
|
|
continue;
|
|
}
|
|
if (id.isFunctionExpression()) {
|
|
continue;
|
|
}
|
|
}
|
|
if (keys) {
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const key = keys[i];
|
|
const child = id.get(key);
|
|
if (Array.isArray(child)) {
|
|
search.push(...child);
|
|
} else if (child.node) {
|
|
search.push(child);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ids;
|
|
}
|
|
function getOuterBindingIdentifierPaths(duplicates = false) {
|
|
return this.getBindingIdentifierPaths(duplicates, true);
|
|
}
|
|
|
|
//# sourceMappingURL=family.js.map
|