|
|
"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._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); |
|
|
} |
|
|
|
|
|
|
|
|
|
