/** * Raise an issue if the local category is passed as a String. */ private void checkLocalCategoryArgument(SeparatedList<ExpressionTree> arguments) { if (!arguments.isEmpty() && arguments.get(0).is(Kind.REGULAR_STRING_LITERAL)) { String firstArg = ((LiteralTree) arguments.get(0)).value(); String localCategory = firstArg.substring(1, firstArg.length() - 1); if (LOCALE_CATEGORY_CONSTANTS.contains(localCategory)) { context().newIssue(this, arguments.get(0), String.format(MESSAGE_SET_LOCAL_ARG, localCategory)); } } }
private static boolean isVariableLengthParameterList(ParameterListTree parameterList) { SeparatedList<ParameterTree> parameters = parameterList.parameters(); if (!parameters.isEmpty()) { ParameterTree lastParameter = parameters.get(parameters.size() - 1); return lastParameter.ellipsisToken() != null; } return false; }
private static boolean isSuspiciousGlobalConfiguration(String lowerCaseQualifiedName, SeparatedList<ExpressionTree> arguments) { return GLOBAL_CONFIGURATION_FUNCTIONS.contains(lowerCaseQualifiedName) && arguments.size() == 2 && isSuspiciousDirective(getStringValue(arguments.get(0)), arguments.get(1)); }
@Override public void visitArrayInitializerBracket(ArrayInitializerBracketTree tree) { tree.arrayPairs().stream() .map(ArrayPairTree::key) .filter(Objects::nonNull) .filter(key -> key.is(Tree.Kind.REGULAR_STRING_LITERAL) && "salt".equals(trimQuotes(((LiteralTree) key)))) .forEach(passwordHashSaltTrees::add); super.visitArrayInitializerBracket(tree); } }
@Test public void with_argument() throws Exception { FunctionCallTree tree = parse("f($p1, $p2)", PHPLexicalGrammar.MEMBER_EXPRESSION); assertThat(tree.is(Kind.FUNCTION_CALL)).isTrue(); assertThat(expressionToString(tree.callee())).isEqualTo("f"); assertThat(tree.openParenthesisToken().text()).isEqualTo("("); assertThat(tree.arguments()).hasSize(2); assertThat(tree.arguments().getSeparators()).hasSize(1); assertThat(expressionToString(tree.arguments().get(0))).isEqualTo("$p1"); assertThat(expressionToString(tree.arguments().get(1))).isEqualTo("$p2"); assertThat(tree.closeParenthesisToken().text()).isEqualTo(")"); }
private static boolean isEmptyArrayConstructor(ExpressionTree arg) { return (arg.is(Tree.Kind.ARRAY_INITIALIZER_FUNCTION, Tree.Kind.ARRAY_INITIALIZER_BRACKET) && ((ArrayInitializerTree) arg).arrayPairs().isEmpty()); }
/** * Used to resolve namespaceNameTree which is using an alias */ public QualifiedName resolveAliasedName(NamespaceNameTree namespaceNameTree) { if (namespaceNameTree.namespaces().isEmpty()) { throw new IllegalStateException("Unable to resolve " + namespaceNameTree + " which has only aliased name"); } ImmutableList.Builder<String> nameBuilder = ImmutableList.<String>builder() .addAll(nameElements); // skip the first element of the namespace, because it's an alias namespaceNameTree.namespaces() .stream() .skip(1) .map(NameIdentifierTree::text) .forEach(nameBuilder::add); nameBuilder.add(namespaceNameTree.name().text()); return new QualifiedName(nameBuilder.build()); }
@CheckForNull private QualifiedName resolveAlias(NamespaceNameTree namespaceNameTree) { if (namespaceNameTree.isFullyQualified()) { return null; } if (namespaceNameTree.namespaces().isEmpty()) { return lookupAlias(namespaceNameTree.name()); } // first namespace element is potentially an alias NameIdentifierTree potentialAlias = namespaceNameTree.namespaces().iterator().next(); QualifiedName aliasedNamespace = lookupAlias(potentialAlias); if (aliasedNamespace != null) { return aliasedNamespace.resolveAliasedName(namespaceNameTree); } return null; }
@Test public void test() throws Exception { ExpressionListStatementTree tree = parse("$a, foo();", PHPLexicalGrammar.EXPRESSION_LIST_STATEMENT); assertThat(tree.is(Kind.EXPRESSION_LIST_STATEMENT)).isTrue(); assertThat(tree.expressions()).hasSize(2); assertThat(tree.expressions().get(0).is(Kind.VARIABLE_IDENTIFIER)).isTrue(); assertThat(tree.expressions().get(1).is(Kind.FUNCTION_CALL)).isTrue(); assertThat(tree.eosToken().text()).isEqualTo(";"); }
@Override public void visitParameterList(ParameterListTree tree) { checkSpaceForComma(new TokenVisitor(tree), tree.parameters().getSeparators()); super.visitParameterList(tree); }
private boolean matches(FunctionCallTree function) { int argumentCount = function.arguments().size(); boolean pathMatches = pathIndexes.length == 0 || hasFileSystemPath(function.arguments()); return minCount <= argumentCount && argumentCount <= maxCount && pathMatches; }
@Override public Iterator<Tree> childrenIterator() { return Iterators.concat(expressions.elementsAndSeparators(), Iterators.singletonIterator(eosToken)); }
private static boolean isSuspiciousGlobalConfiguration(String lowerCaseQualifiedName, SeparatedList<ExpressionTree> arguments) { return GLOBAL_CONFIGURATION_FUNCTIONS.contains(lowerCaseQualifiedName) && arguments.size() == 2 && isSuspiciousDirective(getStringValue(arguments.get(0)), arguments.get(1)); }
@Override public void visitArrayInitializerBracket(ArrayInitializerBracketTree tree) { tree.arrayPairs().stream() .map(ArrayPairTree::key) .filter(Objects::nonNull) .filter(key -> key.is(Tree.Kind.REGULAR_STRING_LITERAL) && "salt".equals(trimQuotes(((LiteralTree) key)))) .forEach(passwordHashSaltTrees::add); super.visitArrayInitializerBracket(tree); } }
@Test public void with_trailing_comma() throws Exception { ArrayInitializerBracketTree tree = parse("[0, 1, 2,]", PHPLexicalGrammar.ARRAY_INIALIZER); assertThat(tree.is(Kind.ARRAY_INITIALIZER_BRACKET)).isTrue(); assertThat(tree.openBracketToken().text()).isEqualTo("["); assertThat(tree.arrayPairs()).hasSize(3); assertThat(tree.arrayPairs().getSeparators()).hasSize(3); assertThat(expressionToString(tree.arrayPairs().get(0))).isEqualTo("0"); assertThat(tree.closeBracketToken().text()).isEqualTo("]"); }
@Test public void with_namespace_keyword() throws Exception { NamespaceNameTree tree = parse("namespace\\subNS\\name", PHPLexicalGrammar.NAMESPACE_NAME); assertThat(tree.namespaces().get(0).text()).isEqualTo("namespace"); }
@Override public void visitParameterList(ParameterListTree tree) { checkSpaceForComma(new TokenVisitor(tree), tree.parameters().getSeparators()); super.visitParameterList(tree); }
private void checkParseStrArguments(FunctionCallTree tree) { if (tree.arguments().size() < 2) { context().newIssue(this, tree, "Add a second argument to this call to \"parse_str\"."); } }