Node processForOf(ForOfStatementTree loopNode) { maybeWarnEs6Feature(loopNode, Feature.FOR_OF); Node initializer = transform(loopNode.initializer); ImmutableSet<Integer> invalidInitializers = ImmutableSet.of(Token.ARRAYLIT, Token.OBJECTLIT); if (invalidInitializers.contains(initializer.getType())) { errorReporter.error("Invalid LHS for a for-of loop", sourceName, lineno(loopNode.initializer), charno(loopNode.initializer)); } return newNode( Token.FOR_OF, initializer, transform(loopNode.collection), transformBlock(loopNode.body)); }
Node processVariableDeclarationList(VariableDeclarationListTree decl) { int declType; switch (decl.declarationType) { case CONST: maybeWarnEs6Feature(decl, Feature.CONST_DECLARATIONS); declType = Token.CONST; break; case LET: maybeWarnEs6Feature(decl, Feature.LET_DECLARATIONS); declType = Token.LET; break; case VAR: declType = Token.VAR; break; default: throw new IllegalStateException(); } Node node = newNode(declType); for (VariableDeclarationTree child : decl.declarations) { node.addChildToBack(transformNodeWithInlineJsDoc(child)); } return node; }
Node processExportDecl(ExportDeclarationTree tree) { maybeWarnEs6Feature(tree, Feature.MODULES); Node decls = null; if (tree.isExportAll) { Preconditions.checkState( tree.declaration == null && tree.exportSpecifierList == null); } else if (tree.declaration != null) { Preconditions.checkState(tree.exportSpecifierList == null); decls = transform(tree.declaration); } else { decls = transformList(Token.EXPORT_SPECS, tree.exportSpecifierList); } if (decls == null) { decls = newNode(Token.EMPTY); } setSourceInfo(decls, tree); Node export = newNode(Token.EXPORT, decls); if (tree.from != null) { Node from = processString(tree.from); export.addChildToBack(from); } export.putBooleanProp(Node.EXPORT_ALL_FROM, tree.isExportAll); export.putBooleanProp(Node.EXPORT_DEFAULT, tree.isDefault); return export; }
Node processObjectLiteral(ObjectLiteralExpressionTree objTree) { Node node = newNode(Token.OBJECTLIT); boolean maybeWarn = false; for (ParseTree el : objTree.propertyNameAndValues) { if (el.type == ParseTreeType.DEFAULT_PARAMETER) { // (e.g. var o = { x=4 };) This is only parsed for compatibility with object patterns. errorReporter.error( "Default value cannot appear at top level of an object literal.", sourceName, lineno(el), 0); continue; } else if (el.type == ParseTreeType.GET_ACCESSOR && maybeReportGetter(el)) { continue; } else if (el.type == ParseTreeType.SET_ACCESSOR && maybeReportSetter(el)) { continue; } Node key = transform(el); if (!key.isComputedProp() && !key.isQuotedString() && !currentFileIsExterns) { maybeWarnKeywordProperty(key); } if (key.getFirstChild() == null) { maybeWarn = true; } node.addChildToBack(key); } if (maybeWarn) { maybeWarnEs6Feature(objTree, Feature.EXTENDED_OBJECT_LITERALS); } return node; }
Node processClassDeclaration(ClassDeclarationTree tree) { maybeWarnEs6Feature(tree, Feature.CLASSES); Node name = transformOrEmpty(tree.name, tree); maybeProcessGenerics(name, tree.generics); Node superClass = transformOrEmpty(tree.superClass, tree); Node interfaces = transformListOrEmpty(Token.IMPLEMENTS, tree.interfaces); Node body = newNode(Token.CLASS_MEMBERS); setSourceInfo(body, tree); for (ParseTree child : tree.elements) { if (child.type == ParseTreeType.MEMBER_VARIABLE || child.type == ParseTreeType.COMPUTED_PROPERTY_MEMBER_VARIABLE) { maybeWarnTypeSyntax(child, Feature.MEMBER_VARIABLE_IN_CLASS); } body.addChildToBack(transform(child)); } Node classNode = newNode(Token.CLASS, name, superClass, body); if (!interfaces.isEmpty()) { maybeWarnTypeSyntax(tree, Feature.IMPLEMENTS); classNode.putProp(Node.IMPLEMENTS, interfaces); } return classNode; }
private void validateRegExpFlags(LiteralExpressionTree tree, String flags) { for (char flag : Lists.charactersOf(flags)) { switch (flag) { case 'g': case 'i': case 'm': break; case 'u': case 'y': Feature feature = flag == 'u' ? Feature.REGEXP_FLAG_U : Feature.REGEXP_FLAG_Y; maybeWarnEs6Feature(tree, feature); break; default: errorReporter.error( "Invalid RegExp flag '" + flag + "'", sourceName, lineno(tree), charno(tree)); } } }
Node processSpreadExpression(SpreadExpressionTree tree) { maybeWarnEs6Feature(tree, Feature.SPREAD_EXPRESSIONS); return newNode(Token.SPREAD, transform(tree.expression)); }
Node processSuper(SuperExpressionTree tree) { maybeWarnEs6Feature(tree, Feature.SUPER); return newNode(Token.SUPER); }
Node processComputedPropertyMethod(ComputedPropertyMethodTree tree) { maybeWarnEs6Feature(tree, Feature.COMPUTED_PROPERTIES); Node n = newNode(Token.COMPUTED_PROP, transform(tree.property), transform(tree.method)); n.putBooleanProp(Node.COMPUTED_PROP_METHOD, true); if (tree.method.asFunctionDeclaration().isStatic) { n.setStaticMember(true); } maybeProcessAccessibilityModifier(n, tree.access); return n; }
Node processComputedPropertyMemberVariable(ComputedPropertyMemberVariableTree tree) { maybeWarnEs6Feature(tree, Feature.COMPUTED_PROPERTIES); maybeWarnTypeSyntax(tree, Feature.COMPUTED_PROPERTIES); Node n = newNode(Token.COMPUTED_PROP, transform(tree.property)); maybeProcessType(n, tree.declaredType); n.putBooleanProp(Node.COMPUTED_PROP_VARIABLE, true); n.putProp(Node.ACCESS_MODIFIER, tree.access); n.setStaticMember(tree.isStatic); maybeProcessAccessibilityModifier(n, tree.access); return n; }
Node processObjectPattern(ObjectPatternTree tree) { maybeWarnEs6Feature(tree, Feature.DESTRUCTURING); Node node = newNode(Token.OBJECT_PATTERN); for (ParseTree child : tree.fields) { node.addChildToBack(transformNodeWithInlineJsDoc(child)); } return node; }
Node processComputedPropertyDefinition(ComputedPropertyDefinitionTree tree) { maybeWarnEs6Feature(tree, Feature.COMPUTED_PROPERTIES); return newNode(Token.COMPUTED_PROP, transform(tree.property), transform(tree.value)); }
Node processArrayPattern(ArrayPatternTree tree) { maybeWarnEs6Feature(tree, Feature.DESTRUCTURING); Node node = newNode(Token.ARRAY_PATTERN); for (ParseTree child : tree.elements) { node.addChildToBack(transformNodeWithInlineJsDoc(child)); } return node; }
Node processComputedPropertyGetter(ComputedPropertyGetterTree tree) { maybeWarnEs6Feature(tree, Feature.COMPUTED_PROPERTIES); Node key = transform(tree.property); Node body = transform(tree.body); Node function = IR.function(IR.name(""), IR.paramList(), body); function.useSourceInfoIfMissingFromForTree(body); Node n = newNode(Token.COMPUTED_PROP, key, function); n.putBooleanProp(Node.COMPUTED_PROP_GETTER, true); n.putBooleanProp(Node.STATIC_MEMBER, tree.isStatic); return n; }
Node processDefaultParameter(DefaultParameterTree tree) { maybeWarnEs6Feature(tree, Feature.DEFAULT_PARAMETERS); return newNode(Token.DEFAULT_VALUE, transform(tree.lhs), transform(tree.defaultValue)); }
Node processNewTarget(NewTargetExpressionTree tree) { maybeWarnEs6Feature(tree, Feature.NEW_TARGET); return newNode(Token.NEW_TARGET); }
Node processImportDecl(ImportDeclarationTree tree) { maybeWarnEs6Feature(tree, Feature.MODULES); Node firstChild = transformOrEmpty(tree.defaultBindingIdentifier, tree); Node secondChild = (tree.nameSpaceImportIdentifier != null) ? newStringNode(Token.IMPORT_STAR, tree.nameSpaceImportIdentifier.value) : transformListOrEmpty(Token.IMPORT_SPECS, tree.importSpecifierList); setSourceInfo(secondChild, tree); Node thirdChild = processString(tree.moduleSpecifier); return newNode(Token.IMPORT, firstChild, secondChild, thirdChild); }
Node processComputedPropertySetter(ComputedPropertySetterTree tree) { maybeWarnEs6Feature(tree, Feature.COMPUTED_PROPERTIES); Node key = transform(tree.property); Node body = transform(tree.body); Node paramList = IR.paramList(safeProcessName(tree.parameter)); Node function = IR.function(IR.name(""), paramList, body); function.useSourceInfoIfMissingFromForTree(body); Node n = newNode(Token.COMPUTED_PROP, key, function); n.putBooleanProp(Node.COMPUTED_PROP_SETTER, true); n.putBooleanProp(Node.STATIC_MEMBER, tree.isStatic); return n; }
Node processTemplateLiteral(TemplateLiteralExpressionTree tree) { maybeWarnEs6Feature(tree, Feature.TEMPLATE_LITERALS); Node templateLitNode = newNode(Token.TEMPLATELIT); setSourceInfo(templateLitNode, tree); Node node = tree.operand == null ? templateLitNode : newNode(Token.TAGGED_TEMPLATELIT, transform(tree.operand), templateLitNode); for (ParseTree child : tree.elements) { templateLitNode.addChildToBack(transform(child)); } return node; }
Node processRestParameter(RestParameterTree tree) { maybeWarnEs6Feature(tree, Feature.REST_PARAMETERS); Node name = newStringNode(Token.NAME, tree.identifier.value); setSourceInfo(name, tree.identifier); return newNode(Token.REST, name); }