com.google.javascript.jscomp.disambiguate.FindPropertyReferences Maven / Gradle / Ivy
Show all versions of closure-compiler Show documentation
/*
* Copyright 2008 The Closure Compiler Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.javascript.jscomp.disambiguate;
import static com.google.common.base.Preconditions.checkState;
import com.google.javascript.jscomp.JSError;
import com.google.javascript.jscomp.NodeTraversal;
import com.google.javascript.jscomp.NodeTraversal.AbstractPostOrderCallback;
import com.google.javascript.jscomp.NodeUtil;
import com.google.javascript.jscomp.PropertyRenamingDiagnostics;
import com.google.javascript.rhino.Node;
import com.google.javascript.rhino.jstype.JSType;
import java.util.LinkedHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
/**
* Traverses the AST, collecting connections between {@link JSType}s, property access, and their
* accociated {@link Node}s.
*
* This callback is intended for both source and externs.
*/
final class FindPropertyReferences extends AbstractPostOrderCallback {
/**
* Tests whether the named JS function is a "property definer", similar to
* `Object.defineProperty`.
*
*
Such a function is assumed to accept two or three arguments:
*
*
* - A string literal that is the name being defined.
*
- An object on which to define the property.
*
- An property descriptor. (optional)
*
*
* This allows the compiler to recognize calls to such functions as property definitions, even
* though they may be custom-defined in user code and the property name is quoted.
*/
@FunctionalInterface
interface IsPropertyDefiner {
boolean test(String name);
}
private LinkedHashMap propIndex = new LinkedHashMap<>();
private final TypeFlattener flattener;
private final Consumer errorCb;
private final IsPropertyDefiner isPropertyDefiner;
FindPropertyReferences(
TypeFlattener flattener, Consumer errorCb, IsPropertyDefiner isPropertyDefiner) {
this.flattener = flattener;
this.errorCb = errorCb;
this.isPropertyDefiner = isPropertyDefiner;
}
LinkedHashMap getPropertyIndex() {
LinkedHashMap tmp = this.propIndex;
this.propIndex = null;
return tmp;
}
@Override
public void visit(NodeTraversal t, Node n, Node parent) {
switch (n.getToken()) {
case GETPROP:
this.registerPropertyUse(n.getLastChild(), n.getFirstChild().getJSType());
break;
case OBJECTLIT:
this.handleObjectLit(n);
break;
case CALL:
this.handleCall(n);
break;
case CLASS:
this.handleClass(n);
break;
case OBJECT_PATTERN:
this.handleObjectPattern(n);
break;
default:
break;
}
}
private void handleObjectLit(Node n) {
// Object.defineProperties literals are handled at the CALL node.
if (n.getParent().isCall() && NodeUtil.isObjectDefinePropertiesDefinition(n.getParent())) {
return;
}
JSType owner = n.getJSType();
this.traverseObjectlitLike(n, (m) -> owner);
}
/** Examines calls in case they are Object.defineProperties calls */
private void handleCall(Node call) {
Node target = call.getFirstChild();
if (!target.isQualifiedName()) {
return;
}
String functionName = target.getOriginalQualifiedName();
if (functionName != null && this.isPropertyDefiner.test(functionName)) {
this.handlePropertyDefiningFunctionCall(call, functionName);
} else if (NodeUtil.isObjectDefinePropertiesDefinition(call)) {
this.handleObjectDefineProperties(call);
}
}
private void handleClass(Node classNode) {
JSType classType = classNode.getJSType();
JSType classPrototypeType =
// the class type may not be a function type if it was in a cast, so treat it as unknown
classType.isFunctionType() ? classType.toMaybeFunctionType().getPrototypeProperty() : null;
this.traverseObjectlitLike(
NodeUtil.getClassMembers(classNode),
(m) -> m.isStaticMember() ? classType : classPrototypeType);
}
private void handleObjectPattern(Node pattern) {
JSType owner = pattern.getJSType();
this.traverseObjectlitLike(pattern, (m) -> owner);
}
private void handlePropertyDefiningFunctionCall(Node call, String renameFunctionName) {
int childCount = call.getChildCount();
int argCount = childCount - 1;
if (argCount != 1 && argCount != 2) {
this.errorCb.accept(
JSError.make(
call,
PropertyRenamingDiagnostics.INVALID_RENAME_FUNCTION,
renameFunctionName,
" Must be called with 1 or 2 arguments"));
return;
}
if (!call.getSecondChild().isString()) {
this.errorCb.accept(
JSError.make(
call,
PropertyRenamingDiagnostics.INVALID_RENAME_FUNCTION,
renameFunctionName,
" The first argument must be a string literal."));
return;
}
String propName = call.getSecondChild().getString();
if (propName.contains(".")) {
this.errorCb.accept(
JSError.make(
call,
PropertyRenamingDiagnostics.INVALID_RENAME_FUNCTION,
renameFunctionName,
" The first argument must not be a property path."));
return;
}
Node obj = call.getChildAtIndex(2);
this.registerPropertyUse(call.getSecondChild(), obj.getJSType());
}
private void handleObjectDefineProperties(Node call) {
Node typeObj = call.getSecondChild();
Node objectLiteral = typeObj.getNext();
if (!objectLiteral.isObjectLit()) {
return;
}
JSType type = typeObj.getJSType();
this.traverseObjectlitLike(objectLiteral, (m) -> type);
}
private void traverseObjectlitLike(Node n, Function memberOwnerFn) {
// The keys in an object pattern are r-values, not l-values, but they are still accesses.
checkState(n.isObjectLit() || n.isObjectPattern() || n.isClassMembers());
for (Node child = n.getFirstChild(); child != null; child = child.getNext()) {
switch (child.getToken()) {
case COMPUTED_PROP:
case OBJECT_REST:
case OBJECT_SPREAD:
continue;
case STRING_KEY:
case MEMBER_FUNCTION_DEF:
case GETTER_DEF:
case SETTER_DEF:
if (child.isQuotedString()) {
continue; // These won't be renamed due to our assumptions. Ignore them.
}
this.registerPropertyUse(child, memberOwnerFn.apply(child));
break;
default:
throw new IllegalStateException(
"Unexpected child of " + n.getToken() + ": " + child.toStringTree());
}
}
}
/**
* Update all datastructures as necessary to consider property use {@code site} from type {@code
* owner}.
*/
private void registerPropertyUse(Node site, JSType owner) {
PropertyClustering prop =
this.propIndex.computeIfAbsent(site.getString(), PropertyClustering::new);
FlatType flatOwner = this.flattener.flatten(owner);
// Set the initial condition for flowing this property along the graph.
flatOwner.getAssociatedProps().add(prop);
// Make sure there's a cluster for this name/type combination.
prop.getClusters().add(flatOwner);
// Record the site to rename once clusters are found. If it's an extern, we won't rename anyway.
prop.getUseSites().put(site, flatOwner);
// Track the externs cluster accordingly.
if (site.isFromExterns()) {
prop.registerExternType(flatOwner);
}
}
}