/** Checks that object literal keys or class method names are valid. */
private static void checkObjectLiteralOrClass(NodeTraversal t, Node n) {
Set<String> getters = new HashSet<>();
Set<String> setters = new HashSet<>();
for (Node key = n.getFirstChild(); key != null; key = key.getNext()) {
if (!key.isSetterDef()) {
// normal property and getter cases
if (!getters.add(key.getString())) {
if (n.isClassMembers()) {
t.report(key, DUPLICATE_CLASS_METHODS);
} else {
t.report(key, DUPLICATE_OBJECT_KEY);
}
}
}
if (!key.isGetterDef()) {
// normal property and setter cases
if (!setters.add(key.getString())) {
if (n.isClassMembers()) {
t.report(key, DUPLICATE_CLASS_METHODS);
} else {
t.report(key, DUPLICATE_OBJECT_KEY);
}
}
}
}
}
private void addToDefinePropertiesObject(ClassDeclarationMetadata metadata, Node member) {
Node obj =
member.isStaticMember()
? metadata.definePropertiesObjForClass
: metadata.definePropertiesObjForPrototype;
Node prop = NodeUtil.getFirstPropMatchingKey(obj, member.getString());
if (prop == null) {
prop =
IR.objectlit(
IR.stringKey("configurable", IR.trueNode()),
IR.stringKey("enumerable", IR.trueNode()));
obj.addChildToBack(IR.stringKey(member.getString(), prop));
}
Node function = member.getLastChild();
JSDocInfoBuilder info = JSDocInfoBuilder.maybeCopyFrom(NodeUtil.getBestJSDocInfo(function));
info.recordThisType(
new JSTypeExpression(
new Node(Token.BANG, IR.string(metadata.fullClassName)), member.getSourceFileName()));
Node stringKey =
IR.stringKey(member.isGetterDef() ? "get" : "set", function.detachFromParent());
stringKey.setJSDocInfo(info.build());
prop.addChildToBack(stringKey);
prop.useSourceInfoIfMissingFromForTree(member);
}
@Override
public void visit(NodeTraversal t, Node n, Node parent) {
switch (n.getType()) {
case Token.OBJECTLIT:
for (Node child : n.children()) {
if (child.isComputedProp()) {
visitObjectWithComputedProperty(n, parent);
break;
}
}
break;
case Token.MEMBER_DEF:
if (parent.isObjectLit()) {
visitMemberDefInObjectLit(n, parent);
}
break;
case Token.FOR_OF:
visitForOf(n, parent);
break;
case Token.SUPER:
visitSuper(n, parent);
break;
case Token.STRING_KEY:
visitStringKey(n);
break;
case Token.CLASS:
for (Node member = n.getLastChild().getFirstChild();
member != null;
member = member.getNext()) {
if (member.isGetterDef()
|| member.isSetterDef()
|| member.getBooleanProp(Node.COMPUTED_PROP_GETTER)
|| member.getBooleanProp(Node.COMPUTED_PROP_SETTER)) {
cannotConvert(member, "getters or setters in class definitions");
return;
}
}
visitClass(n, parent);
break;
case Token.ARRAYLIT:
case Token.NEW:
case Token.CALL:
for (Node child : n.children()) {
if (child.isSpread()) {
visitArrayLitOrCallWithSpread(n, parent);
break;
}
}
break;
case Token.TEMPLATELIT:
Es6TemplateLiterals.visitTemplateLiteral(t, n);
break;
case Token.ARRAY_PATTERN:
visitArrayPattern(t, n, parent);
break;
case Token.OBJECT_PATTERN:
visitObjectPattern(t, n, parent);
break;
}
}
private void visitObjectWithComputedProperty(Node obj, Node parent) {
Preconditions.checkArgument(obj.isObjectLit());
List<Node> props = new ArrayList<>();
Node currElement = obj.getFirstChild();
while (currElement != null) {
if (currElement.getBooleanProp(Node.COMPUTED_PROP_GETTER)
|| currElement.getBooleanProp(Node.COMPUTED_PROP_SETTER)) {
cannotConvertYet(currElement, "computed getter/setter");
return;
} else if (currElement.isGetterDef() || currElement.isSetterDef()) {
currElement = currElement.getNext();
} else {
Node nextNode = currElement.getNext();
obj.removeChild(currElement);
props.add(currElement);
currElement = nextNode;
}
}
String objName = FRESH_COMP_PROP_VAR + compiler.getUniqueNameIdSupplier().get();
props = Lists.reverse(props);
Node result = IR.name(objName);
for (Node propdef : props) {
if (propdef.isComputedProp()) {
Node propertyExpression = propdef.removeFirstChild();
Node value = propdef.removeFirstChild();
result =
IR.comma(IR.assign(IR.getelem(IR.name(objName), propertyExpression), value), result);
} else {
if (!propdef.hasChildren()) {
Node name = IR.name(propdef.getString()).useSourceInfoIfMissingFrom(propdef);
propdef.addChildToBack(name);
}
Node val = propdef.removeFirstChild();
propdef.setType(Token.STRING);
int type = propdef.isQuotedString() ? Token.GETELEM : Token.GETPROP;
Node access = new Node(type, IR.name(objName), propdef);
result = IR.comma(IR.assign(access, val), result);
}
}
Node statement = obj;
while (!NodeUtil.isStatement(statement)) {
statement = statement.getParent();
}
result.useSourceInfoIfMissingFromForTree(obj);
parent.replaceChild(obj, result);
Node var = IR.var(IR.name(objName), obj);
var.useSourceInfoIfMissingFromForTree(statement);
statement.getParent().addChildBefore(var, statement);
compiler.reportCodeChange();
}
/** @param node A getter or setter node. */
private JSTypeExpression getTypeFromGetterOrSetter(Node node) {
JSDocInfo info = node.getJSDocInfo();
if (info != null) {
if (node.isGetterDef() && info.getReturnType() != null) {
return info.getReturnType();
} else {
Set<String> paramNames = info.getParameterNames();
if (paramNames.size() == 1) {
return info.getParameterType(Iterables.getOnlyElement(info.getParameterNames()));
}
}
}
return new JSTypeExpression(new Node(Token.QMARK), node.getSourceFileName());
}
/**
* @return A list of MemberDefinitions in a behavior which are not in the properties block, but
* should still be copied to the element prototype.
*/
private List<MemberDefinition> getNonPropertyMembersToCopy(Node behaviorObjLit) {
Preconditions.checkState(behaviorObjLit.isObjectLit());
ImmutableList.Builder<MemberDefinition> membersToCopy = ImmutableList.builder();
for (Node keyNode : behaviorObjLit.children()) {
if (keyNode.isGetterDef()
|| (keyNode.isStringKey()
&& !keyNode.getFirstChild().isFunction()
&& !behaviorNamesNotToCopy.contains(keyNode.getString()))) {
membersToCopy.add(
new MemberDefinition(
NodeUtil.getBestJSDocInfo(keyNode), keyNode, keyNode.getFirstChild()));
}
}
return membersToCopy.build();
}
private Node tryFoldObjectPropAccess(Node n, Node left, Node right) {
Preconditions.checkArgument(NodeUtil.isGet(n));
if (!left.isObjectLit() || !right.isString()) {
return n;
}
if (NodeUtil.isAssignmentTarget(n)) {
// If GETPROP/GETELEM is used as assignment target the object literal is
// acting as a temporary we can't fold it here:
// "{a:x}.a += 1" is not "x += 1"
return n;
}
// find the last definition in the object literal
Node key = null;
Node value = null;
for (Node c = left.getFirstChild(); c != null; c = c.getNext()) {
if (c.getString().equals(right.getString())) {
switch (c.getType()) {
case SETTER_DEF:
continue;
case GETTER_DEF:
case STRING_KEY:
if (value != null && mayHaveSideEffects(value)) {
// The previously found value had side-effects
return n;
}
key = c;
value = key.getFirstChild();
break;
default:
throw new IllegalStateException();
}
} else if (mayHaveSideEffects(c.getFirstChild())) {
// We don't handle the side-effects here as they might need a temporary
// or need to be reordered.
return n;
}
}
// Didn't find a definition of the name in the object literal, it might
// be coming from the Object prototype
if (value == null) {
return n;
}
if (value.isFunction() && NodeUtil.referencesThis(value)) {
// 'this' may refer to the object we are trying to remove
return n;
}
Node replacement = value.detachFromParent();
if (key.isGetterDef()) {
replacement = IR.call(replacement);
replacement.putBooleanProp(Node.FREE_CALL, true);
}
n.getParent().replaceChild(n, replacement);
reportCodeChange();
return n;
}
/**
* Declares global variables to serve as aliases for the values in an object literal, optionally
* removing all of the object literal's keys and values.
*
* @param alias The object literal's flattened name (e.g. "a$b$c")
* @param objlit The OBJLIT node
* @param varNode The VAR node to which new global variables should be added as children
* @param nameToAddAfter The child of {@code varNode} after which new variables should be added
* (may be null)
* @param varParent {@code varNode}'s parent
* @return The number of variables added
*/
private int declareVarsForObjLitValues(
Name objlitName,
String alias,
Node objlit,
Node varNode,
Node nameToAddAfter,
Node varParent) {
int numVars = 0;
int arbitraryNameCounter = 0;
boolean discardKeys = !objlitName.shouldKeepKeys();
for (Node key = objlit.getFirstChild(), nextKey; key != null; key = nextKey) {
Node value = key.getFirstChild();
nextKey = key.getNext();
// A get or a set can not be rewritten as a VAR.
if (key.isGetterDef() || key.isSetterDef()) {
continue;
}
// We generate arbitrary names for keys that aren't valid JavaScript
// identifiers, since those keys are never referenced. (If they were,
// this object literal's child names wouldn't be collapsible.) The only
// reason that we don't eliminate them entirely is the off chance that
// their values are expressions that have side effects.
boolean isJsIdentifier = !key.isNumber() && TokenStream.isJSIdentifier(key.getString());
String propName = isJsIdentifier ? key.getString() : String.valueOf(++arbitraryNameCounter);
// If the name cannot be collapsed, skip it.
String qName = objlitName.getFullName() + '.' + propName;
Name p = nameMap.get(qName);
if (p != null && !p.canCollapse()) {
continue;
}
String propAlias = appendPropForAlias(alias, propName);
Node refNode = null;
if (discardKeys) {
objlit.removeChild(key);
value.detachFromParent();
} else {
// Substitute a reference for the value.
refNode = IR.name(propAlias);
if (key.getBooleanProp(Node.IS_CONSTANT_NAME)) {
refNode.putBooleanProp(Node.IS_CONSTANT_NAME, true);
}
key.replaceChild(value, refNode);
}
// Declare the collapsed name as a variable with the original value.
Node nameNode = IR.name(propAlias);
nameNode.addChildToFront(value);
if (key.getBooleanProp(Node.IS_CONSTANT_NAME)) {
nameNode.putBooleanProp(Node.IS_CONSTANT_NAME, true);
}
Node newVar = IR.var(nameNode).useSourceInfoIfMissingFromForTree(key);
if (nameToAddAfter != null) {
varParent.addChildAfter(newVar, nameToAddAfter);
} else {
varParent.addChildBefore(newVar, varNode);
}
compiler.reportCodeChange();
nameToAddAfter = newVar;
// Update the global name's node ancestry if it hasn't already been
// done. (Duplicate keys in an object literal can bring us here twice
// for the same global name.)
if (isJsIdentifier && p != null) {
if (!discardKeys) {
Ref newAlias = p.getDeclaration().cloneAndReclassify(Ref.Type.ALIASING_GET);
newAlias.node = refNode;
p.addRef(newAlias);
}
p.getDeclaration().node = nameNode;
if (value.isFunction()) {
checkForHosedThisReferences(value, key.getJSDocInfo(), p);
}
}
numVars++;
}
return numVars;
}
/**
* Classes are processed in 3 phases:
*
* <ol>
* <li>The class name is extracted.
* <li>Class members are processed and rewritten.
* <li>The constructor is built.
* </ol>
*/
private void visitClass(Node classNode, Node parent) {
checkClassReassignment(classNode);
// Collect Metadata
ClassDeclarationMetadata metadata = ClassDeclarationMetadata.create(classNode, parent);
if (metadata == null || metadata.fullClassName == null) {
cannotConvert(
parent,
"Can only convert classes that are declarations or the right hand"
+ " side of a simple assignment.");
return;
}
if (metadata.hasSuperClass() && !metadata.superClassNameNode.isQualifiedName()) {
compiler.report(JSError.make(metadata.superClassNameNode, DYNAMIC_EXTENDS_TYPE));
return;
}
boolean useUnique = NodeUtil.isStatement(classNode) && !NodeUtil.isInFunction(classNode);
String uniqueFullClassName =
useUnique ? getUniqueClassName(metadata.fullClassName) : metadata.fullClassName;
Node classNameAccess = NodeUtil.newQName(compiler, uniqueFullClassName);
Node prototypeAccess = NodeUtil.newPropertyAccess(compiler, classNameAccess, "prototype");
Preconditions.checkState(
NodeUtil.isStatement(metadata.insertionPoint),
"insertion point must be a statement: %s",
metadata.insertionPoint);
Node constructor = null;
JSDocInfo ctorJSDocInfo = null;
// Process all members of the class
Node classMembers = classNode.getLastChild();
Map<String, JSDocInfo> prototypeMembersToDeclare = new LinkedHashMap<>();
Map<String, JSDocInfo> classMembersToDeclare = new LinkedHashMap<>();
for (Node member : classMembers.children()) {
if (member.isEmpty()) {
continue;
}
Preconditions.checkState(
member.isMemberFunctionDef()
|| member.isGetterDef()
|| member.isSetterDef()
|| (member.isComputedProp() && !member.getBooleanProp(Node.COMPUTED_PROP_VARIABLE)),
"Member variables should have been transpiled earlier: ",
member);
if (member.isGetterDef() || member.isSetterDef()) {
JSTypeExpression typeExpr = getTypeFromGetterOrSetter(member).clone();
addToDefinePropertiesObject(metadata, member);
Map<String, JSDocInfo> membersToDeclare =
member.isStaticMember() ? classMembersToDeclare : prototypeMembersToDeclare;
JSDocInfo existingJSDoc = membersToDeclare.get(member.getString());
JSTypeExpression existingType = existingJSDoc == null ? null : existingJSDoc.getType();
if (existingType != null && !existingType.equals(typeExpr)) {
compiler.report(JSError.make(member, CONFLICTING_GETTER_SETTER_TYPE, member.getString()));
} else {
JSDocInfoBuilder jsDoc = new JSDocInfoBuilder(false);
jsDoc.recordType(typeExpr);
if (member.getJSDocInfo() != null && member.getJSDocInfo().isExport()) {
jsDoc.recordExport();
}
if (member.isStaticMember()) {
jsDoc.recordNoCollapse();
}
membersToDeclare.put(member.getString(), jsDoc.build());
}
} else if (member.isMemberFunctionDef() && member.getString().equals("constructor")) {
ctorJSDocInfo = member.getJSDocInfo();
constructor = member.getFirstChild().detachFromParent();
if (!metadata.anonymous) {
// Turns class Foo { constructor: function() {} } into function Foo() {},
// i.e. attaches the name the ctor function.
constructor.replaceChild(constructor.getFirstChild(), metadata.classNameNode.cloneNode());
}
} else {
Node qualifiedMemberAccess =
getQualifiedMemberAccess(compiler, member, classNameAccess, prototypeAccess);
Node method = member.getLastChild().detachFromParent();
Node assign = IR.assign(qualifiedMemberAccess, method);
assign.useSourceInfoIfMissingFromForTree(member);
JSDocInfo info = member.getJSDocInfo();
if (member.isStaticMember() && NodeUtil.referencesThis(assign.getLastChild())) {
JSDocInfoBuilder memberDoc = JSDocInfoBuilder.maybeCopyFrom(info);
memberDoc.recordThisType(
new JSTypeExpression(
new Node(Token.BANG, new Node(Token.QMARK)), member.getSourceFileName()));
info = memberDoc.build();
}
if (info != null) {
assign.setJSDocInfo(info);
}
Node newNode = NodeUtil.newExpr(assign);
metadata.insertNodeAndAdvance(newNode);
}
}
// Add declarations for properties that were defined with a getter and/or setter,
// so that the typechecker knows those properties exist on the class.
// This is a temporary solution. Eventually, the type checker should understand
// Object.defineProperties calls directly.
for (Map.Entry<String, JSDocInfo> entry : prototypeMembersToDeclare.entrySet()) {
String declaredMember = entry.getKey();
Node declaration = IR.getprop(prototypeAccess.cloneTree(), IR.string(declaredMember));
declaration.setJSDocInfo(entry.getValue());
metadata.insertNodeAndAdvance(
IR.exprResult(declaration).useSourceInfoIfMissingFromForTree(classNode));
}
for (Map.Entry<String, JSDocInfo> entry : classMembersToDeclare.entrySet()) {
String declaredMember = entry.getKey();
Node declaration = IR.getprop(classNameAccess.cloneTree(), IR.string(declaredMember));
declaration.setJSDocInfo(entry.getValue());
metadata.insertNodeAndAdvance(
IR.exprResult(declaration).useSourceInfoIfMissingFromForTree(classNode));
}
if (metadata.definePropertiesObjForPrototype.hasChildren()) {
Node definePropsCall =
IR.exprResult(
IR.call(
NodeUtil.newQName(compiler, "Object.defineProperties"),
prototypeAccess.cloneTree(),
metadata.definePropertiesObjForPrototype));
definePropsCall.useSourceInfoIfMissingFromForTree(classNode);
metadata.insertNodeAndAdvance(definePropsCall);
}
if (metadata.definePropertiesObjForClass.hasChildren()) {
Node definePropsCall =
IR.exprResult(
IR.call(
NodeUtil.newQName(compiler, "Object.defineProperties"),
classNameAccess.cloneTree(),
metadata.definePropertiesObjForClass));
definePropsCall.useSourceInfoIfMissingFromForTree(classNode);
metadata.insertNodeAndAdvance(definePropsCall);
}
Preconditions.checkNotNull(constructor);
JSDocInfo classJSDoc = NodeUtil.getBestJSDocInfo(classNode);
JSDocInfoBuilder newInfo = JSDocInfoBuilder.maybeCopyFrom(classJSDoc);
newInfo.recordConstructor();
if (metadata.hasSuperClass()) {
String superClassString = metadata.superClassNameNode.getQualifiedName();
if (newInfo.isInterfaceRecorded()) {
newInfo.recordExtendedInterface(
new JSTypeExpression(
new Node(Token.BANG, IR.string(superClassString)),
metadata.superClassNameNode.getSourceFileName()));
} else {
Node inherits =
IR.call(
NodeUtil.newQName(compiler, INHERITS),
NodeUtil.newQName(compiler, metadata.fullClassName),
NodeUtil.newQName(compiler, superClassString));
Node inheritsCall = IR.exprResult(inherits);
compiler.needsEs6Runtime = true;
inheritsCall.useSourceInfoIfMissingFromForTree(classNode);
Node enclosingStatement = NodeUtil.getEnclosingStatement(classNode);
enclosingStatement.getParent().addChildAfter(inheritsCall, enclosingStatement);
newInfo.recordBaseType(
new JSTypeExpression(
new Node(Token.BANG, IR.string(superClassString)),
metadata.superClassNameNode.getSourceFileName()));
}
}
// Classes are @struct by default.
if (!newInfo.isUnrestrictedRecorded()
&& !newInfo.isDictRecorded()
&& !newInfo.isStructRecorded()) {
newInfo.recordStruct();
}
if (ctorJSDocInfo != null) {
newInfo.recordSuppressions(ctorJSDocInfo.getSuppressions());
for (String param : ctorJSDocInfo.getParameterNames()) {
newInfo.recordParameter(param, ctorJSDocInfo.getParameterType(param));
}
newInfo.mergePropertyBitfieldFrom(ctorJSDocInfo);
}
if (NodeUtil.isStatement(classNode)) {
constructor.getFirstChild().setString("");
Node ctorVar = IR.let(metadata.classNameNode.cloneNode(), constructor);
ctorVar.useSourceInfoIfMissingFromForTree(classNode);
parent.replaceChild(classNode, ctorVar);
} else {
parent.replaceChild(classNode, constructor);
}
if (NodeUtil.isStatement(constructor)) {
constructor.setJSDocInfo(newInfo.build());
} else if (parent.isName()) {
// The constructor function is the RHS of a var statement.
// Add the JSDoc to the VAR node.
Node var = parent.getParent();
var.setJSDocInfo(newInfo.build());
} else if (constructor.getParent().isName()) {
// Is a newly created VAR node.
Node var = constructor.getParent().getParent();
var.setJSDocInfo(newInfo.build());
} else if (parent.isAssign()) {
// The constructor function is the RHS of an assignment.
// Add the JSDoc to the ASSIGN node.
parent.setJSDocInfo(newInfo.build());
} else {
throw new IllegalStateException("Unexpected parent node " + parent);
}
compiler.reportCodeChange();
}
private DeclaredFunctionType getFunTypeFromTypicalFunctionJsdoc(
JSDocInfo jsdoc,
String functionName,
Node funNode,
RawNominalType constructorType,
RawNominalType ownerType,
DeclaredTypeRegistry registry,
FunctionTypeBuilder builder) {
ImmutableList.Builder<String> typeParamsBuilder = ImmutableList.builder();
ImmutableList<String> typeParameters = ImmutableList.of();
Node parent = funNode.getParent();
// TODO(dimvar): need more @template warnings
// - warn for multiple @template annotations
// - warn for @template annotation w/out usage
boolean ignoreJsdoc = false;
if (jsdoc != null) {
if (constructorType != null) {
// We have created new names for these type variables in GTI, don't
// create new ones here.
typeParamsBuilder.addAll(constructorType.getTypeParameters());
} else {
for (String typeParam : jsdoc.getTemplateTypeNames()) {
typeParamsBuilder.add(this.nameGen.getNextName(typeParam));
}
}
// We don't properly support the type transformation language; we treat
// its type variables as ordinary type variables.
for (String typeParam : jsdoc.getTypeTransformations().keySet()) {
typeParamsBuilder.add(this.nameGen.getNextName(typeParam));
}
typeParameters = typeParamsBuilder.build();
if (!typeParameters.isEmpty()) {
if (parent.isSetterDef() || parent.isGetterDef()) {
ignoreJsdoc = true;
jsdoc = null;
warnings.add(JSError.make(funNode, TEMPLATED_GETTER_SETTER));
} else {
builder.addTypeParameters(typeParameters);
}
}
}
if (ownerType != null) {
typeParamsBuilder.addAll(ownerType.getTypeParameters());
typeParameters = typeParamsBuilder.build();
}
fillInFormalParameterTypes(jsdoc, funNode, typeParameters, registry, builder, ignoreJsdoc);
fillInReturnType(jsdoc, funNode, parent, typeParameters, registry, builder, ignoreJsdoc);
if (jsdoc == null) {
return builder.buildDeclaration();
}
// Look at other annotations, eg, @constructor
NominalType parentClass =
getMaybeParentClass(jsdoc, functionName, funNode, typeParameters, registry);
ImmutableSet<NominalType> implementedIntfs =
getImplementedInterfaces(jsdoc, registry, typeParameters);
if (constructorType == null && jsdoc.isConstructorOrInterface()) {
// Anonymous type, don't register it.
return builder.buildDeclaration();
} else if (jsdoc.isConstructor()) {
handleConstructorAnnotation(
functionName, funNode, constructorType, parentClass, implementedIntfs, registry, builder);
} else if (jsdoc.isInterface()) {
handleInterfaceAnnotation(
jsdoc,
functionName,
funNode,
constructorType,
implementedIntfs,
typeParameters,
registry,
builder);
} else if (!implementedIntfs.isEmpty()) {
warnings.add(JSError.make(funNode, IMPLEMENTS_WITHOUT_CONSTRUCTOR, functionName));
}
if (jsdoc.hasThisType()) {
Node thisRoot = jsdoc.getThisType().getRoot();
Preconditions.checkState(thisRoot.getType() == Token.BANG);
builder.addReceiverType(getThisOrNewType(thisRoot.getFirstChild(), registry, typeParameters));
}
return builder.buildDeclaration();
}
