private int getNumberOfCase(AstNode switchStmt) { List<AstNode> switchSelectionList = switchStmt.getChildren(CSharpGrammar.SWITCH_SECTION); int nbCase = 0; for (AstNode switchSelection : switchSelectionList) { nbCase += switchSelection.getChildren(CSharpGrammar.SWITCH_LABEL).size(); } return nbCase; }
/** * @deprecated in 1.17, use {@link #getChildren(AstNodeType...)} instead */ @Deprecated public List<AstNode> findDirectChildren(AstNodeType... nodeTypes) { return getChildren(nodeTypes); }
private void createLambdaParameters(AstNode functionTree) { AstNode parameters = functionTree.getFirstChild(PythonGrammar.VARARGSLIST); if (parameters == null) { return; } parameters.getChildren(PythonGrammar.NAME).forEach(this::addWriteUsage); parameters.getDescendants(PythonGrammar.FPDEF).stream() .flatMap(paramDef -> paramDef.getChildren(PythonGrammar.NAME).stream()) .forEach(this::addWriteUsage); }
private void visitChildren(AstNode ast) { for (AstNode child : ast.getChildren()) { visit(child); } }
private void toXmlChildren(int level, AstNode node) throws IOException { for (AstNode child : node.getChildren()) { printNode(level + 1, child); } }
private void toXmlChildren(int level, AstNode node) throws IOException { for (AstNode child : node.getChildren()) { printNode(level + 1, child); } }
private List<AstNode> getBranchesToCompare(AstNode ifStmt) { List<AstNode> branches = ifStmt.getChildren(PythonGrammar.SUITE); AstNode elseNode = ifStmt.getFirstChild(PythonKeyword.ELSE); if (branches.size() == 2 && elseNode != null) { AstNode suite = branches.get(1); lookForElseIfs(branches, suite); } return branches; }
private List<AstNode> getIfBranches(AstNode ifStmt) { List<AstNode> branches = ifStmt.getChildren(PythonGrammar.SUITE); AstNode elseNode = ifStmt.getFirstChild(PythonKeyword.ELSE); if (branches.size() == 2 && elseNode != null) { AstNode suite = branches.get(1); lookForElseIfs(branches, suite); } return branches; }
private String countArgs(AstNode args) { int num = args.getNumberOfChildren() > 3 ? args.getChildren(ErlangGrammarImpl.comma).size() + 1 : args.getNumberOfChildren() - 2; return String.valueOf(num); } }, ErlangGrammarImpl.functionDeclaration, ErlangGrammarImpl.functionClause, ErlangGrammarImpl.funExpression));
private boolean isWrapperFunction(AstNode childFunction) { if(astNode != null && astNode.is(PythonGrammar.FUNCDEF)) { AstNode childStatement = childFunction.getParent().getParent(); return astNode.getFirstChild(PythonGrammar.SUITE) .getChildren(PythonGrammar.STATEMENT) .stream() .filter(statement -> statement != childStatement) .allMatch(NestingLevel::isSimpleReturn); } return false; }
private boolean hasValuableCode(AstNode funcDef) { AstNode statementList = funcDef.getFirstChild(PythonGrammar.SUITE).getFirstChild(PythonGrammar.STMT_LIST); if (statementList != null && statementList.getChildren(PythonGrammar.SIMPLE_STMT).size() == 1) { return !statementList.getFirstChild(PythonGrammar.SIMPLE_STMT).getFirstChild().is(PythonGrammar.PASS_STMT); } List<AstNode> statements = funcDef.getFirstChild(PythonGrammar.SUITE).getChildren(PythonGrammar.STATEMENT); if (statements.size() == 1) { return !isDocstringOrPass(statements.get(0)); } return statements.size() != 2 || !isDocstringAndPass(statements.get(0), statements.get(1)); }
public static List<AstNode> getDirectives(AstNode classDefNode) { Preconditions.checkArgument(classDefNode.is(FlexGrammar.CLASS_DEF)); return classDefNode .getFirstChild(FlexGrammar.BLOCK) .getFirstChild(FlexGrammar.DIRECTIVES) .getChildren(FlexGrammar.DIRECTIVE); }
public static List<AstNode> getFunctions(AstNode classDefNode) { Preconditions.checkArgument(classDefNode.is(FlexGrammar.CLASS_DEF)); List<AstNode> functions = Lists.newArrayList(); for (AstNode directive : classDefNode.getFirstChild(FlexGrammar.BLOCK).getFirstChild(FlexGrammar.DIRECTIVES).getChildren()) { AstNode functionDef = getFunctionDefinition(directive.getFirstChild(FlexGrammar.ANNOTABLE_DIRECTIVE)); if (functionDef != null) { functions.add(functionDef); } } return functions; }
private static AstNode getDeprecatedConstructor(AstNode astNode) { String className = astNode.getFirstChild(PHPGrammar.IDENTIFIER).getTokenOriginalValue(); for (AstNode classStmt : astNode.getChildren(PHPGrammar.CLASS_STATEMENT)) { AstNode stmt = classStmt.getFirstChild(); if (stmt.is(PHPGrammar.METHOD_DECLARATION) && className.equals(getMethodName(stmt))) { return stmt; } } return null; }
private void getCountersFromListExpression(Set<String> counters, AstNode initialiserExpr) { for (AstNode assignmentExpr : initialiserExpr.getChildren(FlexGrammar.ASSIGNMENT_EXPR_NO_IN)) { AstNode exprFirstChild = assignmentExpr.getFirstChild(); if (assignmentExpr.hasDirectChildren(FlexGrammar.ASSIGNMENT_OPERATOR)) { counters.add(Expression.exprToString(exprFirstChild)); } else if (exprFirstChild.is(FlexGrammar.UNARY_EXPR)) { counters.add(Expression.exprToString(exprFirstChild.getLastChild())); } else if (exprFirstChild.is(FlexGrammar.POSTFIX_EXPR)) { counters.add(Expression.exprToString(exprFirstChild.getFirstChild())); } } }
private static void getCountersFromListExpression(Set<String> counters, AstNode initialiserExpr) { for (AstNode assignmentExpr : initialiserExpr.getChildren(FlexGrammar.ASSIGNMENT_EXPR_NO_IN)) { AstNode exprFirstChild = assignmentExpr.getFirstChild(); if (assignmentExpr.hasDirectChildren(FlexGrammar.ASSIGNMENT_OPERATOR)) { counters.add(Expression.exprToString(exprFirstChild)); } else if (exprFirstChild.is(FlexGrammar.UNARY_EXPR)) { counters.add(Expression.exprToString(exprFirstChild.getLastChild())); } else if (exprFirstChild.is(FlexGrammar.POSTFIX_EXPR)) { counters.add(Expression.exprToString(exprFirstChild.getFirstChild())); } } }
private void retrieveTypeFromParameter(AstNode methodDeclaration) { AstNode parameterList = methodDeclaration.getFirstChild(PHPGrammar.PARAMETER_LIST); if (parameterList != null) { for (AstNode parameter : parameterList.getChildren(PHPGrammar.PARAMETER)) { AstNode classType = parameter.getFirstChild(PHPGrammar.OPTIONAL_CLASS_TYPE); if (classType != null && classType.getFirstChild().is(PHPGrammar.FULLY_QUALIFIED_CLASS_NAME)) { types.add(getClassName(classType.getFirstChild())); } } } }
public static AstNode getConstructor(AstNode classDefNode) { Preconditions.checkArgument(classDefNode.is(FlexGrammar.CLASS_DEF)); final String className = Clazz.getName(classDefNode); for (AstNode directive : classDefNode.getFirstChild(FlexGrammar.BLOCK).getFirstChild(FlexGrammar.DIRECTIVES).getChildren()) { AstNode functionDef = getFunctionDefinition(directive.getFirstChild(FlexGrammar.ANNOTABLE_DIRECTIVE)); if (functionDef != null && Function.isConstructor(functionDef, className)) { return functionDef; } } return null; }
@Override public void visitNode(AstNode astNode) { for (AstNode paramList : astNode.getChildren(PHPGrammar.PARAMETER_LIST_FOR_CALL)) { AstNode param = paramList.getFirstChild(); if (param.is(PHPGrammar.ALIAS_VARIABLE)) { getContext().createLineViolation(this, "Remove the ''&'' to pass \"{0}\" by value.", param, CheckUtils.getExpressionAsString(param.getFirstChild(PHPGrammar.MEMBER_EXPRESSION))); } } }
@Override public void visitNode(AstNode astNode) { checkFunctionParametersName(astNode); if (astNode.getFirstChild(FlexGrammar.FUNCTION_COMMON).getFirstChild(FlexGrammar.BLOCK) != null) { checkLocalVariableName(astNode.getFirstChild(FlexGrammar.FUNCTION_COMMON) .getFirstChild(FlexGrammar.BLOCK) .getFirstChild(FlexGrammar.DIRECTIVES) .getChildren(FlexGrammar.DIRECTIVE)); } }