294 lines
11 KiB
JavaScript
294 lines
11 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = exports.SHOULD_STOP = exports.SHOULD_SKIP = exports.REMOVED = void 0;
|
|
var virtualTypes = require("./lib/virtual-types.js");
|
|
var _debug = require("debug");
|
|
var _index = require("../index.js");
|
|
var _index2 = require("../scope/index.js");
|
|
var _t = require("@babel/types");
|
|
var t = _t;
|
|
var cache = require("../cache.js");
|
|
var _generator = require("@babel/generator");
|
|
var NodePath_ancestry = require("./ancestry.js");
|
|
var NodePath_inference = require("./inference/index.js");
|
|
var NodePath_replacement = require("./replacement.js");
|
|
var NodePath_evaluation = require("./evaluation.js");
|
|
var NodePath_conversion = require("./conversion.js");
|
|
var NodePath_introspection = require("./introspection.js");
|
|
var _context = require("./context.js");
|
|
var NodePath_context = _context;
|
|
var NodePath_removal = require("./removal.js");
|
|
var NodePath_modification = require("./modification.js");
|
|
var NodePath_family = require("./family.js");
|
|
var NodePath_comments = require("./comments.js");
|
|
var NodePath_virtual_types_validator = require("./lib/virtual-types-validator.js");
|
|
const {
|
|
validate
|
|
} = _t;
|
|
const debug = _debug("babel");
|
|
const REMOVED = exports.REMOVED = 1 << 0;
|
|
const SHOULD_STOP = exports.SHOULD_STOP = 1 << 1;
|
|
const SHOULD_SKIP = exports.SHOULD_SKIP = 1 << 2;
|
|
const NodePath_Final = exports.default = class NodePath {
|
|
constructor(hub, parent) {
|
|
this.contexts = [];
|
|
this.state = null;
|
|
this.opts = null;
|
|
this._traverseFlags = 0;
|
|
this.skipKeys = null;
|
|
this.parentPath = null;
|
|
this.container = null;
|
|
this.listKey = null;
|
|
this.key = null;
|
|
this.node = null;
|
|
this.type = null;
|
|
this._store = null;
|
|
this.parent = parent;
|
|
this.hub = hub;
|
|
this.data = null;
|
|
this.context = null;
|
|
this.scope = null;
|
|
}
|
|
get removed() {
|
|
return (this._traverseFlags & 1) > 0;
|
|
}
|
|
set removed(v) {
|
|
if (v) this._traverseFlags |= 1;else this._traverseFlags &= -2;
|
|
}
|
|
get shouldStop() {
|
|
return (this._traverseFlags & 2) > 0;
|
|
}
|
|
set shouldStop(v) {
|
|
if (v) this._traverseFlags |= 2;else this._traverseFlags &= -3;
|
|
}
|
|
get shouldSkip() {
|
|
return (this._traverseFlags & 4) > 0;
|
|
}
|
|
set shouldSkip(v) {
|
|
if (v) this._traverseFlags |= 4;else this._traverseFlags &= -5;
|
|
}
|
|
static get({
|
|
hub,
|
|
parentPath,
|
|
parent,
|
|
container,
|
|
listKey,
|
|
key
|
|
}) {
|
|
if (!hub && parentPath) {
|
|
hub = parentPath.hub;
|
|
}
|
|
if (!parent) {
|
|
throw new Error("To get a node path the parent needs to exist");
|
|
}
|
|
const targetNode = container[key];
|
|
const paths = cache.getOrCreateCachedPaths(parent, parentPath);
|
|
let path = paths.get(targetNode);
|
|
if (!path) {
|
|
path = new NodePath(hub, parent);
|
|
if (targetNode) paths.set(targetNode, path);
|
|
}
|
|
_context.setup.call(path, parentPath, container, listKey, key);
|
|
return path;
|
|
}
|
|
getScope(scope) {
|
|
return this.isScope() ? new _index2.default(this) : scope;
|
|
}
|
|
setData(key, val) {
|
|
if (this.data == null) {
|
|
this.data = Object.create(null);
|
|
}
|
|
return this.data[key] = val;
|
|
}
|
|
getData(key, def) {
|
|
if (this.data == null) {
|
|
this.data = Object.create(null);
|
|
}
|
|
let val = this.data[key];
|
|
if (val === undefined && def !== undefined) val = this.data[key] = def;
|
|
return val;
|
|
}
|
|
hasNode() {
|
|
return this.node != null;
|
|
}
|
|
buildCodeFrameError(msg, Error = SyntaxError) {
|
|
return this.hub.buildError(this.node, msg, Error);
|
|
}
|
|
traverse(visitor, state) {
|
|
(0, _index.default)(this.node, visitor, this.scope, state, this);
|
|
}
|
|
set(key, node) {
|
|
validate(this.node, key, node);
|
|
this.node[key] = node;
|
|
}
|
|
getPathLocation() {
|
|
const parts = [];
|
|
let path = this;
|
|
do {
|
|
let key = path.key;
|
|
if (path.inList) key = `${path.listKey}[${key}]`;
|
|
parts.unshift(key);
|
|
} while (path = path.parentPath);
|
|
return parts.join(".");
|
|
}
|
|
debug(message) {
|
|
if (!debug.enabled) return;
|
|
debug(`${this.getPathLocation()} ${this.type}: ${message}`);
|
|
}
|
|
toString() {
|
|
return (0, _generator.default)(this.node).code;
|
|
}
|
|
get inList() {
|
|
return !!this.listKey;
|
|
}
|
|
set inList(inList) {
|
|
if (!inList) {
|
|
this.listKey = null;
|
|
}
|
|
}
|
|
get parentKey() {
|
|
return this.listKey || this.key;
|
|
}
|
|
};
|
|
const methods = {
|
|
findParent: NodePath_ancestry.findParent,
|
|
find: NodePath_ancestry.find,
|
|
getFunctionParent: NodePath_ancestry.getFunctionParent,
|
|
getStatementParent: NodePath_ancestry.getStatementParent,
|
|
getEarliestCommonAncestorFrom: NodePath_ancestry.getEarliestCommonAncestorFrom,
|
|
getDeepestCommonAncestorFrom: NodePath_ancestry.getDeepestCommonAncestorFrom,
|
|
getAncestry: NodePath_ancestry.getAncestry,
|
|
isAncestor: NodePath_ancestry.isAncestor,
|
|
isDescendant: NodePath_ancestry.isDescendant,
|
|
inType: NodePath_ancestry.inType,
|
|
getTypeAnnotation: NodePath_inference.getTypeAnnotation,
|
|
isBaseType: NodePath_inference.isBaseType,
|
|
couldBeBaseType: NodePath_inference.couldBeBaseType,
|
|
baseTypeStrictlyMatches: NodePath_inference.baseTypeStrictlyMatches,
|
|
isGenericType: NodePath_inference.isGenericType,
|
|
replaceWithMultiple: NodePath_replacement.replaceWithMultiple,
|
|
replaceWithSourceString: NodePath_replacement.replaceWithSourceString,
|
|
replaceWith: NodePath_replacement.replaceWith,
|
|
replaceExpressionWithStatements: NodePath_replacement.replaceExpressionWithStatements,
|
|
replaceInline: NodePath_replacement.replaceInline,
|
|
evaluateTruthy: NodePath_evaluation.evaluateTruthy,
|
|
evaluate: NodePath_evaluation.evaluate,
|
|
toComputedKey: NodePath_conversion.toComputedKey,
|
|
ensureBlock: NodePath_conversion.ensureBlock,
|
|
unwrapFunctionEnvironment: NodePath_conversion.unwrapFunctionEnvironment,
|
|
arrowFunctionToExpression: NodePath_conversion.arrowFunctionToExpression,
|
|
splitExportDeclaration: NodePath_conversion.splitExportDeclaration,
|
|
ensureFunctionName: NodePath_conversion.ensureFunctionName,
|
|
matchesPattern: NodePath_introspection.matchesPattern,
|
|
isStatic: NodePath_introspection.isStatic,
|
|
isNodeType: NodePath_introspection.isNodeType,
|
|
canHaveVariableDeclarationOrExpression: NodePath_introspection.canHaveVariableDeclarationOrExpression,
|
|
canSwapBetweenExpressionAndStatement: NodePath_introspection.canSwapBetweenExpressionAndStatement,
|
|
isCompletionRecord: NodePath_introspection.isCompletionRecord,
|
|
isStatementOrBlock: NodePath_introspection.isStatementOrBlock,
|
|
referencesImport: NodePath_introspection.referencesImport,
|
|
getSource: NodePath_introspection.getSource,
|
|
willIMaybeExecuteBefore: NodePath_introspection.willIMaybeExecuteBefore,
|
|
_guessExecutionStatusRelativeTo: NodePath_introspection._guessExecutionStatusRelativeTo,
|
|
resolve: NodePath_introspection.resolve,
|
|
isConstantExpression: NodePath_introspection.isConstantExpression,
|
|
isInStrictMode: NodePath_introspection.isInStrictMode,
|
|
isDenylisted: NodePath_context.isDenylisted,
|
|
visit: NodePath_context.visit,
|
|
skip: NodePath_context.skip,
|
|
skipKey: NodePath_context.skipKey,
|
|
stop: NodePath_context.stop,
|
|
setContext: NodePath_context.setContext,
|
|
requeue: NodePath_context.requeue,
|
|
requeueComputedKeyAndDecorators: NodePath_context.requeueComputedKeyAndDecorators,
|
|
remove: NodePath_removal.remove,
|
|
insertBefore: NodePath_modification.insertBefore,
|
|
insertAfter: NodePath_modification.insertAfter,
|
|
unshiftContainer: NodePath_modification.unshiftContainer,
|
|
pushContainer: NodePath_modification.pushContainer,
|
|
getOpposite: NodePath_family.getOpposite,
|
|
getCompletionRecords: NodePath_family.getCompletionRecords,
|
|
getSibling: NodePath_family.getSibling,
|
|
getPrevSibling: NodePath_family.getPrevSibling,
|
|
getNextSibling: NodePath_family.getNextSibling,
|
|
getAllNextSiblings: NodePath_family.getAllNextSiblings,
|
|
getAllPrevSiblings: NodePath_family.getAllPrevSiblings,
|
|
get: NodePath_family.get,
|
|
getAssignmentIdentifiers: NodePath_family.getAssignmentIdentifiers,
|
|
getBindingIdentifiers: NodePath_family.getBindingIdentifiers,
|
|
getOuterBindingIdentifiers: NodePath_family.getOuterBindingIdentifiers,
|
|
getBindingIdentifierPaths: NodePath_family.getBindingIdentifierPaths,
|
|
getOuterBindingIdentifierPaths: NodePath_family.getOuterBindingIdentifierPaths,
|
|
shareCommentsWithSiblings: NodePath_comments.shareCommentsWithSiblings,
|
|
addComment: NodePath_comments.addComment,
|
|
addComments: NodePath_comments.addComments
|
|
};
|
|
Object.assign(NodePath_Final.prototype, methods);
|
|
{
|
|
NodePath_Final.prototype.arrowFunctionToShadowed = NodePath_conversion[String("arrowFunctionToShadowed")];
|
|
Object.assign(NodePath_Final.prototype, {
|
|
has: NodePath_introspection[String("has")],
|
|
is: NodePath_introspection[String("is")],
|
|
isnt: NodePath_introspection[String("isnt")],
|
|
equals: NodePath_introspection[String("equals")],
|
|
hoist: NodePath_modification[String("hoist")],
|
|
updateSiblingKeys: NodePath_modification.updateSiblingKeys,
|
|
call: NodePath_context.call,
|
|
isBlacklisted: NodePath_context[String("isBlacklisted")],
|
|
setScope: NodePath_context.setScope,
|
|
resync: NodePath_context.resync,
|
|
popContext: NodePath_context.popContext,
|
|
pushContext: NodePath_context.pushContext,
|
|
setup: NodePath_context.setup,
|
|
setKey: NodePath_context.setKey
|
|
});
|
|
}
|
|
{
|
|
NodePath_Final.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
|
|
NodePath_Final.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
|
|
Object.assign(NodePath_Final.prototype, {
|
|
_getTypeAnnotation: NodePath_inference._getTypeAnnotation,
|
|
_replaceWith: NodePath_replacement._replaceWith,
|
|
_resolve: NodePath_introspection._resolve,
|
|
_call: NodePath_context._call,
|
|
_resyncParent: NodePath_context._resyncParent,
|
|
_resyncKey: NodePath_context._resyncKey,
|
|
_resyncList: NodePath_context._resyncList,
|
|
_resyncRemoved: NodePath_context._resyncRemoved,
|
|
_getQueueContexts: NodePath_context._getQueueContexts,
|
|
_removeFromScope: NodePath_removal._removeFromScope,
|
|
_callRemovalHooks: NodePath_removal._callRemovalHooks,
|
|
_remove: NodePath_removal._remove,
|
|
_markRemoved: NodePath_removal._markRemoved,
|
|
_assertUnremoved: NodePath_removal._assertUnremoved,
|
|
_containerInsert: NodePath_modification._containerInsert,
|
|
_containerInsertBefore: NodePath_modification._containerInsertBefore,
|
|
_containerInsertAfter: NodePath_modification._containerInsertAfter,
|
|
_verifyNodeList: NodePath_modification._verifyNodeList,
|
|
_getKey: NodePath_family._getKey,
|
|
_getPattern: NodePath_family._getPattern
|
|
});
|
|
}
|
|
for (const type of t.TYPES) {
|
|
const typeKey = `is${type}`;
|
|
const fn = t[typeKey];
|
|
NodePath_Final.prototype[typeKey] = function (opts) {
|
|
return fn(this.node, opts);
|
|
};
|
|
NodePath_Final.prototype[`assert${type}`] = function (opts) {
|
|
if (!fn(this.node, opts)) {
|
|
throw new TypeError(`Expected node path of type ${type}`);
|
|
}
|
|
};
|
|
}
|
|
Object.assign(NodePath_Final.prototype, NodePath_virtual_types_validator);
|
|
for (const type of Object.keys(virtualTypes)) {
|
|
if (type[0] === "_") continue;
|
|
if (!t.TYPES.includes(type)) t.TYPES.push(type);
|
|
}
|
|
|
|
//# sourceMappingURL=index.js.map
|