@Override
public void leaveNode(AstNode astNode) {
if (isInClass && classStack.peek().isInConstructor && astNode.is(FlexGrammar.FUNCTION_DEF)) {
classStack.peek().isInConstructor = false;
} else if (isInClass && astNode.is(FlexGrammar.CLASS_DEF)) {
classStack.pop();
isInClass = classStack.isEmpty() ? false : true;
}
}
@Override
public void visitNode(AstNode astNode) {
if (astNode.is(FlexGrammar.CLASS_DEF)) {
inClass = true;
classStack.push(new ClassState(astNode));
} else if (inClass && astNode.is(FlexGrammar.QUALIFIED_IDENTIFIER)) {
classStack.peek().use(astNode);
}
}
@Override
public void visitNode(AstNode astNode) {
if (astNode.is(PHPGrammar.FUNCTION_DECLARATION)) {
getContext().createLineViolation(this, "Move this function into a class.", astNode);
} else if (scopes.isEmpty()) {
checkAssignment(astNode);
}
if (astNode.is(FunctionUtils.functions())) {
scopes.push(astNode);
}
}
@Override
public void visitNode(AstNode astNode) {
if (astNode.is(PythonGrammar.FILE_INPUT)) {
visitModule(astNode);
}
if (astNode.is(PythonGrammar.FUNCDEF)) {
visitFuncDef(astNode);
}
if (astNode.is(PythonGrammar.CLASSDEF)) {
visitClassDef(astNode);
}
}
@Override
public void visitNode(AstNode astNode) {
EcmaScriptGrammar g = getContext().getGrammar();
if (astNode.is(g.functionDeclaration, g.functionExpression)) {
checkFunction(astNode);
} else if (astNode.is(g.catch_, g.variableDeclaration, g.variableDeclarationNoIn)) {
checkVariableDeclaration(astNode);
} else if (astNode.is(g.propertySetParameterList)) {
checkPropertySetParameterList(astNode);
} else if (astNode.is(g.memberExpression)) {
checkModification(astNode);
}
}
private static AstNode getFunctionBlock(AstNode functionNode) {
if (functionNode.is(PHPGrammar.METHOD_DECLARATION)) {
return functionNode.getFirstChild(PHPGrammar.METHOD_BODY).getFirstChild(PHPGrammar.BLOCK);
} else {
return functionNode.getFirstChild(PHPGrammar.BLOCK);
}
}
@Test
public void test_children_when_one_child() {
AstNodeType type1 = mock(AstNodeType.class);
AstNodeType type2 = mock(AstNodeType.class);
AstNode child = mock(AstNode.class);
when(node.getNumberOfChildren()).thenReturn(1);
when(node.getFirstChild()).thenReturn(child);
AstSelect children = select.children();
assertThat((Object) children).isInstanceOf(SingleAstSelect.class);
assertThat(children).containsOnly(child);
when(node.getChildren()).thenReturn(ImmutableList.of(child));
children = select.children(type1);
assertThat((Object) children).isSameAs(AstSelectFactory.empty());
when(child.getType()).thenReturn(type1);
children = select.children(type1);
assertThat((Object) children).isInstanceOf(SingleAstSelect.class);
assertThat(children).containsOnly(child);
children = select.children(type1, type2);
assertThat((Object) children).isSameAs(AstSelectFactory.empty());
when(child.is(type1, type2)).thenReturn(true);
children = select.children(type1, type2);
assertThat((Object) children).isInstanceOf(SingleAstSelect.class);
assertThat(children).containsOnly(child);
}
@Override
public void visitNode(AstNode node) {
if (node.is(PHPGrammar.IF_STATEMENT)) {
visitIfStatementNode(node);
} else {
visitCaseListNode(node);
}
}
@Override
public void leaveNode(AstNode astNode) {
if (astNode.is(FlexGrammar.CLASS_DEF)) {
reportUnusedPrivateFunction();
classStack.pop();
inClass = classStack.isEmpty() ? false : true;
}
}
@Test
public void test_filter_by_types() {
AstNodeType type1 = mock(AstNodeType.class);
AstNodeType type2 = mock(AstNodeType.class);
assertThat((Object) select.filter(type1, type2)).isSameAs(AstSelectFactory.empty());
when(node.is(type1, type2)).thenReturn(true);
assertThat((Object) select.filter(type1, type2)).isSameAs(select);
}
private boolean isDefaultOrDeleteFunctionBody(AstNode functionBodyNode) {
boolean defaultOrDelete = false;
List<AstNode> functionBody = functionBodyNode.getChildren();
// look for exact sub AST
if (functionBody.size() == 3) {
if (functionBody.get(0).is(CxxPunctuator.ASSIGN)
&& functionBody.get(2).is(CxxPunctuator.SEMICOLON)) {
AstNode bodyType = functionBody.get(1);
if (bodyType.is(CxxKeyword.DELETE) || bodyType.is(CxxKeyword.DEFAULT)) {
defaultOrDelete = true;
}
}
}
return defaultOrDelete;
}
@Override
public void visitNode(AstNode node) {
if (node.is(CxxGrammarImpl.LITERAL)) {
reg.reset(node.getTokenOriginalValue().replaceAll("\\s", ""));
if (reg.find()) {
getContext()
.createLineViolation(this, "Do not hard code sensitive data in programs.", node);
}
}
}
@Override
public void visitNode(AstNode node) {
for (AstNode nestedNode :
node.getDescendants(PuppetGrammar.CLASSDEF, PuppetGrammar.DEFINITION)) {
message =
"Move this nested "
+ (nestedNode.is(PuppetGrammar.CLASSDEF) ? "class " : "define ")
+ "\""
+ nestedNode.getFirstChild(PuppetGrammar.CLASSNAME).getTokenValue()
+ "\""
+ " outside of "
+ (node.is(PuppetGrammar.CLASSDEF) ? "class " : "define ")
+ "\""
+ node.getFirstChild(PuppetGrammar.CLASSNAME).getTokenValue()
+ "\""
+ ".";
addIssue(nestedNode, this, message);
}
}
@Test
public void getSecondDeclarationTest() {
AstNodeXPathQuery<AstNode> xpath1 =
AstNodeXPathQuery.create("/COMPILATION_UNIT/DEFINITION[@tokenLine=4]");
AstNodeXPathQuery<AstNode> xpath2 = AstNodeXPathQuery.create("/COMPILATION_UNIT/DEFINITION[2]");
AstNode declarationAtLineFour = fileNode.getChildren().get(1);
assertThat(declarationAtLineFour.is(MiniCGrammar.DEFINITION)).isTrue();
assertThat(declarationAtLineFour.getTokenLine()).isEqualTo(4);
assertThat(xpath1.selectSingleNode(fileNode)).isEqualTo(declarationAtLineFour);
assertThat(xpath1.selectSingleNode(fileNode)).isEqualTo(xpath2.selectSingleNode(fileNode));
}
private void checkAssignment(AstNode astNode) {
AstNode memberExpr = astNode.getFirstChild();
AstNode variable = memberExpr.getFirstChild();
if (memberExpr.getNumberOfChildren() == 1 && variable.is(PHPGrammar.VARIABLE_WITHOUT_OBJECTS)) {
String varName = variable.getTokenOriginalValue();
if (memberExpr.getTokens().size() == 1
&& !CheckUtils.isSuperGlobal(varName)
&& !globalVariableNames.contains(varName)) {
getContext().createLineViolation(this, "Move this variable into a class.", astNode);
globalVariableNames.add(varName);
}
}
}
@Test
public void test_firstAncestor_by_types() {
AstNodeType type1 = mock(AstNodeType.class);
AstNodeType type2 = mock(AstNodeType.class);
assertThat((Object) select.firstAncestor(type1, type2)).isSameAs(AstSelectFactory.empty());
AstNode parent = mock(AstNode.class);
when(node.getParent()).thenReturn(parent);
AstNode ancestor = mock(AstNode.class);
when(ancestor.is(type1, type2)).thenReturn(true);
when(parent.getParent()).thenReturn(ancestor);
assertThat((Object) select.firstAncestor(type1, type2)).isInstanceOf(SingleAstSelect.class);
assertThat(select.firstAncestor(type1, type2)).containsOnly(ancestor);
}
@Override
public void visitNode(AstNode astNode) {
if (astNode.is(FlexGrammar.UNARY_EXPR)
&& "not".equals(astNode.getFirstChild().getTokenValue())) {
getContext()
.createLineViolation(
this, "Operator 'not' not available in ActionScript 3.0", astNode.getFirstChild());
} else {
String operator = getValue(astNode);
if (deprecatedOperators.contains(operator)) {
getContext()
.createLineViolation(
this, "Operator '" + operator + "' not available in ActionScript 3.0", astNode);
}
}
}
@Override
public void visitNode(AstNode astNode) {
if (astNode.is(FlexGrammar.CLASS_DEF)) {
isInClass = true;
String className = Clazz.getName(astNode);
classStack.push(new ClassState(className));
} else if (isConstructor(astNode)) {
classStack.peek().isInConstructor = true;
} else if (isCallToDispatchEventInConstructor(astNode)) {
getContext()
.createLineViolation(
this,
"Remove this event dispatch from the \"{0}\" constructor",
astNode,
classStack.peek().className);
}
}
@Override
protected void retrievePrivateClassMember(AstNode classDeclaration) {
for (AstNode classStmt : classDeclaration.getChildren(PHPGrammar.CLASS_STATEMENT)) {
AstNode stmtChild = classStmt.getFirstChild();
if (stmtChild.is(PHPGrammar.CLASS_VARIABLE_DECLARATION)) {
List<AstNode> modifiers =
stmtChild
.getFirstChild(PHPGrammar.VARIABLE_MODIFIERS)
.getChildren(PHPGrammar.MEMBER_MODIFIER);
if (isPrivate(modifiers)) {
for (AstNode varDeclaration : stmtChild.getChildren(PHPGrammar.VARIABLE_DECLARATION)) {
AstNode varIdentifier = varDeclaration.getFirstChild(PHPGrammar.VAR_IDENTIFIER);
addPrivateMember(getCalledName(varIdentifier, modifiers), varIdentifier);
}
}
}
}
}
private boolean isElseIf(AstNode astNode) {
AstNode parentPreviousSibling = astNode.getParent().getPreviousSibling();
return parentPreviousSibling != null && parentPreviousSibling.is(PHPKeyword.ELSE);
}
private boolean isConstructor(AstNode astNode) {
return isInClass
&& astNode.is(FlexGrammar.FUNCTION_DEF)
&& Function.isConstructor(astNode, classStack.peek().className);
}
private boolean isCallToDispatchEventInConstructor(AstNode astNode) {
return isInClass
&& classStack.peek().isInConstructor
&& astNode.is(FlexGrammar.PRIMARY_EXPR)
&& isCallToDispatchEvent(astNode);
}
@Override
public void leaveNode(AstNode astNode) {
if (astNode.is(FunctionUtils.functions())) {
scopes.pop();
}
}