packages/babel-generator/src/node/whitespace.js
import * as t from "@babel/types";
type WhitespaceObject = {
before?: boolean,
after?: boolean,
};
/**
* Crawl a node to test if it contains a CallExpression, a Function, or a Helper.
*
* @example
* crawl(node)
* // { hasCall: false, hasFunction: true, hasHelper: false }
*/
function crawl(node, state = {}) {
if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
crawl(node.object, state);
if (node.computed) crawl(node.property, state);
} else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
crawl(node.left, state);
crawl(node.right, state);
} else if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
state.hasCall = true;
crawl(node.callee, state);
} else if (t.isFunction(node)) {
state.hasFunction = true;
} else if (t.isIdentifier(node)) {
state.hasHelper = state.hasHelper || isHelper(node.callee);
}
return state;
}
/**
* Test if a node is or has a helper.
*/
function isHelper(node) {
if (t.isMemberExpression(node)) {
return isHelper(node.object) || isHelper(node.property);
} else if (t.isIdentifier(node)) {
return node.name === "require" || node.name[0] === "_";
} else if (t.isCallExpression(node)) {
return isHelper(node.callee);
} else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
return (
(t.isIdentifier(node.left) && isHelper(node.left)) || isHelper(node.right)
);
} else {
return false;
}
}
function isType(node) {
return (
t.isLiteral(node) ||
t.isObjectExpression(node) ||
t.isArrayExpression(node) ||
t.isIdentifier(node) ||
t.isMemberExpression(node)
);
}
/**
* Tests for node types that need whitespace.
*/
export const nodes = {
/**
* Test if AssignmentExpression needs whitespace.
*/
AssignmentExpression(node: Object): ?WhitespaceObject {
const state = crawl(node.right);
if ((state.hasCall && state.hasHelper) || state.hasFunction) {
return {
before: state.hasFunction,
after: true,
};
}
},
/**
* Test if SwitchCase needs whitespace.
*/
SwitchCase(node: Object, parent: Object): WhitespaceObject {
return {
before: node.consequent.length || parent.cases[0] === node,
after:
!node.consequent.length &&
parent.cases[parent.cases.length - 1] === node,
};
},
/**
* Test if LogicalExpression needs whitespace.
*/
LogicalExpression(node: Object): ?WhitespaceObject {
if (t.isFunction(node.left) || t.isFunction(node.right)) {
return {
after: true,
};
}
},
/**
* Test if Literal needs whitespace.
*/
Literal(node: Object): ?WhitespaceObject {
if (node.value === "use strict") {
return {
after: true,
};
}
},
/**
* Test if CallExpressionish needs whitespace.
*/
CallExpression(node: Object): ?WhitespaceObject {
if (t.isFunction(node.callee) || isHelper(node)) {
return {
before: true,
after: true,
};
}
},
OptionalCallExpression(node: Object): ?WhitespaceObject {
if (t.isFunction(node.callee)) {
return {
before: true,
after: true,
};
}
},
/**
* Test if VariableDeclaration needs whitespace.
*/
VariableDeclaration(node: Object): ?WhitespaceObject {
for (let i = 0; i < node.declarations.length; i++) {
const declar = node.declarations[i];
let enabled = isHelper(declar.id) && !isType(declar.init);
if (!enabled) {
const state = crawl(declar.init);
enabled = (isHelper(declar.init) && state.hasCall) || state.hasFunction;
}
if (enabled) {
return {
before: true,
after: true,
};
}
}
},
/**
* Test if IfStatement needs whitespace.
*/
IfStatement(node: Object): ?WhitespaceObject {
if (t.isBlockStatement(node.consequent)) {
return {
before: true,
after: true,
};
}
},
};
/**
* Test if Property needs whitespace.
*/
nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (
node: Object,
parent,
): ?WhitespaceObject {
if (parent.properties[0] === node) {
return {
before: true,
};
}
};
nodes.ObjectTypeCallProperty = function (
node: Object,
parent,
): ?WhitespaceObject {
if (parent.callProperties[0] === node && !parent.properties?.length) {
return {
before: true,
};
}
};
nodes.ObjectTypeIndexer = function (node: Object, parent): ?WhitespaceObject {
if (
parent.indexers[0] === node &&
!parent.properties?.length &&
!parent.callProperties?.length
) {
return {
before: true,
};
}
};
nodes.ObjectTypeInternalSlot = function (
node: Object,
parent,
): ?WhitespaceObject {
if (
parent.internalSlots[0] === node &&
!parent.properties?.length &&
!parent.callProperties?.length &&
!parent.indexers?.length
) {
return {
before: true,
};
}
};
/**
* Returns lists from node types that need whitespace.
*/
export const list = {
/**
* Return VariableDeclaration declarations init properties.
*/
VariableDeclaration(node: Object): Array<Object> {
return node.declarations.map(decl => decl.init);
},
/**
* Return VariableDeclaration elements.
*/
ArrayExpression(node: Object): Array<Object> {
return node.elements;
},
/**
* Return VariableDeclaration properties.
*/
ObjectExpression(node: Object): Array<Object> {
return node.properties;
},
};
/**
* Add whitespace tests for nodes and their aliases.
*/
[
["Function", true],
["Class", true],
["Loop", true],
["LabeledStatement", true],
["SwitchStatement", true],
["TryStatement", true],
].forEach(function ([type, amounts]) {
if (typeof amounts === "boolean") {
amounts = { after: amounts, before: amounts };
}
[type].concat(t.FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
nodes[type] = function () {
return amounts;
};
});
});