Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#include "frontend/NameFunctions.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/Sprintf.h"
#include "frontend/ParseNode.h"
#include "frontend/ParseNodeVisitor.h"
#include "frontend/ParserAtom.h" // ParserAtomsTable
#include "frontend/SharedContext.h"
#include "util/Poison.h"
#include "util/StringBuilder.h"
using namespace js;
using namespace js::frontend;
namespace {
class NameResolver : public ParseNodeVisitor<NameResolver> {
using Base = ParseNodeVisitor;
static const size_t MaxParents = 100;
FrontendContext* fc_;
ParserAtomsTable& parserAtoms_;
TaggedParserAtomIndex prefix_;
// Number of nodes in the parents array.
size_t nparents_;
// Stack of ParseNodes from the root to the current node.
// Only elements 0..nparents_ are initialized.
MOZ_INIT_OUTSIDE_CTOR
ParseNode* parents_[MaxParents];
// When naming a function, the buffer where the name is built.
// When we are not under resolveFun, buf_ is empty.
StringBuilder buf_;
/* Test whether a ParseNode represents a function invocation */
bool isCall(ParseNode* pn) {
return pn && pn->isKind(ParseNodeKind::CallExpr);
}
/*
* Append a reference to a property named |name| to |buf_|. If |name| is
* a proper identifier name, then we append '.name'; otherwise, we
* append '["name"]'.
*
* Note that we need the IsIdentifier check for atoms from both
* ParseNodeKind::Name nodes and ParseNodeKind::String nodes:
* given code like a["b c"], the front end will produce a ParseNodeKind::Dot
* with a ParseNodeKind::Name child whose name contains spaces.
*/
bool appendPropertyReference(TaggedParserAtomIndex name) {
if (parserAtoms_.isIdentifier(name)) {
return buf_.append('.') && buf_.append(parserAtoms_, name);
}
/* Quote the string as needed. */
UniqueChars source = parserAtoms_.toQuotedString(name);
if (!source) {
ReportOutOfMemory(fc_);
return false;
}
return buf_.append('[') &&
buf_.append(source.get(), strlen(source.get())) && buf_.append(']');
}
/* Append a number to buf_. */
bool appendNumber(double n) {
char number[30];
int digits = SprintfLiteral(number, "%g", n);
return buf_.append(number, digits);
}
// Append "[<n>]" to buf_, referencing a property named by a numeric literal.
bool appendNumericPropertyReference(double n) {
return buf_.append("[") && appendNumber(n) && buf_.append(']');
}
/*
* Walk over the given ParseNode, attempting to convert it to a stringified
* name that represents where the function is being assigned to.
*
* |*foundName| is set to true if a name is found for the expression.
*/
bool nameExpression(ParseNode* n, bool* foundName) {
switch (n->getKind()) {
case ParseNodeKind::ArgumentsLength:
case ParseNodeKind::DotExpr: {
PropertyAccess* prop = &n->as<PropertyAccess>();
if (!nameExpression(&prop->expression(), foundName)) {
return false;
}
if (!*foundName) {
return true;
}
return appendPropertyReference(prop->right()->as<NameNode>().atom());
}
case ParseNodeKind::Name:
case ParseNodeKind::PrivateName: {
*foundName = true;
return buf_.append(parserAtoms_, n->as<NameNode>().atom());
}
case ParseNodeKind::ThisExpr:
*foundName = true;
return buf_.append("this");
case ParseNodeKind::ElemExpr: {
PropertyByValue* elem = &n->as<PropertyByValue>();
if (!nameExpression(&elem->expression(), foundName)) {
return false;
}
if (!*foundName) {
return true;
}
if (!buf_.append('[') || !nameExpression(elem->right(), foundName)) {
return false;
}
if (!*foundName) {
return true;
}
return buf_.append(']');
}
case ParseNodeKind::NumberExpr:
*foundName = true;
return appendNumber(n->as<NumericLiteral>().value());
default:
// We're confused as to what to call this function.
*foundName = false;
return true;
}
}
/*
* When naming an anonymous function, the process works loosely by walking
* up the AST and then translating that to a string. The stringification
* happens from some far-up assignment and then going back down the parse
* tree to the function definition point.
*
* This function will walk up the parse tree, gathering relevant nodes used
* for naming, and return the assignment node if there is one. The provided
* array and size will be filled in, and the returned node could be nullptr
* if no assignment is found. The first element of the array will be the
* innermost node relevant to naming, and the last element will be the
* outermost node.
*/
ParseNode* gatherNameable(ParseNode** nameable, size_t* size) {
MOZ_ASSERT(nparents_ > 0);
MOZ_ASSERT(parents_[nparents_ - 1]->is<FunctionNode>());
*size = 0;
for (int pos = nparents_ - 2; pos >= 0; pos--) {
ParseNode* cur = parents_[pos];
if (cur->is<AssignmentNode>()) {
return cur;
}
switch (cur->getKind()) {
case ParseNodeKind::PrivateName:
case ParseNodeKind::Name:
return cur; // found the initialized declaration
case ParseNodeKind::ThisExpr:
return cur; // setting a property of 'this'
case ParseNodeKind::Function:
return nullptr; // won't find an assignment or declaration
case ParseNodeKind::ReturnStmt:
// Normally the relevant parent of a node is its direct parent, but
// sometimes with code like:
//
// var foo = (function() { return function() {}; })();
//
// the outer function is just a helper to create a scope for the
// returned function. Hence the name of the returned function should
// actually be 'foo'. This loop sees if the current node is a
// ParseNodeKind::Return, and if there is a direct function
// call we skip to that.
for (int tmp = pos - 1; tmp > 0; tmp--) {
if (isDirectCall(tmp, cur)) {
pos = tmp;
break;
}
if (isCall(cur)) {
// Don't skip too high in the tree.
break;
}
cur = parents_[tmp];
}
break;
case ParseNodeKind::PropertyDefinition:
case ParseNodeKind::Shorthand:
// Record the ParseNodeKind::PropertyDefinition/Shorthand but skip the
// ParseNodeKind::Object so we're not flagged as a contributor.
pos--;
[[fallthrough]];
default:
// Save any other nodes we encounter on the way up.
MOZ_ASSERT(*size < MaxParents);
nameable[(*size)++] = cur;
break;
}
}
return nullptr;
}
/*
* Resolve the name of a function. If the function already has a name
* listed, then it is skipped. Otherwise an intelligent name is guessed to
* assign to the function's displayAtom field.
*/
[[nodiscard]] bool resolveFun(FunctionNode* funNode,
TaggedParserAtomIndex* retId) {
MOZ_ASSERT(funNode != nullptr);
FunctionBox* funbox = funNode->funbox();
MOZ_ASSERT(buf_.empty());
auto resetBuf = mozilla::MakeScopeExit([&] { buf_.clear(); });
*retId = TaggedParserAtomIndex::null();
// If the function already has a name, use that.
if (funbox->displayAtom()) {
if (!prefix_) {
*retId = funbox->displayAtom();
return true;
}
if (!buf_.append(parserAtoms_, prefix_) || !buf_.append('/') ||
!buf_.append(parserAtoms_, funbox->displayAtom())) {
return false;
}
*retId = buf_.finishParserAtom(parserAtoms_, fc_);
return !!*retId;
}
// If a prefix is specified, then it is a form of namespace.
if (prefix_) {
if (!buf_.append(parserAtoms_, prefix_) || !buf_.append('/')) {
return false;
}
}
// Gather all nodes relevant to naming.
ParseNode* toName[MaxParents];
size_t size;
ParseNode* assignment = gatherNameable(toName, &size);
// If the function is assigned to something, then that is very relevant.
if (assignment) {
// e.g, foo = function() {}
if (assignment->is<AssignmentNode>()) {
assignment = assignment->as<AssignmentNode>().left();
}
bool foundName = false;
if (!nameExpression(assignment, &foundName)) {
return false;
}
if (!foundName) {
return true;
}
}
// Other than the actual assignment, other relevant nodes to naming are
// those in object initializers and then particular nodes marking a
// contribution.
for (int pos = size - 1; pos >= 0; pos--) {
ParseNode* node = toName[pos];
if (node->isKind(ParseNodeKind::PropertyDefinition) ||
node->isKind(ParseNodeKind::Shorthand)) {
ParseNode* left = node->as<BinaryNode>().left();
if (left->isKind(ParseNodeKind::ObjectPropertyName) ||
left->isKind(ParseNodeKind::StringExpr)) {
// Here we handle two cases:
// 1) ObjectPropertyName category, e.g `foo: function() {}`
// 2) StringExpr category, e.g `"foo": function() {}`
if (!appendPropertyReference(left->as<NameNode>().atom())) {
return false;
}
} else if (left->isKind(ParseNodeKind::NumberExpr)) {
// This case handles Number expression Anonymous Functions
// for example: `{ 10: function() {} }`.
if (!appendNumericPropertyReference(
left->as<NumericLiteral>().value())) {
return false;
}
} else if (left->isKind(ParseNodeKind::ComputedName) &&
(left->as<UnaryNode>().kid()->isKind(
ParseNodeKind::StringExpr) ||
left->as<UnaryNode>().kid()->isKind(
ParseNodeKind::NumberExpr)) &&
node->as<PropertyDefinition>().accessorType() ==
AccessorType::None) {
// In this branch we handle computed property with string
// or numeric literal:
// e.g, `{ ["foo"]: function(){} }`, and `{ [10]: function() {} }`.
//
// Note we only handle the names that are known at compile time,
// so if we have `var x = "foo"; ({ [x]: function(){} })`, we don't
// handle that here, it's handled at runtime by JSOp::SetFunName.
// The accessor type of the property must be AccessorType::None,
// given getters and setters need prefix and we cannot handle it here.
ParseNode* kid = left->as<UnaryNode>().kid();
if (kid->isKind(ParseNodeKind::StringExpr)) {
if (!appendPropertyReference(kid->as<NameNode>().atom())) {
return false;
}
} else {
MOZ_ASSERT(kid->isKind(ParseNodeKind::NumberExpr));
if (!appendNumericPropertyReference(
kid->as<NumericLiteral>().value())) {
return false;
}
}
} else {
MOZ_ASSERT(left->isKind(ParseNodeKind::ComputedName) ||
left->isKind(ParseNodeKind::BigIntExpr));
}
} else {
// Don't have consecutive '<' characters, and also don't start
// with a '<' character.
if (!buf_.empty() && buf_.getChar(buf_.length() - 1) != '<' &&
!buf_.append('<')) {
return false;
}
}
}
// functions which are "genuinely anonymous" but are contained in some
// other namespace are rather considered as "contributing" to the outer
// function, so give them a contribution symbol here.
if (!buf_.empty() && buf_.getChar(buf_.length() - 1) == '/' &&
!buf_.append('<')) {
return false;
}
if (buf_.empty()) {
return true;
}
*retId = buf_.finishParserAtom(parserAtoms_, fc_);
if (!*retId) {
return false;
}
// Skip assigning the guessed name if the function has a (dynamically)
// computed inferred name.
if (!funNode->isDirectRHSAnonFunction()) {
funbox->setGuessedAtom(*retId);
}
return true;
}
/*
* Tests whether parents_[pos] is a function call whose callee is cur.
* This is the case for functions which do things like simply create a scope
* for new variables and then return an anonymous function using this scope.
*/
bool isDirectCall(int pos, ParseNode* cur) {
return pos >= 0 && isCall(parents_[pos]) &&
parents_[pos]->as<BinaryNode>().left() == cur;
}
public:
[[nodiscard]] bool visitFunction(FunctionNode* pn) {
TaggedParserAtomIndex savedPrefix = prefix_;
TaggedParserAtomIndex newPrefix;
if (!resolveFun(pn, &newPrefix)) {
return false;
}
// If a function looks like (function(){})() where the parent node
// of the definition of the function is a call, then it shouldn't
// contribute anything to the namespace, so don't bother updating
// the prefix to whatever was returned.
if (!isDirectCall(nparents_ - 2, pn)) {
prefix_ = newPrefix;
}
bool ok = Base::visitFunction(pn);
prefix_ = savedPrefix;
return ok;
}
// Skip this type of node. It never contains functions.
[[nodiscard]] bool visitCallSiteObj(CallSiteNode* callSite) {
// This node only contains internal strings or undefined and an array -- no
// user-controlled expressions.
return true;
}
// Skip walking the list of string parts, which never contains functions.
[[nodiscard]] bool visitTaggedTemplateExpr(BinaryNode* taggedTemplate) {
ParseNode* tag = taggedTemplate->left();
// The leading expression, e.g. |tag| in |tag`foo`|,
// that might contain functions.
if (!visit(tag)) {
return false;
}
// The callsite object node is first. This node only contains
// internal strings or undefined and an array -- no user-controlled
// expressions.
CallSiteNode* element =
&taggedTemplate->right()->as<ListNode>().head()->as<CallSiteNode>();
#ifdef DEBUG
{
ListNode* rawNodes = &element->head()->as<ListNode>();
MOZ_ASSERT(rawNodes->isKind(ParseNodeKind::ArrayExpr));
for (ParseNode* raw : rawNodes->contents()) {
MOZ_ASSERT(raw->isKind(ParseNodeKind::TemplateStringExpr));
}
for (ParseNode* cooked : element->contentsFrom(rawNodes->pn_next)) {
MOZ_ASSERT(cooked->isKind(ParseNodeKind::TemplateStringExpr) ||
cooked->isKind(ParseNodeKind::RawUndefinedExpr));
}
}
#endif
// Next come any interpolated expressions in the tagged template.
ParseNode* interpolated = element->pn_next;
for (; interpolated; interpolated = interpolated->pn_next) {
if (!visit(interpolated)) {
return false;
}
}
return true;
}
private:
// Speed hack: this type of node can't contain functions, so skip walking it.
[[nodiscard]] bool internalVisitSpecList(ListNode* pn) {
// Import/export spec lists contain import/export specs containing only
// pairs of names or strings. Alternatively, an export spec list may
// contain a single export batch specifier.
#ifdef DEBUG
bool isImport = pn->isKind(ParseNodeKind::ImportSpecList);
ParseNode* item = pn->head();
if (!isImport && item && item->isKind(ParseNodeKind::ExportBatchSpecStmt)) {
MOZ_ASSERT(item->is<NullaryNode>());
} else {
for (ParseNode* item : pn->contents()) {
if (item->is<UnaryNode>()) {
auto* spec = &item->as<UnaryNode>();
MOZ_ASSERT(spec->isKind(isImport
? ParseNodeKind::ImportNamespaceSpec
: ParseNodeKind::ExportNamespaceSpec));
MOZ_ASSERT(spec->kid()->isKind(ParseNodeKind::Name) ||
spec->kid()->isKind(ParseNodeKind::StringExpr));
} else {
auto* spec = &item->as<BinaryNode>();
MOZ_ASSERT(spec->isKind(isImport ? ParseNodeKind::ImportSpec
: ParseNodeKind::ExportSpec));
MOZ_ASSERT(spec->left()->isKind(ParseNodeKind::Name) ||
spec->left()->isKind(ParseNodeKind::StringExpr));
MOZ_ASSERT(spec->right()->isKind(ParseNodeKind::Name) ||
spec->right()->isKind(ParseNodeKind::StringExpr));
}
}
}
#endif
return true;
}
public:
[[nodiscard]] bool visitImportSpecList(ListNode* pn) {
return internalVisitSpecList(pn);
}
[[nodiscard]] bool visitExportSpecList(ListNode* pn) {
return internalVisitSpecList(pn);
}
NameResolver(FrontendContext* fc, ParserAtomsTable& parserAtoms)
: ParseNodeVisitor(fc),
fc_(fc),
parserAtoms_(parserAtoms),
nparents_(0),
buf_(fc) {}
/*
* Resolve names for all anonymous functions in the given ParseNode tree.
*/
[[nodiscard]] bool visit(ParseNode* pn) {
// Push pn to the parse node stack.
if (nparents_ >= MaxParents) {
// Silently skip very deeply nested functions.
return true;
}
auto initialParents = nparents_;
parents_[initialParents] = pn;
nparents_++;
bool ok = Base::visit(pn);
// Pop pn from the parse node stack.
nparents_--;
MOZ_ASSERT(initialParents == nparents_, "nparents imbalance detected");
MOZ_ASSERT(parents_[initialParents] == pn,
"pushed child shouldn't change underneath us");
AlwaysPoison(&parents_[initialParents], JS_OOB_PARSE_NODE_PATTERN,
sizeof(parents_[initialParents]), MemCheckKind::MakeUndefined);
return ok;
}
};
} /* anonymous namespace */
bool frontend::NameFunctions(FrontendContext* fc, ParserAtomsTable& parserAtoms,
ParseNode* pn) {
NameResolver nr(fc, parserAtoms);
return nr.visit(pn);
}