/**
* 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 void visitScriptNode(NodeTraversal t) {
if (mode == Mode.SINGLE_FILE && requires.isEmpty()) {
// Likely a file that isn't using Closure at all.
return;
}
Set<String> namespaces = new HashSet<>();
// For every usage, check that there is a goog.require, and warn if not.
for (Map.Entry<String, Node> entry : usages.entrySet()) {
String namespace = entry.getKey();
if (namespace.endsWith(".call") || namespace.endsWith(".apply")) {
namespace = namespace.substring(0, namespace.lastIndexOf('.'));
}
if (namespace.startsWith("goog.global.")) {
continue;
}
Node node = entry.getValue();
JSDocInfo info = NodeUtil.getBestJSDocInfo(NodeUtil.getEnclosingStatement(node));
if (info != null && info.getSuppressions().contains("missingRequire")) {
continue;
}
String outermostClassName = getOutermostClassName(namespace);
// The parent namespace is also checked as part of the requires so that classes
// used by goog.module are still checked properly. This may cause missing requires
// to be missed but in practice that should happen rarely.
String nonNullClassName = outermostClassName != null ? outermostClassName : namespace;
String parentNamespace = null;
int separatorIndex = nonNullClassName.lastIndexOf('.');
if (separatorIndex > 0) {
parentNamespace = nonNullClassName.substring(0, separatorIndex);
}
boolean notProvidedByConstructors =
!providedNames.contains(namespace)
&& !providedNames.contains(outermostClassName)
&& !providedNames.contains(parentNamespace);
boolean notProvidedByRequires =
!requires.containsKey(namespace)
&& !requires.containsKey(outermostClassName)
&& !requires.containsKey(parentNamespace);
if (notProvidedByConstructors
&& notProvidedByRequires
&& !namespaces.contains(namespace)
&& !"goog".equals(parentNamespace)) {
// TODO(mknichel): If the symbol is not explicitly provided, find the next best
// symbol from the provides in the same file.
String rootName = Splitter.on('.').split(namespace).iterator().next();
if (mode != Mode.SINGLE_FILE || closurizedNamespaces.contains(rootName)) {
if (node.isCall()) {
compiler.report(t.makeError(node, MISSING_REQUIRE_CALL_WARNING, namespace));
} else {
compiler.report(t.makeError(node, MISSING_REQUIRE_WARNING, namespace));
}
namespaces.add(namespace);
}
}
}
// For every goog.require, check that there is a usage (in either usages or weakUsages)
// and warn if there is not.
for (Map.Entry<String, Node> entry : requires.entrySet()) {
String require = entry.getKey();
Node call = entry.getValue();
Node parent = call.getParent();
if (parent.isAssign()) {
// var baz = goog.require('foo.bar.baz');
// Assume that the var 'baz' is used somewhere, and don't warn.
continue;
}
if (!usages.containsKey(require) && !weakUsages.containsKey(require)) {
reportExtraRequireWarning(call, require);
}
}
}
/**
* Classes are processed in 3 phases: 1) The class name is extracted. 2) Class members are
* processed and rewritten. 3) The constructor is built.
*/
private void visitClass(Node classNode, Node parent) {
checkClassReassignment(classNode);
// Collect Metadata
Node className = classNode.getFirstChild();
Node superClassName = className.getNext();
Node classMembers = classNode.getLastChild();
// This is a statement node. We insert methods of the
// transpiled class after this node.
Node insertionPoint;
if (!superClassName.isEmpty() && !superClassName.isQualifiedName()) {
compiler.report(JSError.make(superClassName, DYNAMIC_EXTENDS_TYPE));
return;
}
// The fully qualified name of the class, which will be used in the output.
// May come from the class itself or the LHS of an assignment.
String fullClassName = null;
// Whether the constructor function in the output should be anonymous.
boolean anonymous;
// If this is a class statement, or a class expression in a simple
// assignment or var statement, convert it. In any other case, the
// code is too dynamic, so just call cannotConvert.
if (NodeUtil.isStatement(classNode)) {
fullClassName = className.getString();
anonymous = false;
insertionPoint = classNode;
} else if (parent.isAssign() && parent.getParent().isExprResult()) {
// Add members after the EXPR_RESULT node:
// example.C = class {}; example.C.prototype.foo = function() {};
fullClassName = parent.getFirstChild().getQualifiedName();
if (fullClassName == null) {
cannotConvert(
parent,
"Can only convert classes that are declarations or the right hand"
+ " side of a simple assignment.");
return;
}
anonymous = true;
insertionPoint = parent.getParent();
} else if (parent.isName()) {
// Add members after the 'var' statement.
// var C = class {}; C.prototype.foo = function() {};
fullClassName = parent.getString();
anonymous = true;
insertionPoint = parent.getParent();
} else {
cannotConvert(
parent,
"Can only convert classes that are declarations or the right hand"
+ " side of a simple assignment.");
return;
}
if (!className.isEmpty() && !className.getString().equals(fullClassName)) {
// cannot bind two class names in the case of: var Foo = class Bar {};
cannotConvertYet(classNode, "named class in an assignment");
return;
}
boolean useUnique = NodeUtil.isStatement(classNode) && !isInFunction(classNode);
String uniqueFullClassName = useUnique ? getUniqueClassName(fullClassName) : fullClassName;
String superClassString = superClassName.getQualifiedName();
Verify.verify(NodeUtil.isStatement(insertionPoint));
Node constructor = null;
JSDocInfo ctorJSDocInfo = null;
// Process all members of the class
for (Node member : classMembers.children()) {
if (member.isEmpty()) {
continue;
}
if (member.isMemberDef() && member.getString().equals("constructor")) {
ctorJSDocInfo = member.getJSDocInfo();
constructor = member.getFirstChild().detachFromParent();
if (!anonymous) {
constructor.replaceChild(constructor.getFirstChild(), className.cloneNode());
}
} else {
Node qualifiedMemberName;
Node method;
if (member.isMemberDef()) {
if (member.isStaticMember()) {
qualifiedMemberName =
NodeUtil.newQualifiedNameNode(
compiler.getCodingConvention(),
Joiner.on(".").join(uniqueFullClassName, member.getString()));
} else {
qualifiedMemberName =
NodeUtil.newQualifiedNameNode(
compiler.getCodingConvention(),
Joiner.on(".").join(uniqueFullClassName, "prototype", member.getString()));
}
method = member.getFirstChild().detachFromParent();
} else if (member.isComputedProp()) {
if (member.isStaticMember()) {
qualifiedMemberName =
IR.getelem(
NodeUtil.newQualifiedNameNode(
compiler.getCodingConvention(), uniqueFullClassName),
member.removeFirstChild());
} else {
qualifiedMemberName =
IR.getelem(
NodeUtil.newQualifiedNameNode(
compiler.getCodingConvention(),
Joiner.on('.').join(uniqueFullClassName, "prototype")),
member.removeFirstChild());
}
method = member.getLastChild().detachFromParent();
} else {
throw new IllegalStateException("Unexpected class member: " + member);
}
Node assign = IR.assign(qualifiedMemberName, method);
assign.useSourceInfoIfMissingFromForTree(member);
JSDocInfo info = member.getJSDocInfo();
if (member.isStaticMember() && NodeUtil.referencesThis(assign.getLastChild())) {
JSDocInfoBuilder memberDoc;
if (info == null) {
memberDoc = new JSDocInfoBuilder(true);
} else {
memberDoc = JSDocInfoBuilder.copyFrom(info);
}
memberDoc.recordThisType(
new JSTypeExpression(
new Node(Token.BANG, new Node(Token.QMARK)), member.getSourceFileName()));
info = memberDoc.build(assign);
}
if (info != null) {
info.setAssociatedNode(assign);
assign.setJSDocInfo(info);
}
Node newNode = NodeUtil.newExpr(assign);
insertionPoint.getParent().addChildAfter(newNode, insertionPoint);
insertionPoint = newNode;
}
}
// Rewrite constructor
if (constructor == null) {
Node body = IR.block();
if (!superClassName.isEmpty()) {
Node superCall = baseCall(classNode, "constructor", null);
body.addChildToBack(IR.exprResult(superCall));
}
Node name = anonymous ? IR.name("").srcref(className) : className.detachFromParent();
constructor =
IR.function(name, IR.paramList(), body).useSourceInfoIfMissingFromForTree(classNode);
}
JSDocInfo classJSDoc = classNode.getJSDocInfo();
JSDocInfoBuilder newInfo =
(classJSDoc != null) ? JSDocInfoBuilder.copyFrom(classJSDoc) : new JSDocInfoBuilder(true);
newInfo.recordConstructor();
if (!superClassName.isEmpty()) {
if (newInfo.isInterfaceRecorded()) {
newInfo.recordExtendedInterface(
new JSTypeExpression(
new Node(Token.BANG, IR.string(superClassString)),
superClassName.getSourceFileName()));
} else {
Node inherits =
IR.call(
NodeUtil.newQualifiedNameNode(compiler.getCodingConvention(), INHERITS),
NodeUtil.newQualifiedNameNode(compiler.getCodingConvention(), fullClassName),
NodeUtil.newQualifiedNameNode(compiler.getCodingConvention(), superClassString));
Node inheritsCall = IR.exprResult(inherits);
inheritsCall.useSourceInfoIfMissingFromForTree(classNode);
Node enclosingStatement = NodeUtil.getEnclosingStatement(classNode);
enclosingStatement.getParent().addChildAfter(inheritsCall, enclosingStatement);
newInfo.recordBaseType(
new JSTypeExpression(
new Node(Token.BANG, IR.string(superClassString)),
superClassName.getSourceFileName()));
Node copyProps =
IR.call(
NodeUtil.newQualifiedNameNode(compiler.getCodingConvention(), COPY_PROP),
NodeUtil.newQualifiedNameNode(compiler.getCodingConvention(), fullClassName),
NodeUtil.newQualifiedNameNode(compiler.getCodingConvention(), superClassString));
copyProps.useSourceInfoIfMissingFromForTree(classNode);
enclosingStatement
.getParent()
.addChildAfter(IR.exprResult(copyProps).srcref(classNode), enclosingStatement);
}
}
// 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));
}
}
insertionPoint = constructor;
if (NodeUtil.isStatement(classNode)) {
constructor.getFirstChild().setString("");
Node ctorVar = IR.var(IR.name(fullClassName), constructor);
ctorVar.useSourceInfoIfMissingFromForTree(classNode);
parent.replaceChild(classNode, ctorVar);
} else {
parent.replaceChild(classNode, constructor);
}
if (NodeUtil.isStatement(constructor)) {
insertionPoint.setJSDocInfo(newInfo.build(insertionPoint));
} 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(var));
} else if (constructor.getParent().isName()) {
// Is a newly created VAR node.
Node var = constructor.getParent().getParent();
var.setJSDocInfo(newInfo.build(var));
} else if (parent.isAssign()) {
// The constructor function is the RHS of an assignment.
// Add the JSDoc to the ASSIGN node.
parent.setJSDocInfo(newInfo.build(parent));
} else {
throw new IllegalStateException("Unexpected parent node " + parent);
}
compiler.reportCodeChange();
}
