Coverage Report

Coverage Report - com.puppycrawl.tools.checkstyle.checks.indentation.ExpressionHandler

Classes in this File

Line Coverage

Branch Coverage

Complexity

ExpressionHandler

99%

130/131

93%

86/92

2.613

 ////////////////////////////////////////////////////////////////////////////////
 // checkstyle: Checks Java source code for adherence to a set of rules.
 // Copyright (C) 2001-2014  Oliver Burn
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation; either
 // version 2.1 of the License, or (at your option) any later version.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 ////////////////////////////////////////////////////////////////////////////////
 package com.puppycrawl.tools.checkstyle.checks.indentation;
 
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 import com.puppycrawl.tools.checkstyle.api.TokenTypes;
 import com.puppycrawl.tools.checkstyle.api.Utils;
 import java.util.Arrays;
 
 /**
  * Abstract base class for all handlers.
  *
  * @author jrichard
  */
 public abstract class ExpressionHandler
 {
     /**
      * The instance of <code>IndentationCheck</code> using this handler.
      */
     private final IndentationCheck mIndentCheck;
 
     /** the AST which is handled by this handler */
     private final DetailAST mMainAst;
 
     /** name used during output to user */
     private final String mTypeName;
 
     /** containing AST handler */
     private final ExpressionHandler mParent;
 
     /** indentation amount for this handler */
     private IndentLevel mLevel;
 
     /**
      * Construct an instance of this handler with the given indentation check,
      * name, abstract syntax tree, and parent handler.
      *
      * @param aIndentCheck   the indentation check
      * @param aTypeName      the name of the handler
      * @param aExpr          the abstract syntax tree
      * @param aParent        the parent handler
      */
     public ExpressionHandler(IndentationCheck aIndentCheck,
             String aTypeName, DetailAST aExpr, ExpressionHandler aParent)
     {
         mIndentCheck = aIndentCheck;
         mTypeName = aTypeName;
         mMainAst = aExpr;
         mParent = aParent;
     }
 
     /**
      * Get the indentation amount for this handler. For performance reasons,
      * this value is cached. The first time this method is called, the
      * indentation amount is computed and stored. On further calls, the stored
      * value is returned.
      *
      * @return the expected indentation amount
      */
     public final IndentLevel getLevel()
     {
         if (mLevel == null) {
             mLevel = getLevelImpl();
         }
         return mLevel;
     }
 
     /**
      * Compute the indentation amount for this handler.
      *
      * @return the expected indentation amount
      */
     protected IndentLevel getLevelImpl()
     {
         return mParent.suggestedChildLevel(this);
     }
 
     /**
      * Indentation level suggested for a child element. Children don't have
      * to respect this, but most do.
      *
      * @param aChild  child AST (so suggestion level can differ based on child
      *                  type)
      *
      * @return suggested indentation for child
      */
     public IndentLevel suggestedChildLevel(ExpressionHandler aChild)
     {
         return new IndentLevel(getLevel(), getBasicOffset());
     }
 
     /**
      * Log an indentation error.
      *
      * @param aAst           the expression that caused the error
      * @param aSubtypeName   the type of the expression
      * @param aActualLevel    the actual indent level of the expression
      */
     protected final void logError(DetailAST aAst, String aSubtypeName,
                                   int aActualLevel)
     {
         logError(aAst, aSubtypeName, aActualLevel, getLevel());
     }
 
     /**
      * Log an indentation error.
      *
      * @param aAst           the expression that caused the error
      * @param aSubtypeName   the type of the expression
      * @param aActualLevel   the actual indent level of the expression
      * @param aExpectedLevel the expected indent level of the expression
      */
     protected final void logError(DetailAST aAst, String aSubtypeName,
                                   int aActualLevel, IndentLevel aExpectedLevel)
     {
         final String typeStr =
             ("".equals(aSubtypeName) ? "" : (" " + aSubtypeName));
         mIndentCheck.indentationLog(aAst.getLineNo(), "indentation.error",
                 mTypeName + typeStr, aActualLevel, aExpectedLevel);
     }
 
     /**
      * Log child indentation error.
      *
      * @param aLine           the expression that caused the error
      * @param aActualLevel   the actual indent level of the expression
      * @param aExpectedLevel the expected indent level of the expression
      */
     private void logChildError(int aLine,
                                int aActualLevel,
                                IndentLevel aExpectedLevel)
     {
         mIndentCheck.indentationLog(aLine, "indentation.child.error",
                 mTypeName, aActualLevel, aExpectedLevel);
     }
 
     /**
      * Determines if the given expression is at the start of a line.
      *
      * @param aAst   the expression to check
      *
      * @return true if it is, false otherwise
      */
     protected final boolean startsLine(DetailAST aAst)
     {
         return getLineStart(aAst) == expandedTabsColumnNo(aAst);
     }
 
     /**
      * Determines if two expressions are on the same line.
      *
      * @param aAst1   the first expression
      * @param aAst2   the second expression
      *
      * @return true if they are, false otherwise
      */
     static boolean areOnSameLine(DetailAST aAst1, DetailAST aAst2)
     {
         return (aAst1 != null) && (aAst2 != null)
             && (aAst1.getLineNo() == aAst2.getLineNo());
     }
 
     /**
      * Searchs in given sub-tree (including given node) for the token
      * which represents first symbol for this sub-tree in file.
      * @param aAST a root of sub-tree in which the search shoul be performed.
      * @return a token which occurs first in the file.
      */
     static DetailAST getFirstToken(DetailAST aAST)
     {
         DetailAST first = aAST;
         DetailAST child = aAST.getFirstChild();
 
         while (child != null) {
             final DetailAST toTest = getFirstToken(child);
             if ((toTest.getLineNo() < first.getLineNo())
                 || ((toTest.getLineNo() == first.getLineNo())
                     && (toTest.getColumnNo() < first.getColumnNo())))
             {
                 first = toTest;
             }
             child = child.getNextSibling();
         }
 
         return first;
     }
 
     /**
      * Get the start of the line for the given expression.
      *
      * @param aAst   the expression to find the start of the line for
      *
      * @return the start of the line for the given expression
      */
     protected final int getLineStart(DetailAST aAst)
     {
         final String line = mIndentCheck.getLines()[aAst.getLineNo() - 1];
         return getLineStart(line);
     }
 
     // TODO: this whole checking of consecuitive/expression line indents is
     // smelling pretty bad... and is in serious need of pruning.  But, I
     // want to finish the invalid tests before I start messing around with
     // it.
 
     /**
      * Check the indentation of consecutive lines for the expression we are
      * handling.
      *
      * @param aStartLine     the first line to check
      * @param aEndLine       the last line to check
      * @param aIndentLevel   the required indent level
      */
     protected final void checkLinesIndent(int aStartLine, int aEndLine,
         IndentLevel aIndentLevel)
     {
         // check first line
         checkSingleLine(aStartLine, aIndentLevel);
 
         // check following lines
         final IndentLevel offsetLevel =
             new IndentLevel(aIndentLevel, getBasicOffset());
         for (int i = aStartLine + 1; i <= aEndLine; i++) {
             checkSingleLine(i, offsetLevel);
         }
     }
 
     /**
      * @return true if indentation should be increased after
      *              fisrt line in checkLinesIndent()
      *         false otherwise
      */
     protected boolean shouldIncreaseIndent()
     {
         return true;
     }
 
     /**
      * Check the indentation for a set of lines.
      *
      * @param aLines              the set of lines to check
      * @param aIndentLevel        the indentation level
      * @param aFirstLineMatches   whether or not the first line has to match
      * @param aFirstLine          firstline of whole expression
      */
     private void checkLinesIndent(LineSet aLines,
                                   IndentLevel aIndentLevel,
                                   boolean aFirstLineMatches,
                                   int aFirstLine)
     {
         if (aLines.isEmpty()) {
             return;
         }
 
         // check first line
         final int startLine = aLines.firstLine();
         final int endLine = aLines.lastLine();
         final int startCol = aLines.firstLineCol();
 
         final int realStartCol =
             getLineStart(mIndentCheck.getLines()[startLine - 1]);
 
         if (realStartCol == startCol) {
             checkSingleLine(startLine, startCol, aIndentLevel,
                 aFirstLineMatches);
         }
 
         // if first line starts the line, following lines are indented
         // one level; but if the first line of this expression is
         // nested with the previous expression (which is assumed if it
         // doesn't start the line) then don't indent more, the first
         // indentation is absorbed by the nesting
 
         // TODO: shouldIncreaseIndent() is a hack, should be removed
         //       after complete rewriting of checkExpressionSubtree()
 
         IndentLevel theLevel = aIndentLevel;
         if (aFirstLineMatches
             || ((aFirstLine > mMainAst.getLineNo()) && shouldIncreaseIndent()))
         {
             theLevel = new IndentLevel(aIndentLevel, getBasicOffset());
         }
 
         // check following lines
         for (int i = startLine + 1; i <= endLine; i++) {
             final Integer col = aLines.getStartColumn(i);
             // startCol could be null if this line didn't have an
             // expression that was required to be checked (it could be
             // checked by a child expression)
 
             if (col != null) {
                 checkSingleLine(i, col.intValue(), theLevel, false);
             }
         }
     }
 
     /**
      * Check the indent level for a single line.
      *
      * @param aLineNum       the line number to check
      * @param aIndentLevel   the required indent level
      */
     private void checkSingleLine(int aLineNum, IndentLevel aIndentLevel)
     {
         final String line = mIndentCheck.getLines()[aLineNum - 1];
         final int start = getLineStart(line);
         if (aIndentLevel.gt(start)) {
             logChildError(aLineNum, start, aIndentLevel);
         }
     }
 
     /**
      * Check the indentation for a single line.
      *
      * @param aLineNum       the number of the line to check
      * @param aColNum        the column number we are starting at
      * @param aIndentLevel   the indentation level
      * @param aMustMatch     whether or not the indentation level must match
      */
 
     private void checkSingleLine(int aLineNum, int aColNum,
         IndentLevel aIndentLevel, boolean aMustMatch)
     {
         final String line = mIndentCheck.getLines()[aLineNum - 1];
         final int start = getLineStart(line);
         // if must match is set, it is an error if the line start is not
         // at the correct indention level; otherwise, it is an only an
         // error if this statement starts the line and it is less than
         // the correct indentation level
         if (aMustMatch ? !aIndentLevel.accept(start)
             : (aColNum == start) && aIndentLevel.gt(start))
         {
             logChildError(aLineNum, start, aIndentLevel);
         }
     }
 
     /**
      * Get the start of the specified line.
      *
      * @param aLine   the specified line number
      *
      * @return the start of the specified line
      */
     protected final int getLineStart(String aLine)
     {
         for (int start = 0; start < aLine.length(); start++) {
             final char c = aLine.charAt(start);
 
             if (!Character.isWhitespace(c)) {
                 return Utils.lengthExpandedTabs(
                     aLine, start, mIndentCheck.getIndentationTabWidth());
             }
         }
         return 0;
     }
 
     // TODO: allowNesting either shouldn't be allowed with
     //  firstLineMatches, or I should change the firstLineMatches logic
     //  so it doesn't match if the first line is nested
 
     /**
      * Check the indent level of the children of the specified parent
      * expression.
      *
      * @param aParent             the parent whose children we are checking
      * @param aTokenTypes         the token types to check
      * @param aStartLevel         the starting indent level
      * @param aFirstLineMatches   whether or not the first line needs to match
      * @param aAllowNesting       whether or not nested children are allowed
      */
     protected final void checkChildren(DetailAST aParent,
                                        int[] aTokenTypes,
                                        IndentLevel aStartLevel,
                                        boolean aFirstLineMatches,
                                        boolean aAllowNesting)
     {
         Arrays.sort(aTokenTypes);
         for (DetailAST child = aParent.getFirstChild();
                 child != null;
                 child = child.getNextSibling())
         {
             if (Arrays.binarySearch(aTokenTypes, child.getType()) >= 0) {
                 checkExpressionSubtree(child, aStartLevel,
                     aFirstLineMatches, aAllowNesting);
             }
         }
     }
 
     /**
      * Check the indentation level for an expression subtree.
      *
      * @param aTree               the expression subtree to check
      * @param aLevel              the indentation level
      * @param aFirstLineMatches   whether or not the first line has to match
      * @param aAllowNesting       whether or not subtree nesting is allowed
      */
     protected final void checkExpressionSubtree(
         DetailAST aTree,
         IndentLevel aLevel,
         boolean aFirstLineMatches,
         boolean aAllowNesting
     )
     {
         final LineSet subtreeLines = new LineSet();
         final int firstLine = getFirstLine(Integer.MAX_VALUE, aTree);
         if (aFirstLineMatches && !aAllowNesting) {
             subtreeLines.addLineAndCol(firstLine,
                 getLineStart(mIndentCheck.getLines()[firstLine - 1]));
         }
         findSubtreeLines(subtreeLines, aTree, aAllowNesting);
 
         checkLinesIndent(subtreeLines, aLevel, aFirstLineMatches, firstLine);
     }
 
     /**
      * Get the first line for a given expression.
      *
      * @param aStartLine   the line we are starting from
      * @param aTree        the expression to find the first line for
      *
      * @return the first line of the expression
      */
     protected final int getFirstLine(int aStartLine, DetailAST aTree)
     {
         // find line for this node
         // TODO: getLineNo should probably not return < 0, but it is for
         // the interface methods... I should ask about this
         int realStart = aStartLine;
         final int currLine = aTree.getLineNo();
         if (currLine < realStart) {
             realStart = currLine;
         }
 
         // check children
         for (DetailAST node = aTree.getFirstChild();
             node != null;
             node = node.getNextSibling())
         {
             realStart = getFirstLine(realStart, node);
         }
 
         return realStart;
     }
 
     /**
      * Get the column number for the start of a given expression, expanding
      * tabs out into spaces in the process.
      *
      * @param aAST   the expression to find the start of
      *
      * @return the column number for the start of the expression
      */
     protected final int expandedTabsColumnNo(DetailAST aAST)
     {
         final String line =
             mIndentCheck.getLines()[aAST.getLineNo() - 1];
 
         return Utils.lengthExpandedTabs(line, aAST.getColumnNo(),
             mIndentCheck.getIndentationTabWidth());
     }
 
     /**
      * Find the set of lines for a given subtree.
      *
      * @param aLines          the set of lines to add to
      * @param aTree           the subtree to examine
      * @param aAllowNesting   whether or not to allow nested subtrees
      */
     protected final void findSubtreeLines(LineSet aLines, DetailAST aTree,
         boolean aAllowNesting)
     {
         // find line for this node
         // TODO: getLineNo should probably not return < 0, but it is for
         // the interface methods... I should ask about this
 
         if (getIndentCheck().getHandlerFactory().isHandledType(aTree.getType())
             || (aTree.getLineNo() < 0))
         {
             return;
         }
 
         // TODO: the problem with this is that not all tree tokens actually
         // have the right column number -- I should get a list of these
         // and verify that checking nesting this way won't cause problems
 //          if (aAllowNesting && aTree.getColumnNo() != getLineStart(aTree)) {
 //              return;
 //          }
 
         final int lineNum = aTree.getLineNo();
         final Integer colNum = aLines.getStartColumn(lineNum);
 
         final int thisLineColumn = expandedTabsColumnNo(aTree);
         if ((colNum == null) || (thisLineColumn < colNum.intValue())) {
             aLines.addLineAndCol(lineNum, thisLineColumn);
         }
 
         // check children
         for (DetailAST node = aTree.getFirstChild();
             node != null;
             node = node.getNextSibling())
         {
             findSubtreeLines(aLines, node, aAllowNesting);
         }
     }
 
     /**
      * Check the indentation level of modifiers.
      */
     protected final void checkModifiers()
     {
         final DetailAST modifiers =
             mMainAst.findFirstToken(TokenTypes.MODIFIERS);
         for (DetailAST modifier = modifiers.getFirstChild();
              modifier != null;
              modifier = modifier.getNextSibling())
         {
             /*
             if (!areOnSameLine(modifier, prevExpr)) {
                 continue;
             }
             */
             if (startsLine(modifier)
                 && !getLevel().accept(expandedTabsColumnNo(modifier)))
             {
                 logError(modifier, "modifier",
                     expandedTabsColumnNo(modifier));
             }
         }
     }
 
     /**
      * Check the indentation of the expression we are handling.
      */
     public abstract void checkIndentation();
 
     /**
      * Accessor for the IndentCheck attribute.
      *
      * @return the IndentCheck attribute
      */
     protected final IndentationCheck getIndentCheck()
     {
         return mIndentCheck;
     }
 
     /**
      * Accessor for the MainAst attribute.
      *
      * @return the MainAst attribute
      */
     protected final DetailAST getMainAst()
     {
         return mMainAst;
     }
 
     /**
      * Accessor for the Parent attribute.
      *
      * @return the Parent attribute
      */
     protected final ExpressionHandler getParent()
     {
         return mParent;
     }
 
     /**
      * A shortcut for <code>IndentationCheck</code> property.
      * @return value of basicOffset property of <code>IndentationCheck</code>
      */
     protected final int getBasicOffset()
     {
         return getIndentCheck().getBasicOffset();
     }
 
     /**
      * A shortcut for <code>IndentationCheck</code> property.
      * @return value of braceAdjustment property
      *         of <code>IndentationCheck</code>
      */
     protected final int getBraceAdjustement()
     {
         return getIndentCheck().getBraceAdjustement();
     }
 
     /**
      * Check the indentation of the right parenthesis.
      * @param aRparen parenthesis to check
      * @param aLparen left parenthesis associated with aRparen
      */
     protected final void checkRParen(DetailAST aLparen, DetailAST aRparen)
     {
         // no paren - no check :)
         if (aRparen == null) {
             return;
         }
 
         // the rcurly can either be at the correct indentation,
         // or not first on the line ...
         final int rparenLevel = expandedTabsColumnNo(aRparen);
         if (getLevel().accept(rparenLevel) || !startsLine(aRparen)) {
             return;
         }
 
         // or has <lparen level> + 1 indentation
         final int lparenLevel = expandedTabsColumnNo(aLparen);
         if (rparenLevel == (lparenLevel + 1)) {
             return;
         }
 
         logError(aRparen, "rparen", rparenLevel);
     }
 
     /**
      * Check the indentation of the left parenthesis.
      * @param aLparen parenthesis to check
      */
     protected final void checkLParen(final DetailAST aLparen)
     {
         // the rcurly can either be at the correct indentation, or on the
         // same line as the lcurly
         if ((aLparen == null)
             || getLevel().accept(expandedTabsColumnNo(aLparen))
             || !startsLine(aLparen))
         {
             return;
         }
         logError(aLparen, "lparen", expandedTabsColumnNo(aLparen));
     }
 }

