@Override public void visitObjectLiteral(ObjectLiteralTree tree) { scan(tree.properties()); }
private static boolean isMultiline(ObjectLiteralTree objectLiteral) { return isMultilineInternal(objectLiteral.properties(), objectLiteral.closeCurlyBraceToken()); }
private void raiseIssue(ObjectLiteralTree tree, int begin, int end, String primaryMessage, String secondaryMessage) { PreciseIssue preciseIssue = addIssue(tree.openCurlyBraceToken(), primaryMessage); for (int i = begin; i < end; i++) { if (isShorthand(tree.properties().get(i))) { preciseIssue.secondary(tree.properties().get(i), secondaryMessage); } } }
@Override public void visitNode(Tree tree) { if (tree.is(Kind.BLOCK)) { BlockTree body = (BlockTree) tree; Tree parent = body.parent(); SyntaxToken openCurly = body.openCurlyBraceToken(); openCurly.column(); checkFunction(parent, openCurly); checkConditional(parent, openCurly); checkLoop(parent, openCurly); checkTryCatchFinally(body, parent, openCurly); checkWith(parent, openCurly); } if (tree.is(Kind.OBJECT_LITERAL)) { ObjectLiteralTree objectLiteral = (ObjectLiteralTree) tree; SyntaxToken openCurly = objectLiteral.openCurlyBraceToken(); Tree parent = objectLiteral.parent(); checkAssignment(openCurly, parent); } if (tree.is(Kind.SWITCH_STATEMENT)) { checkSwitch((SwitchStatementTree) tree); } if (tree.is(Kind.CLASS_DECLARATION, Kind.CLASS_EXPRESSION)) { checkClass((ClassTree) tree); } }
private static boolean endsWithComma(ObjectLiteralTree objectLiteral) { SeparatedList<Tree> properties = objectLiteral.properties(); return properties.size() == properties.getSeparators().size(); }
@Override public void visitObjectLiteral(ObjectLiteralTree tree) { checkProperties(tree.properties()); super.visitObjectLiteral(tree); }
@Override public void visitObjectLiteral(ObjectLiteralTree tree) { checkProperties(tree.properties()); super.visitObjectLiteral(tree); }
/** * @return the pair property with the given name within the given object literal, null if not found */ @Nullable public static PairPropertyTree getModelProperty(ObjectLiteralTree objectLiteral, String propertyName) { for (Tree property : objectLiteral.properties()) { if (property.is(Tree.Kind.PAIR_PROPERTY)) { PairPropertyTree pairProperty = (PairPropertyTree) property; if (Utils.identifierWithName(pairProperty.key(), propertyName)) { return pairProperty; } } } return null; } }
private static boolean hasObjectOrArrayAttribute(ObjectLiteralTree objectLiteral) { for (Tree property : objectLiteral.properties()) { if (property.is(Kind.PAIR_PROPERTY) && ((PairPropertyTree) property).value().is(Kind.ARRAY_LITERAL, Kind.OBJECT_LITERAL)) { return true; } } return false; }
private void checkForSpaceInPropertyNames(ObjectLiteralTree objectLiteral) { for (Tree attribute : objectLiteral.properties()) { if (attribute.is(Kind.PAIR_PROPERTY)) { Tree key = ((PairPropertyTree) attribute).key(); checkString(key); } } }
private void checkForSpaceInPropertyNames(ObjectLiteralTree objectLiteral) { for (Tree attribute : objectLiteral.properties()) { if (attribute.is(Kind.PAIR_PROPERTY)) { ExpressionTree key = ((PairPropertyTree) attribute).key(); checkString(key); } } }
private static boolean hasObjectOrArrayAttribute(ObjectLiteralTree objectLiteral) { for (Tree property : objectLiteral.properties()) { if (property.is(Kind.PAIR_PROPERTY) && ((PairPropertyTree) property).value().is(Kind.ARRAY_LITERAL, Kind.OBJECT_LITERAL)) { return true; } } return false; }
@Override public void visitObjectLiteral(ObjectLiteralTree tree) { // list keeps true for shorthand property List<Boolean> isShorthandPropertyList = new ArrayList<>(); int shorthandPropertiesNumber = 0; boolean containsSpreadProperty = false; for (Tree propertyTree : tree.properties()) { if (propertyTree.is(Kind.SPREAD_ELEMENT)) { containsSpreadProperty = true; break; } else { boolean isShorthandProperty = isShorthand(propertyTree); isShorthandPropertyList.add(isShorthandProperty); shorthandPropertiesNumber += isShorthandProperty ? 1 : 0; } } if (!containsSpreadProperty && shorthandPropertiesNumber > 0) { analyseShorthandPropertiesPosition(tree, isShorthandPropertyList, shorthandPropertiesNumber); } super.visitObjectLiteral(tree); }
@Override public void visitObjectLiteral(ObjectLiteralTree tree) { SeparatedList<Tree> separatedList = tree.properties(); int listSize = separatedList.size(); if (listSize > 0 && listSize == separatedList.getSeparators().size()) { Tree trailingComma = separatedList.getSeparator(listSize - 1); raiseIssue(trailingComma); } super.visitObjectLiteral(tree); }
@Override public void visitObjectLiteral(ObjectLiteralTree tree) { if (isMultiline(tree) && !endsWithComma(tree)) { raiseIssueOnLastElement(tree.properties()); } super.visitObjectLiteral(tree); }
@Override public void visitObjectLiteral(ObjectLiteralTree tree) { Set<String> keys = Sets.newHashSet(); for (Tree property : tree.properties()){ if (property.is(Tree.Kind.PAIR_PROPERTY)){ visitPairProperty(keys, property, (PairPropertyTree)property); } if (property instanceof IdentifierTree){ IdentifierTree identifier = (IdentifierTree)property; addKey(keys, identifier.name(), property); } } super.visitObjectLiteral(tree); }
private void analyseShorthandPropertiesPosition(ObjectLiteralTree tree, List<Boolean> isShorthandPropertyList, int shorthandPropertiesNumber) { int numberOfShorthandAtBeginning = getNumberOfTrueAtBeginning(isShorthandPropertyList); int numberOfShorthandAtEnd = getNumberOfTrueAtBeginning(Lists.reverse(isShorthandPropertyList)); boolean allAtBeginning = numberOfShorthandAtBeginning == shorthandPropertiesNumber; boolean allAtEnd = numberOfShorthandAtEnd == shorthandPropertiesNumber; int propertiesNumber = tree.properties().size(); if (!allAtBeginning && numberOfShorthandAtBeginning > numberOfShorthandAtEnd) { raiseIssuePattern(tree, numberOfShorthandAtBeginning, propertiesNumber, "beginning"); } else if (!allAtEnd && numberOfShorthandAtEnd > numberOfShorthandAtBeginning) { raiseIssuePattern(tree, 0, propertiesNumber - numberOfShorthandAtEnd, "end"); } else if (!allAtBeginning && !allAtEnd) { raiseIssue(tree, 0, propertiesNumber, MESSAGE, SECONDARY_MESSAGE); } }
private static boolean isBasicValue(ExpressionTree expression) { if (expression.is(Kind.BOOLEAN_LITERAL, Kind.NUMERIC_LITERAL, Kind.STRING_LITERAL, Kind.NULL_LITERAL)) { return BASIC_LITERAL_VALUES.contains(((LiteralTree) expression).value()); } else if (expression.is(Kind.UNARY_MINUS)) { ExpressionTree operand = ((UnaryExpressionTree) expression).expression(); return BASIC_LITERAL_VALUES.contains("-" + ((LiteralTree) operand).value()); } else if (expression.is(Kind.ARRAY_LITERAL)) { return ((ArrayLiteralTree) expression).elements().isEmpty(); } else if (expression.is(Kind.OBJECT_LITERAL)) { return ((ObjectLiteralTree) expression).properties().isEmpty(); } else if (expression.is(Kind.IDENTIFIER_REFERENCE)) { return ((IdentifierTree) expression).name().equals("undefined"); } ExpressionTree withoutParenthesis = CheckUtils.removeParenthesis(expression); if (withoutParenthesis.is(Kind.VOID)) { ExpressionTree operand = ((UnaryExpressionTree) withoutParenthesis).expression(); return operand.is(Kind.NUMERIC_LITERAL) && "0".equals(((LiteralTree) operand).value()); } return false; }