Refine search
@Override public SourceCode createSourceCode(SourceCode parentSourceCode, AstNode astNode) { String className = astNode.getFirstDescendant(ErlangGrammarImpl.moduleAttr).getFirstChild(ErlangGrammarImpl.atom).getTokenValue(); SourceClass cls = new SourceClass(className + ":" + astNode.getToken().getLine()); cls.setStartAtLine(astNode.getTokenLine()); return cls; } }, ErlangGrammarImpl.module));
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); }
private String extractPropertySignature(AstNode astNode) { StringBuilder signature = new StringBuilder(astNode.getPreviousSibling().getLastToken().getValue()); signature.append("_"); AstNode delcarationNode = astNode.getParent().getParent().getParent(); if (delcarationNode.is(CSharpGrammar.INDEXER_DECLARATION)) { signature.append("Item"); } else { signature.append(delcarationNode.getFirstChild(CSharpGrammar.MEMBER_NAME).getTokenValue()); } signature.append(":"); signature.append(astNode.getTokenLine()); return signature.toString(); }
public static int getNumberOfLine(AstNode functionNode) { AstNode blockNode = functionNode.getFirstChild(FlexGrammar.FUNCTION_COMMON).getFirstChild(FlexGrammar.BLOCK); // Is not an abstract method if (blockNode != null) { int firstLine = blockNode.getFirstChild(FlexPunctuator.LCURLYBRACE).getTokenLine(); int lastLine = blockNode.getFirstChild(FlexPunctuator.RCURLYBRACE).getTokenLine(); return lastLine - firstLine + 1; } return 0; } }
private static boolean isNotVariableVariables(AstNode compoundNode) { AstNode compoundParentPreviousNode = compoundNode.getParent().getPreviousAstNode(); return compoundParentPreviousNode != null && compoundParentPreviousNode.isNot(PHPGrammar.SIMPLE_INDIRECT_REFERENCE); } }
private void addSimpleField(AstNode test) { Token token = test.getToken(); if (test.getNumberOfChildren() == 1 && test.getFirstChild().is(PythonGrammar.ATOM) && token.getType().equals(GenericTokenType.IDENTIFIER) && !CheckUtils.containsValue(symbols, token.getValue())) { symbols.add(token); } }
private int getLineStartingColumn(AstNode node) { int line = node.getTokenLine(); AstNode previousNode = node.getPreviousAstNode(); int column = node.getToken().getColumn(); while (previousNode != null && previousNode.getToken().getLine() == line) { column = previousNode.getToken().getColumn(); previousNode = previousNode.getParent(); } return column; }
private boolean isFirstOnline(AstNode curlyBrace) { Token previousToken = curlyBrace.getPreviousAstNode().getLastToken(); // In one case, clonsing parenthesis can be on the same line as the opening curly brace if (previousToken.getType().equals(PHPPunctuator.RPARENTHESIS)) { previousToken = curlyBrace.getPreviousAstNode().getPreviousAstNode().getLastToken(); } return previousToken.getLine() != curlyBrace.getTokenLine(); }
/** * Check that else, catch or finally keywords are on the same line as the previous closing curly brace. */ private void checkRCurlyBraceOnSameLine(FormattingStandardCheck formattingCheck, AstNode node) { Token previsouToken = node.getPreviousAstNode().getLastToken(); String keyword = node.getFirstChild(PHPKeyword.ELSE, PHPKeyword.CATCH, PHPKeyword.FINALLY).getTokenOriginalValue(); if (previsouToken.getType().equals(PHPPunctuator.RCURLYBRACE) && previsouToken.getLine() != node.getTokenLine()) { formattingCheck.reportIssue("Move this \"" + keyword + "\" to the same line as the previous closing curly brace.", node); } }
private void appendNodecontent(AstNode node) throws IOException { writer.append(node.getName()); if (node.getTokenValue() != null) { writer.append(" tokenValue=\"" + node.getTokenValue() + "\""); } if (node.hasToken()) { writer.append(" tokenLine=\"" + node.getTokenLine() + "\" tokenColumn=\"" + node.getToken().getColumn() + "\""); } }
private void addSelfField(AstNode test) { if ("self".equals(test.getTokenValue())) { AstNode trailer = test.getFirstDescendant(PythonGrammar.TRAILER); if (trailer != null && trailer.getFirstChild(PythonGrammar.NAME) != null) { Token token = trailer.getFirstChild(PythonGrammar.NAME).getToken(); if (!CheckUtils.containsValue(symbols, token.getValue())) { symbols.add(token); } } } }
@Override public void visitNode(AstNode node) { if (node.hasParent(PlSqlGrammar.VARIABLE_DECLARATION)) { AstNode datatype = node.getParent().getFirstChild(PlSqlGrammar.DATATYPE); AstNode expression = node.getLastChild(); if (expression.is(PlSqlGrammar.METHOD_CALL) && !datatype.getTokenValue().equals(expression.getTokenValue())) { addLineIssue(getLocalizedMessage(CHECK_KEY), node.getTokenLine()); } } }
@Override public void visitNode(AstNode node) { AstNode parent = node.getParent(); if (parentIsNotExpression(parent) && node.getNumberOfChildren() == 3) { AstNode foundCandidate = node.getLastChild(); AstNode percentCandidate = foundCandidate.getPreviousAstNode(); if (percentCandidate.is(PlSqlPunctuator.MOD) && "FOUND".equals(foundCandidate.getTokenValue())) { addLineIssue(getLocalizedMessage(CHECK_KEY), node.getTokenLine()); } } }
private static boolean returnReturnNone(AstNode stmt) { return stmt.is(PythonGrammar.RETURN_STMT) && (stmt.getFirstChild(PythonGrammar.TESTLIST) == null || stmt.getFirstChild(PythonGrammar.TESTLIST).getToken().getValue().equals(PythonKeyword.NONE.getValue())); }
/** * Check there is not space between a function's name and the opening parenthesis. */ private void checkSpaceAfterFunctionName(FormattingStandardCheck formattingCheck, AstNode node) { Token lParenToken = node.getFirstChild(PHPPunctuator.LPARENTHESIS).getToken(); Token funcNameToken = node.is(PHPGrammar.FUNCTION_CALL_PARAMETER_LIST) ? node.getPreviousAstNode().getLastToken() : node.getFirstChild(PHPGrammar.IDENTIFIER).getToken(); if (getNbSpaceBetween(funcNameToken, lParenToken) != 0) { formattingCheck.reportIssue("Remove all space between the method name \"" + funcNameToken.getOriginalValue() + "\" and the opening parenthesis.", node); } }
public static boolean isOnASingleLine(AstNode parent) { List<AstNode> statements = parent.getChildren(PythonGrammar.STATEMENT); if (statements.isEmpty()) { return true; } return statements.get(0).getTokenLine() == statements.get(statements.size() - 1).getLastToken().getLine(); } }
private static boolean isOverridingParentFunction(AstNode attributesNode) { if (attributesNode != null && attributesNode.is(FlexGrammar.ATTRIBUTES)) { for (AstNode attribute : attributesNode.getChildren()) { if (attribute.getFirstChild().is(FlexGrammar.ATTRIBUTE_EXPR) && attribute.getFirstChild().getNumberOfChildren() == 1 && attribute.getFirstChild().getFirstChild(FlexGrammar.IDENTIFIER).getTokenValue().equals(FlexKeyword.OVERRIDE.getValue())) { return true; } } } return false; }
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())); } } }