1		////////////////////////////////////////////////////////////////////////////////
2		// checkstyle: Checks Java source code for adherence to a set of rules.
3		// Copyright (C) 2001-2014 Oliver Burn
4		//
5		// This library is free software; you can redistribute it and/or
6		// modify it under the terms of the GNU Lesser General Public
7		// License as published by the Free Software Foundation; either
8		// version 2.1 of the License, or (at your option) any later version.
9		//
10		// This library is distributed in the hope that it will be useful,
11		// but WITHOUT ANY WARRANTY; without even the implied warranty of
12		// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13		// Lesser General Public License for more details.
14		//
15		// You should have received a copy of the GNU Lesser General Public
16		// License along with this library; if not, write to the Free Software
17		// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18		////////////////////////////////////////////////////////////////////////////////
19		package com.puppycrawl.tools.checkstyle.checks.indentation;
20
21		import com.puppycrawl.tools.checkstyle.api.DetailAST;
22		import com.puppycrawl.tools.checkstyle.api.TokenTypes;
23		import com.puppycrawl.tools.checkstyle.api.Utils;
24		import java.util.Arrays;
25
26		/**
27		* Abstract base class for all handlers.
28		*
29		* @author jrichard
30		*/
31		public abstract class ExpressionHandler
32		{
33		/**
34		* The instance of <code>IndentationCheck</code> using this handler.
35		*/
36		private final IndentationCheck mIndentCheck;
37
38		/** the AST which is handled by this handler */
39		private final DetailAST mMainAst;
40
41		/** name used during output to user */
42		private final String mTypeName;
43
44		/** containing AST handler */
45		private final ExpressionHandler mParent;
46
47		/** indentation amount for this handler */
48		private IndentLevel mLevel;
49
50		/**
51		* Construct an instance of this handler with the given indentation check,
52		* name, abstract syntax tree, and parent handler.
53		*
54		* @param aIndentCheck the indentation check
55		* @param aTypeName the name of the handler
56		* @param aExpr the abstract syntax tree
57		* @param aParent the parent handler
58		*/
59		public ExpressionHandler(IndentationCheck aIndentCheck,
60		String aTypeName, DetailAST aExpr, ExpressionHandler aParent)
61	1809	{
62	1809	mIndentCheck = aIndentCheck;
63	1809	mTypeName = aTypeName;
64	1809	mMainAst = aExpr;
65	1809	mParent = aParent;
66	1809	}
67
68		/**
69		* Get the indentation amount for this handler. For performance reasons,
70		* this value is cached. The first time this method is called, the
71		* indentation amount is computed and stored. On further calls, the stored
72		* value is returned.
73		*
74		* @return the expected indentation amount
75		*/
76		public final IndentLevel getLevel()
77		{
78	7312	if (mLevel == null) {
79	1377	mLevel = getLevelImpl();
80		}
81	7312	return mLevel;
82		}
83
84		/**
85		* Compute the indentation amount for this handler.
86		*
87		* @return the expected indentation amount
88		*/
89		protected IndentLevel getLevelImpl()
90		{
91	1112	return mParent.suggestedChildLevel(this);
92		}
93
94		/**
95		* Indentation level suggested for a child element. Children don't have
96		* to respect this, but most do.
97		*
98		* @param aChild child AST (so suggestion level can differ based on child
99		* type)
100		*
101		* @return suggested indentation for child
102		*/
103		public IndentLevel suggestedChildLevel(ExpressionHandler aChild)
104		{
105	23	return new IndentLevel(getLevel(), getBasicOffset());
106		}
107
108		/**
109		* Log an indentation error.
110		*
111		* @param aAst the expression that caused the error
112		* @param aSubtypeName the type of the expression
113		* @param aActualLevel the actual indent level of the expression
114		*/
115		protected final void logError(DetailAST aAst, String aSubtypeName,
116		int aActualLevel)
117		{
118	121	logError(aAst, aSubtypeName, aActualLevel, getLevel());
119	121	}
120
121		/**
122		* Log an indentation error.
123		*
124		* @param aAst the expression that caused the error
125		* @param aSubtypeName the type of the expression
126		* @param aActualLevel the actual indent level of the expression
127		* @param aExpectedLevel the expected indent level of the expression
128		*/
129		protected final void logError(DetailAST aAst, String aSubtypeName,
130		int aActualLevel, IndentLevel aExpectedLevel)
131		{
132	201	final String typeStr =
133		("".equals(aSubtypeName) ? "" : (" " + aSubtypeName));
134	201	mIndentCheck.indentationLog(aAst.getLineNo(), "indentation.error",
135		mTypeName + typeStr, aActualLevel, aExpectedLevel);
136	201	}
137
138		/**
139		* Log child indentation error.
140		*
141		* @param aLine the expression that caused the error
142		* @param aActualLevel the actual indent level of the expression
143		* @param aExpectedLevel the expected indent level of the expression
144		*/
145		private void logChildError(int aLine,
146		int aActualLevel,
147		IndentLevel aExpectedLevel)
148		{
149	146	mIndentCheck.indentationLog(aLine, "indentation.child.error",
150		mTypeName, aActualLevel, aExpectedLevel);
151	146	}
152
153		/**
154		* Determines if the given expression is at the start of a line.
155		*
156		* @param aAst the expression to check
157		*
158		* @return true if it is, false otherwise
159		*/
160		protected final boolean startsLine(DetailAST aAst)
161		{
162	2292	return getLineStart(aAst) == expandedTabsColumnNo(aAst);
163		}
164
165		/**
166		* Determines if two expressions are on the same line.
167		*
168		* @param aAst1 the first expression
169		* @param aAst2 the second expression
170		*
171		* @return true if they are, false otherwise
172		*/
173		static boolean areOnSameLine(DetailAST aAst1, DetailAST aAst2)
174		{
175	728	return (aAst1 != null) && (aAst2 != null)
176		&& (aAst1.getLineNo() == aAst2.getLineNo());
177		}
178
179		/**
180		* Searchs in given sub-tree (including given node) for the token
181		* which represents first symbol for this sub-tree in file.
182		* @param aAST a root of sub-tree in which the search shoul be performed.
183		* @return a token which occurs first in the file.
184		*/
185		static DetailAST getFirstToken(DetailAST aAST)
186		{
187	394	DetailAST first = aAST;
188	394	DetailAST child = aAST.getFirstChild();
189
190	631	while (child != null) {
191	237	final DetailAST toTest = getFirstToken(child);
192	237	if ((toTest.getLineNo() < first.getLineNo())
193		\|\| ((toTest.getLineNo() == first.getLineNo())
194		&& (toTest.getColumnNo() < first.getColumnNo())))
195		{
196	74	first = toTest;
197		}
198	237	child = child.getNextSibling();
199	237	}
200
201	394	return first;
202		}
203
204		/**
205		* Get the start of the line for the given expression.
206		*
207		* @param aAst the expression to find the start of the line for
208		*
209		* @return the start of the line for the given expression
210		*/
211		protected final int getLineStart(DetailAST aAst)
212		{
213	2819	final String line = mIndentCheck.getLines()[aAst.getLineNo() - 1];
214	2819	return getLineStart(line);
215		}
216
217		// TODO: this whole checking of consecuitive/expression line indents is
218		// smelling pretty bad... and is in serious need of pruning. But, I
219		// want to finish the invalid tests before I start messing around with
220		// it.
221
222		/**
223		* Check the indentation of consecutive lines for the expression we are
224		* handling.
225		*
226		* @param aStartLine the first line to check
227		* @param aEndLine the last line to check
228		* @param aIndentLevel the required indent level
229		*/
230		protected final void checkLinesIndent(int aStartLine, int aEndLine,
231		IndentLevel aIndentLevel)
232		{
233		// check first line
234	114	checkSingleLine(aStartLine, aIndentLevel);
235
236		// check following lines
237	114	final IndentLevel offsetLevel =
238		new IndentLevel(aIndentLevel, getBasicOffset());
239	141	for (int i = aStartLine + 1; i <= aEndLine; i++) {
240	27	checkSingleLine(i, offsetLevel);
241		}
242	114	}
243
244		/**
245		* @return true if indentation should be increased after
246		* fisrt line in checkLinesIndent()
247		* false otherwise
248		*/
249		protected boolean shouldIncreaseIndent()
250		{
251	65	return true;
252		}
253
254		/**
255		* Check the indentation for a set of lines.
256		*
257		* @param aLines the set of lines to check
258		* @param aIndentLevel the indentation level
259		* @param aFirstLineMatches whether or not the first line has to match
260		* @param aFirstLine firstline of whole expression
261		*/
262		private void checkLinesIndent(LineSet aLines,
263		IndentLevel aIndentLevel,
264		boolean aFirstLineMatches,
265		int aFirstLine)
266		{
267	1619	if (aLines.isEmpty()) {
268	32	return;
269		}
270
271		// check first line
272	1587	final int startLine = aLines.firstLine();
273	1587	final int endLine = aLines.lastLine();
274	1587	final int startCol = aLines.firstLineCol();
275
276	1587	final int realStartCol =
277		getLineStart(mIndentCheck.getLines()[startLine - 1]);
278
279	1587	if (realStartCol == startCol) {
280	727	checkSingleLine(startLine, startCol, aIndentLevel,
281		aFirstLineMatches);
282		}
283
284		// if first line starts the line, following lines are indented
285		// one level; but if the first line of this expression is
286		// nested with the previous expression (which is assumed if it
287		// doesn't start the line) then don't indent more, the first
288		// indentation is absorbed by the nesting
289
290		// TODO: shouldIncreaseIndent() is a hack, should be removed
291		// after complete rewriting of checkExpressionSubtree()
292
293	1587	IndentLevel theLevel = aIndentLevel;
294	1587	if (aFirstLineMatches
295		\|\| ((aFirstLine > mMainAst.getLineNo()) && shouldIncreaseIndent()))
296		{
297	649	theLevel = new IndentLevel(aIndentLevel, getBasicOffset());
298		}
299
300		// check following lines
301	1729	for (int i = startLine + 1; i <= endLine; i++) {
302	142	final Integer col = aLines.getStartColumn(i);
303		// startCol could be null if this line didn't have an
304		// expression that was required to be checked (it could be
305		// checked by a child expression)
306
307	142	if (col != null) {
308	130	checkSingleLine(i, col.intValue(), theLevel, false);
309		}
310		}
311	1587	}
312
313		/**
314		* Check the indent level for a single line.
315		*
316		* @param aLineNum the line number to check
317		* @param aIndentLevel the required indent level
318		*/
319		private void checkSingleLine(int aLineNum, IndentLevel aIndentLevel)
320		{
321	141	final String line = mIndentCheck.getLines()[aLineNum - 1];
322	141	final int start = getLineStart(line);
323	141	if (aIndentLevel.gt(start)) {
324	9	logChildError(aLineNum, start, aIndentLevel);
325		}
326	141	}
327
328		/**
329		* Check the indentation for a single line.
330		*
331		* @param aLineNum the number of the line to check
332		* @param aColNum the column number we are starting at
333		* @param aIndentLevel the indentation level
334		* @param aMustMatch whether or not the indentation level must match
335		*/
336
337		private void checkSingleLine(int aLineNum, int aColNum,
338		IndentLevel aIndentLevel, boolean aMustMatch)
339		{
340	857	final String line = mIndentCheck.getLines()[aLineNum - 1];
341	857	final int start = getLineStart(line);
342		// if must match is set, it is an error if the line start is not
343		// at the correct indention level; otherwise, it is an only an
344		// error if this statement starts the line and it is less than
345		// the correct indentation level
346	857	if (aMustMatch ? !aIndentLevel.accept(start)
347		: (aColNum == start) && aIndentLevel.gt(start))
348		{
349	137	logChildError(aLineNum, start, aIndentLevel);
350		}
351	857	}
352
353		/**
354		* Get the start of the specified line.
355		*
356		* @param aLine the specified line number
357		*
358		* @return the start of the specified line
359		*/
360		protected final int getLineStart(String aLine)
361		{
362	55962	for (int start = 0; start < aLine.length(); start++) {
363	55962	final char c = aLine.charAt(start);
364
365	55962	if (!Character.isWhitespace(c)) {
366	5808	return Utils.lengthExpandedTabs(
367		aLine, start, mIndentCheck.getIndentationTabWidth());
368		}
369		}
370	0	return 0;
371		}
372
373		// TODO: allowNesting either shouldn't be allowed with
374		// firstLineMatches, or I should change the firstLineMatches logic
375		// so it doesn't match if the first line is nested
376
377		/**
378		* Check the indent level of the children of the specified parent
379		* expression.
380		*
381		* @param aParent the parent whose children we are checking
382		* @param aTokenTypes the token types to check
383		* @param aStartLevel the starting indent level
384		* @param aFirstLineMatches whether or not the first line needs to match
385		* @param aAllowNesting whether or not nested children are allowed
386		*/
387		protected final void checkChildren(DetailAST aParent,
388		int[] aTokenTypes,
389		IndentLevel aStartLevel,
390		boolean aFirstLineMatches,
391		boolean aAllowNesting)
392		{
393	561	Arrays.sort(aTokenTypes);
394	561	for (DetailAST child = aParent.getFirstChild();
395	2708	child != null;
396	2147	child = child.getNextSibling())
397		{
398	2147	if (Arrays.binarySearch(aTokenTypes, child.getType()) >= 0) {
399	575	checkExpressionSubtree(child, aStartLevel,
400		aFirstLineMatches, aAllowNesting);
401		}
402		}
403	561	}
404
405		/**
406		* Check the indentation level for an expression subtree.
407		*
408		* @param aTree the expression subtree to check
409		* @param aLevel the indentation level
410		* @param aFirstLineMatches whether or not the first line has to match
411		* @param aAllowNesting whether or not subtree nesting is allowed
412		*/
413		protected final void checkExpressionSubtree(
414		DetailAST aTree,
415		IndentLevel aLevel,
416		boolean aFirstLineMatches,
417		boolean aAllowNesting
418		)
419		{
420	1619	final LineSet subtreeLines = new LineSet();
421	1619	final int firstLine = getFirstLine(Integer.MAX_VALUE, aTree);
422	1619	if (aFirstLineMatches && !aAllowNesting) {
423	404	subtreeLines.addLineAndCol(firstLine,
424		getLineStart(mIndentCheck.getLines()[firstLine - 1]));
425		}
426	1619	findSubtreeLines(subtreeLines, aTree, aAllowNesting);
427
428	1619	checkLinesIndent(subtreeLines, aLevel, aFirstLineMatches, firstLine);
429	1619	}
430
431		/**
432		* Get the first line for a given expression.
433		*
434		* @param aStartLine the line we are starting from
435		* @param aTree the expression to find the first line for
436		*
437		* @return the first line of the expression
438		*/
439		protected final int getFirstLine(int aStartLine, DetailAST aTree)
440		{
441		// find line for this node
442		// TODO: getLineNo should probably not return < 0, but it is for
443		// the interface methods... I should ask about this
444	12695	int realStart = aStartLine;
445	12695	final int currLine = aTree.getLineNo();
446	12695	if (currLine < realStart) {
447	1763	realStart = currLine;
448		}
449
450		// check children
451	12695	for (DetailAST node = aTree.getFirstChild();
452	23731	node != null;
453	11036	node = node.getNextSibling())
454		{
455	11036	realStart = getFirstLine(realStart, node);
456		}
457
458	12695	return realStart;
459		}
460
461		/**
462		* Get the column number for the start of a given expression, expanding
463		* tabs out into spaces in the process.
464		*
465		* @param aAST the expression to find the start of
466		*
467		* @return the column number for the start of the expression
468		*/
469		protected final int expandedTabsColumnNo(DetailAST aAST)
470		{
471	11113	final String line =
472		mIndentCheck.getLines()[aAST.getLineNo() - 1];
473
474	11113	return Utils.lengthExpandedTabs(line, aAST.getColumnNo(),
475		mIndentCheck.getIndentationTabWidth());
476		}
477
478		/**
479		* Find the set of lines for a given subtree.
480		*
481		* @param aLines the set of lines to add to
482		* @param aTree the subtree to examine
483		* @param aAllowNesting whether or not to allow nested subtrees
484		*/
485		protected final void findSubtreeLines(LineSet aLines, DetailAST aTree,
486		boolean aAllowNesting)
487		{
488		// find line for this node
489		// TODO: getLineNo should probably not return < 0, but it is for
490		// the interface methods... I should ask about this
491
492	6254	if (getIndentCheck().getHandlerFactory().isHandledType(aTree.getType())
493		\|\| (aTree.getLineNo() < 0))
494		{
495	529	return;
496		}
497
498		// TODO: the problem with this is that not all tree tokens actually
499		// have the right column number -- I should get a list of these
500		// and verify that checking nesting this way won't cause problems
501		// if (aAllowNesting && aTree.getColumnNo() != getLineStart(aTree)) {
502		// return;
503		// }
504
505	5725	final int lineNum = aTree.getLineNo();
506	5725	final Integer colNum = aLines.getStartColumn(lineNum);
507
508	5725	final int thisLineColumn = expandedTabsColumnNo(aTree);
509	5725	if ((colNum == null) \|\| (thisLineColumn < colNum.intValue())) {
510	2327	aLines.addLineAndCol(lineNum, thisLineColumn);
511		}
512
513		// check children
514	5725	for (DetailAST node = aTree.getFirstChild();
515	10083	node != null;
516	4358	node = node.getNextSibling())
517		{
518	4358	findSubtreeLines(aLines, node, aAllowNesting);
519		}
520	5725	}
521
522		/**
523		* Check the indentation level of modifiers.
524		*/
525		protected final void checkModifiers()
526		{
527	275	final DetailAST modifiers =
528		mMainAst.findFirstToken(TokenTypes.MODIFIERS);
529	275	for (DetailAST modifier = modifiers.getFirstChild();
530	494	modifier != null;
531	219	modifier = modifier.getNextSibling())
532		{
533		/*
534		if (!areOnSameLine(modifier, prevExpr)) {
535		continue;
536		}
537		*/
538	219	if (startsLine(modifier)
539		&& !getLevel().accept(expandedTabsColumnNo(modifier)))
540		{
541	12	logError(modifier, "modifier",
542		expandedTabsColumnNo(modifier));
543		}
544		}
545	275	}
546
547		/**
548		* Check the indentation of the expression we are handling.
549		*/
550		public abstract void checkIndentation();
551
552		/**
553		* Accessor for the IndentCheck attribute.
554		*
555		* @return the IndentCheck attribute
556		*/
557		protected final IndentationCheck getIndentCheck()
558		{
559	10172	return mIndentCheck;
560		}
561
562		/**
563		* Accessor for the MainAst attribute.
564		*
565		* @return the MainAst attribute
566		*/
567		protected final DetailAST getMainAst()
568		{
569	13112	return mMainAst;
570		}
571
572		/**
573		* Accessor for the Parent attribute.
574		*
575		* @return the Parent attribute
576		*/
577		protected final ExpressionHandler getParent()
578		{
579	2038	return mParent;
580		}
581
582		/**
583		* A shortcut for <code>IndentationCheck</code> property.
584		* @return value of basicOffset property of <code>IndentationCheck</code>
585		*/
586		protected final int getBasicOffset()
587		{
588	2653	return getIndentCheck().getBasicOffset();
589		}
590
591		/**
592		* A shortcut for <code>IndentationCheck</code> property.
593		* @return value of braceAdjustment property
594		* of <code>IndentationCheck</code>
595		*/
596		protected final int getBraceAdjustement()
597		{
598	1195	return getIndentCheck().getBraceAdjustement();
599		}
600
601		/**
602		* Check the indentation of the right parenthesis.
603		* @param aRparen parenthesis to check
604		* @param aLparen left parenthesis associated with aRparen
605		*/
606		protected final void checkRParen(DetailAST aLparen, DetailAST aRparen)
607		{
608		// no paren - no check :)
609	692	if (aRparen == null) {
610	309	return;
611		}
612
613		// the rcurly can either be at the correct indentation,
614		// or not first on the line ...
615	383	final int rparenLevel = expandedTabsColumnNo(aRparen);
616	383	if (getLevel().accept(rparenLevel) \|\| !startsLine(aRparen)) {
617	373	return;
618		}
619
620		// or has <lparen level> + 1 indentation
621	10	final int lparenLevel = expandedTabsColumnNo(aLparen);
622	10	if (rparenLevel == (lparenLevel + 1)) {
623	1	return;
624		}
625
626	9	logError(aRparen, "rparen", rparenLevel);
627	9	}
628
629		/**
630		* Check the indentation of the left parenthesis.
631		* @param aLparen parenthesis to check
632		*/
633		protected final void checkLParen(final DetailAST aLparen)
634		{
635		// the rcurly can either be at the correct indentation, or on the
636		// same line as the lcurly
637	1003	if ((aLparen == null)
638		\|\| getLevel().accept(expandedTabsColumnNo(aLparen))
639		\|\| !startsLine(aLparen))
640		{
641	1002	return;
642		}
643	1	logError(aLparen, "lparen", expandedTabsColumnNo(aLparen));
644	1	}
645		}