/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.adobe.ac.pmd.rules.core;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.logging.Logger;
import com.adobe.ac.pmd.IFlexViolation;
import com.adobe.ac.pmd.nodes.IAttribute;
import com.adobe.ac.pmd.nodes.IClass;
import com.adobe.ac.pmd.nodes.IConstant;
import com.adobe.ac.pmd.nodes.IFunction;
import com.adobe.ac.pmd.nodes.INode;
import com.adobe.ac.pmd.nodes.IPackage;
import com.adobe.ac.pmd.parser.IParserNode;
import com.adobe.ac.pmd.parser.NodeKind;
import com.adobe.ac.utils.StackTraceUtils;
/**
* Abstract class for AST-based rule Extends this class if your rule is only
* detectable in an AS script block, which can be converted into an Abstract
* Syntax Tree. Then you will be able to either use the visitor pattern, or to
* iterate from the package node, in order to find your violation(s).
*
* @author xagnetti
*/
public abstract class AbstractAstFlexRule extends AbstractFlexRule implements IFlexAstRule
{
/**
*
*/
protected enum FunctionType
{
GETTER, NORMAL, SETTER
}
/**
*
*/
protected enum VariableOrConstant
{
CONSTANT, VARIABLE
}
/**
*
*/
protected enum VariableScope
{
IN_CLASS, IN_FUNCTION
}
private interface ExpressionVisitor
{
void visitExpression( final IParserNode ast );
}
private static final Logger LOGGER = Logger.getLogger( AbstractAstFlexRule.class.getName() );
/**
* @param functionNode
* @return
*/
/**
* @param functionNode
* @return
*/
protected static IParserNode getNameFromFunctionDeclaration( final IParserNode functionNode )
{
IParserNode nameChild = null;
for ( final IParserNode child : functionNode.getChildren() )
{
if ( child.is( NodeKind.NAME ) )
{
nameChild = child;
break;
}
}
return nameChild;
}
/**
* @param fieldNode
* @return
*/
protected static IParserNode getTypeFromFieldDeclaration( final IParserNode fieldNode )
{
return fieldNode.getChild( 0 ).getChild( 1 );
}
private final List< IFlexViolation > violations;
/**
*
*/
public AbstractAstFlexRule()
{
super();
violations = new ArrayList< IFlexViolation >();
}
/*
* (non-Javadoc)
* @see
* com.adobe.ac.pmd.rules.core.AbstractFlexRule#isConcernedByTheCurrentFile
* ()
*/
@Override
public boolean isConcernedByTheCurrentFile()
{
return true;
}
/**
* @param function
* @return the added violation positioned on the given function node
*/
protected final IFlexViolation addViolation( final IFunction function )
{
final IParserNode name = getNameFromFunctionDeclaration( function.getInternalNode() );
return addViolation( name,
name,
name.getStringValue() );
}
/**
* @param function
* @param messageToReplace
* @return
*/
protected final IFlexViolation addViolation( final IFunction function,
final String messageToReplace )
{
final IParserNode name = getNameFromFunctionDeclaration( function.getInternalNode() );
return addViolation( name,
name,
messageToReplace );
}
/**
* @param violatingNode
* @return the added violation replacing the threshold value in the message
* if any.
*/
protected final IFlexViolation addViolation( final INode violatingNode )
{
return addViolation( violatingNode.getInternalNode(),
violatingNode.getInternalNode() );
}
/**
* @param violatingNode
* @return the added violation replacing the threshold value in the message
* if any.
*/
protected final IFlexViolation addViolation( final INode violatingNode,
final String... messageToReplace )
{
return addViolation( violatingNode.getInternalNode(),
violatingNode.getInternalNode(),
messageToReplace );
}
/**
* @param violatingNode
* @param endNode
* @return the added violation replacing the threshold value in the message
* if any.
*/
protected final IFlexViolation addViolation( final IParserNode violatingNode )
{
return addViolation( violatingNode,
violatingNode );
}
/**
* @param beginningNode
* @param endNode
* @param messageToReplace
* @return the add violation replacing the {0} token by the specified message
*/
protected final IFlexViolation addViolation( final IParserNode beginningNode,
final IParserNode endNode,
final String... messageToReplace )
{
if ( isAlreadyViolationAdded( beginningNode ) )
{
return null;
}
final IFlexViolation violation = addViolation( ViolationPosition.create( beginningNode.getLine(),
endNode.getLine(),
beginningNode.getColumn(),
endNode.getColumn() ) );
for ( int i = 0; i < messageToReplace.length; i++ )
{
violation.replacePlaceholderInMessage( messageToReplace[ i ],
i );
}
return violation;
}
/**
* @param violatingNode
* @param endNode
* @param messageToReplace
* @return the add violation replacing the {0} token by the specified message
*/
protected final IFlexViolation addViolation( final IParserNode violatingNode,
final String... messageToReplace )
{
return addViolation( violatingNode,
violatingNode,
messageToReplace );
}
/**
* @param violationPosition
* @return the added violation positioned at the given position
*/
protected final IFlexViolation addViolation( final ViolationPosition violationPosition )
{
return addViolation( violations,
violationPosition );
}
/**
* find the violations list from the given class node
*
* @param classNode
*/
protected void findViolations( final IClass classNode )
{
findViolationsFromAttributes( classNode.getAttributes() );
findViolationsFromConstants( classNode.getConstants() );
findViolations( classNode.getFunctions() );
if ( classNode.getConstructor() != null )
{
findViolationsFromConstructor( classNode.getConstructor() );
}
}
/**
* find violations in every function in a class
*
* @param function
*/
protected void findViolations( final IFunction function )
{
}
/**
* Override this method if you need to find violations from the package ( or
* any subsequent node like class or function)
*
* @param packageNode
*/
protected void findViolations( final IPackage packageNode )
{
final IClass classNode = packageNode.getClassNode();
if ( classNode != null )
{
findViolations( classNode );
}
}
/**
* find the violations list from the given functions list
*
* @param functions
*/
protected void findViolations( final List< IFunction > functions )
{
for ( final IFunction function : functions )
{
findViolations( function );
}
}
/**
* find the violations list from the given class variables list
*
* @param variables
*/
protected void findViolationsFromAttributes( final List< IAttribute > variables )
{
}
/**
* find the violations list from the given class constants list
*
* @param constants
*/
protected void findViolationsFromConstants( final List< IConstant > constants )
{
}
/**
* find the violations list from the given class constructor node
*
* @param constructor
*/
protected void findViolationsFromConstructor( final IFunction constructor )
{
}
/**
* Find violations in the current file
*/
@Override
protected final List< IFlexViolation > findViolationsInCurrentFile()
{
try
{
if ( getCurrentPackageNode() != null )
{
visitCompilationUnit( getCurrentPackageNode().getInternalNode() );
findViolations( getCurrentPackageNode() );
}
}
catch ( final Exception e )
{
LOGGER.warning( "on "
+ getCurrentFile().getFilePath() );
LOGGER.warning( StackTraceUtils.print( e ) );
}
final List< IFlexViolation > copy = new ArrayList< IFlexViolation >( violations );
violations.clear();
return copy;
}
/**
* @param statementNode
*/
protected void visitAs( final IParserNode statementNode )
{
}
/**
* @param catchNode
*/
protected void visitCatch( final IParserNode catchNode )
{
visitNameTypeInit( catchNode.getChild( 0 ) );
visitBlock( catchNode.getChild( 1 ) );
}
/**
* @param classNode
*/
protected void visitClass( final IParserNode classNode )
{
IParserNode content = null;
for ( final IParserNode node : classNode.getChildren() )
{
if ( node.is( NodeKind.CONTENT ) )
{
content = node;
break;
}
}
visitClassContent( content );
}
/**
* Visit the condition of a if, while, ...
*
* @param condition
*/
protected void visitCondition( final IParserNode condition )
{
visitExpression( condition );
}
/**
* @param doNode
*/
protected void visitDo( final IParserNode doNode )
{
visitBlock( doNode.getChild( 0 ) );
visitCondition( doNode.getChild( 1 ) );
}
/**
* @param ifNode
*/
protected void visitElse( final IParserNode ifNode )
{
visitBlock( ifNode.getChild( 2 ) );
}
/**
* Visit empty statement
*
* @param statementNode
*/
protected void visitEmptyStatetement( final IParserNode statementNode )
{
}
/**
* @param finallyNode
*/
protected void visitFinally( final IParserNode finallyNode )
{
if ( isNodeNavigable( finallyNode ) )
{
visitBlock( finallyNode.getChild( 0 ) );
}
}
/**
* @param forNode
*/
protected void visitFor( final IParserNode forNode )
{
visitBlock( forNode.getChild( 3 ) );
}
/**
* @param foreachNode
*/
protected void visitForEach( final IParserNode foreachNode )
{
visitBlock( foreachNode.getChild( 2 ) );
}
/**
* @param functionNode
* @param type
*/
protected void visitFunction( final IParserNode functionNode,
final FunctionType type )
{
final Iterator< IParserNode > iterator = functionNode.getChildren().iterator();
IParserNode currentNode = iterator.next();
while ( currentNode.is( NodeKind.META_LIST )
|| currentNode.is( NodeKind.MOD_LIST ) || currentNode.is( NodeKind.AS_DOC )
|| currentNode.is( NodeKind.MULTI_LINE_COMMENT ) )
{
currentNode = iterator.next();
}
currentNode = iterator.next();
visitParameters( currentNode );
currentNode = iterator.next();
visitFunctionReturnType( currentNode );
try
{
// Intrinsic functions in AS2
currentNode = iterator.next();
visitFunctionBody( currentNode );
}
catch ( final NoSuchElementException e )
{
}
}
/**
* @param functionReturnTypeNode
*/
protected void visitFunctionReturnType( final IParserNode functionReturnTypeNode )
{
visitBlock( functionReturnTypeNode );
}
/**
* @param ifNode
*/
protected void visitIf( final IParserNode ifNode )
{
visitCondition( ifNode.getChild( 0 ) );
visitThen( ifNode );
if ( ifNode.numChildren() == 3 )
{
visitElse( ifNode );
}
}
/**
* @param interfaceNode
*/
protected void visitInterface( final IParserNode interfaceNode )
{
}
/**
* @param methodCallNode
*/
protected void visitMethodCall( final IParserNode methodCallNode )
{
final Iterator< IParserNode > iterator = methodCallNode.getChildren().iterator();
visitExpression( iterator.next() );
do
{
visitExpressionList( iterator.next() );
}
while ( iterator.hasNext() );
}
/**
* @param newExpression
*/
protected void visitNewExpression( final IParserNode newExpression )
{
visitExpression( newExpression.getChild( 0 ) );
visitExpressionList( newExpression.getChild( 1 ) );
}
protected void visitOperator( final IParserNode statementNode )
{
}
/**
* @param functionParametersNode
*/
protected void visitParameters( final IParserNode functionParametersNode )
{
if ( isNodeNavigable( functionParametersNode ) )
{
for ( final IParserNode node2 : functionParametersNode.getChildren() )
{
visitNameTypeInit( node2.getChild( 0 ) );
}
}
}
protected void visitRelationalExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.RELATION,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitShiftExpression( ast );
}
} );
}
/**
* @param ast
*/
protected void visitReturn( final IParserNode ast )
{
if ( isNodeNavigable( ast ) )
{
visitExpression( ast.getChild( 0 ) );
}
}
/**
* @param statementNode
*/
protected void visitStatement( final IParserNode statementNode )
{
switch ( statementNode.getId() )
{
case OP:
visitOperator( statementNode );
break;
case AS:
visitAs( statementNode );
break;
case RETURN:
visitReturn( statementNode );
break;
case IF:
visitIf( statementNode );
break;
case FOR:
visitFor( statementNode );
break;
case FOREACH:
visitForEach( statementNode );
break;
case DO:
visitDo( statementNode );
break;
case WHILE:
visitWhile( statementNode );
break;
case SWITCH:
visitSwitch( statementNode );
break;
case TRY:
visitTry( statementNode );
break;
case CATCH:
visitCatch( statementNode );
break;
case FINALLY:
visitFinally( statementNode );
break;
case STMT_EMPTY:
visitEmptyStatetement( statementNode );
break;
case LEFT_CURLY_BRACKET:
visitBlock( statementNode );
break;
default:
visitExpressionList( statementNode );
}
}
/**
* @param switchNode
*/
protected void visitSwitch( final IParserNode switchNode )
{
final Iterator< IParserNode > iterator = switchNode.getChildren().iterator();
visitExpression( iterator.next() );
final IParserNode cases = iterator.next();
for ( final IParserNode caseNode : cases.getChildren() )
{
final IParserNode child = caseNode.getChild( 0 );
if ( child.is( NodeKind.DEFAULT ) )
{
visitSwitchDefaultCase( caseNode.getChild( 1 ) );
}
else
{
visitSwitchCase( caseNode.getChild( 1 ) );
visitExpression( child );
}
}
}
/**
* @param switchCaseNode
*/
protected void visitSwitchCase( final IParserNode switchCaseNode )
{
visitBlock( switchCaseNode );
}
/**
* @param defaultCaseNode
*/
protected void visitSwitchDefaultCase( final IParserNode defaultCaseNode )
{
visitBlock( defaultCaseNode );
}
/**
* @param ifNode
*/
protected void visitThen( final IParserNode ifNode )
{
visitBlock( ifNode.getChild( 1 ) );
}
/**
* @param ast
*/
protected void visitTry( final IParserNode ast )
{
visitBlock( ast.getChild( 0 ) );
}
/**
* @param node
*/
protected void visitVariableInitialization( final IParserNode node )
{
visitExpression( node );
}
/**
* @param variableNode
* @param varOrConst
* @param scope
*/
protected void visitVarOrConstList( final IParserNode variableNode,
final VariableOrConstant varOrConst,
final VariableScope scope )
{
final Iterator< IParserNode > iterator = variableNode.getChildren().iterator();
IParserNode node = iterator.next();
while ( node.is( NodeKind.META_LIST )
|| node.is( NodeKind.MOD_LIST ) )
{
node = iterator.next();
}
while ( node != null )
{
visitNameTypeInit( node );
node = iterator.hasNext() ? iterator.next()
: null;
}
}
/**
* @param whileNode
*/
protected void visitWhile( final IParserNode whileNode )
{
visitCondition( whileNode.getChild( 0 ) );
visitBlock( whileNode.getChild( 1 ) );
}
private boolean isAlreadyViolationAdded( final IParserNode nodeToBeAdded )
{
for ( final IFlexViolation violation : violations )
{
if ( violation.getBeginLine() == nodeToBeAdded.getLine()
&& violation.getBeginColumn() == nodeToBeAdded.getColumn() )
{
return true;
}
}
return false;
}
private boolean isNodeNavigable( final IParserNode node )
{
return node != null
&& node.numChildren() != 0;
}
private void visitAdditiveExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.ADD,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitMultiplicativeExpression( ast );
}
} );
}
private void visitAndExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.AND,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitBitwiseOrExpression( ast );
}
} );
}
private void visitArrayAccessor( final IParserNode ast )
{
final Iterator< IParserNode > iterator = ast.getChildren().iterator();
visitExpression( iterator.next() );
do
{
visitExpression( iterator.next() );
}
while ( iterator.hasNext() );
}
private void visitBitwiseAndExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.B_AND,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitEqualityExpression( ast );
}
} );
}
private void visitBitwiseOrExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.B_OR,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitBitwiseXorExpression( ast );
}
} );
}
private void visitBitwiseXorExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.B_XOR,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitBitwiseAndExpression( ast );
}
} );
}
private void visitBlock( final IParserNode ast )
{
if ( isNodeNavigable( ast ) )
{
for ( final IParserNode node : ast.getChildren() )
{
visitStatement( node );
}
}
else if ( ast != null )
{
visitStatement( ast );
}
}
private void visitClassContent( final IParserNode ast )
{
if ( isNodeNavigable( ast ) )
{
for ( final IParserNode node : ast.getChildren() )
{
if ( node.is( NodeKind.VAR_LIST ) )
{
visitVarOrConstList( node,
VariableOrConstant.VARIABLE,
VariableScope.IN_CLASS );
}
else if ( node.is( NodeKind.CONST_LIST ) )
{
visitVarOrConstList( node,
VariableOrConstant.CONSTANT,
VariableScope.IN_CLASS );
}
}
for ( final IParserNode node : ast.getChildren() )
{
if ( node.is( NodeKind.FUNCTION ) )
{
visitFunction( node,
FunctionType.NORMAL );
}
else if ( node.is( NodeKind.SET ) )
{
visitFunction( node,
FunctionType.SETTER );
}
else if ( node.is( NodeKind.GET ) )
{
visitFunction( node,
FunctionType.GETTER );
}
}
}
}
private void visitCompilationUnit( final IParserNode ast )
{
for ( final IParserNode node : ast.getChildren() )
{
if ( node.is( NodeKind.PACKAGE )
&& node.numChildren() >= 2 )
{
visitPackageContent( node.getChild( 1 ) );
}
if ( !node.is( NodeKind.PACKAGE )
&& node.numChildren() > 0 )
{
visitPackageContent( node );
}
}
}
private void visitConditionalExpression( final IParserNode ast )
{
if ( ast != null )
{
if ( ast.is( NodeKind.CONDITIONAL ) )
{
final Iterator< IParserNode > iterator = ast.getChildren().iterator();
final IParserNode node = iterator.next();
visitOrExpression( node );
while ( iterator.hasNext() )
{
visitExpression( iterator.next() );
visitExpression( iterator.next() );
}
}
else
{
visitOrExpression( ast );
}
}
}
private void visitEqualityExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.EQUALITY,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitRelationalExpression( ast );
}
} );
}
private void visitExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.ASSIGN,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitConditionalExpression( ast );
}
} );
}
private void visitExpression( final IParserNode ast,
final NodeKind kind,
final ExpressionVisitor visitor )
{
if ( ast.is( kind ) )
{
final Iterator< IParserNode > iterator = ast.getChildren().iterator();
final IParserNode node = iterator.next();
visitor.visitExpression( node );
while ( iterator.hasNext() )
{
iterator.next();
visitor.visitExpression( iterator.next() );
}
}
else
{
visitor.visitExpression( ast );
}
}
private void visitExpressionList( final IParserNode ast )
{
if ( isNodeNavigable( ast ) )
{
for ( final IParserNode node : ast.getChildren() )
{
visitExpression( node );
}
}
}
private void visitFunctionBody( final IParserNode node )
{
visitBlock( node );
}
private void visitMultiplicativeExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.MULTIPLICATION,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitUnaryExpression( ast );
}
} );
}
private void visitNameTypeInit( final IParserNode ast )
{
if ( ast != null
&& ast.numChildren() != 0 )
{
final Iterator< IParserNode > iterator = ast.getChildren().iterator();
IParserNode node;
iterator.next();
iterator.next();
if ( iterator.hasNext() )
{
node = iterator.next();
visitVariableInitialization( node );
}
}
}
private void visitObjectInitialization( final IParserNode ast )
{
if ( isNodeNavigable( ast ) )
{
for ( final IParserNode node : ast.getChildren() )
{
visitExpression( node.getChild( 1 ) );
}
}
}
private void visitOrExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.OR,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitAndExpression( ast );
}
} );
}
private void visitPackageContent( final IParserNode ast )
{
if ( isNodeNavigable( ast ) )
{
for ( final IParserNode node : ast.getChildren() )
{
if ( node.is( NodeKind.CLASS ) )
{
visitClass( node );
}
else if ( node.is( NodeKind.INTERFACE ) )
{
visitInterface( node );
}
}
}
}
private void visitPrimaryExpression( final IParserNode ast )
{
if ( ast.is( NodeKind.NEW ) )
{
visitNewExpression( ast );
}
else if ( ast.numChildren() != 0
&& ast.is( NodeKind.ARRAY ) )
{
visitExpressionList( ast );
}
else if ( ast.is( NodeKind.OBJECT ) )
{
visitObjectInitialization( ast );
}
else if ( ast.is( NodeKind.E4X_ATTR ) )
{
final IParserNode node = ast.getChild( 0 );
if ( !node.is( NodeKind.NAME )
&& !node.is( NodeKind.STAR ) )
{
visitExpression( node );
}
}
else
{
visitExpressionList( ast );
}
}
private void visitShiftExpression( final IParserNode ast )
{
visitExpression( ast,
NodeKind.SHIFT,
new ExpressionVisitor()
{
public void visitExpression( final IParserNode ast )
{
visitAdditiveExpression( ast );
}
} );
}
private void visitUnaryExpression( final IParserNode ast )
{
switch ( ast.getId() )
{
case PRE_INC:
case PRE_DEC:
case MINUS:
case PLUS:
visitUnaryExpression( ast.getChild( 0 ) );
break;
default:
visitUnaryExpressionNotPlusMinus( ast );
}
}
private void visitUnaryExpressionNotPlusMinus( final IParserNode ast )
{
switch ( ast.getId() )
{
case DELETE:
case VOID:
case TYPEOF:
case NOT:
case B_NOT:
visitExpression( ast.getChild( 0 ) );
break;
default:
visitUnaryPostfixExpression( ast );
}
}
private void visitUnaryPostfixExpression( final IParserNode ast )
{
switch ( ast.getId() )
{
case ARRAY_ACCESSOR:
visitArrayAccessor( ast );
break;
case DOT:
case E4X_FILTER:
visitExpression( ast.getChild( 0 ) );
visitExpression( ast.getChild( 1 ) );
break;
case POST_INC:
case POST_DEC:
visitPrimaryExpression( ast.getChild( 0 ) );
break;
case CALL:
visitMethodCall( ast );
break;
case E4X_STAR:
visitExpression( ast.getChild( 0 ) );
break;
default:
visitPrimaryExpression( ast );
break;
}
}
}