001/////////////////////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code and other text files for adherence to a set of rules. 003// Copyright (C) 2001-2022 the original author or authors. 004// 005// This library is free software; you can redistribute it and/or 006// modify it under the terms of the GNU Lesser General Public 007// License as published by the Free Software Foundation; either 008// version 2.1 of the License, or (at your option) any later version. 009// 010// This library is distributed in the hope that it will be useful, 011// but WITHOUT ANY WARRANTY; without even the implied warranty of 012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 013// Lesser General Public License for more details. 014// 015// You should have received a copy of the GNU Lesser General Public 016// License along with this library; if not, write to the Free Software 017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 018/////////////////////////////////////////////////////////////////////////////////////////////// 019 020package com.puppycrawl.tools.checkstyle.checks.indentation; 021 022import java.util.Arrays; 023 024import com.puppycrawl.tools.checkstyle.api.DetailAST; 025import com.puppycrawl.tools.checkstyle.api.TokenTypes; 026import com.puppycrawl.tools.checkstyle.utils.CommonUtil; 027 028/** 029 * Abstract base class for all handlers. 030 * 031 */ 032public abstract class AbstractExpressionHandler { 033 034 /** 035 * The instance of {@code IndentationCheck} using this handler. 036 */ 037 private final IndentationCheck indentCheck; 038 039 /** The AST which is handled by this handler. */ 040 private final DetailAST mainAst; 041 042 /** Name used during output to user. */ 043 private final String typeName; 044 045 /** Containing AST handler. */ 046 private final AbstractExpressionHandler parent; 047 048 /** Indentation amount for this handler. */ 049 private IndentLevel indent; 050 051 /** 052 * Construct an instance of this handler with the given indentation check, 053 * name, abstract syntax tree, and parent handler. 054 * 055 * @param indentCheck the indentation check 056 * @param typeName the name of the handler 057 * @param expr the abstract syntax tree 058 * @param parent the parent handler 059 */ 060 protected AbstractExpressionHandler(IndentationCheck indentCheck, String typeName, 061 DetailAST expr, AbstractExpressionHandler parent) { 062 this.indentCheck = indentCheck; 063 this.typeName = typeName; 064 mainAst = expr; 065 this.parent = parent; 066 } 067 068 /** 069 * Check the indentation of the expression we are handling. 070 */ 071 public abstract void checkIndentation(); 072 073 /** 074 * Get the indentation amount for this handler. For performance reasons, 075 * this value is cached. The first time this method is called, the 076 * indentation amount is computed and stored. On further calls, the stored 077 * value is returned. 078 * 079 * @return the expected indentation amount 080 * @noinspection WeakerAccess 081 * @noinspectionreason WeakerAccess - we avoid 'protected' when possible 082 */ 083 public final IndentLevel getIndent() { 084 if (indent == null) { 085 indent = getIndentImpl(); 086 } 087 return indent; 088 } 089 090 /** 091 * Compute the indentation amount for this handler. 092 * 093 * @return the expected indentation amount 094 */ 095 protected IndentLevel getIndentImpl() { 096 return parent.getSuggestedChildIndent(this); 097 } 098 099 /** 100 * Indentation level suggested for a child element. Children don't have 101 * to respect this, but most do. 102 * 103 * @param child child AST (so suggestion level can differ based on child 104 * type) 105 * 106 * @return suggested indentation for child 107 * @noinspection WeakerAccess 108 * @noinspectionreason WeakerAccess - we avoid 'protected' when possible 109 */ 110 public IndentLevel getSuggestedChildIndent(AbstractExpressionHandler child) { 111 return new IndentLevel(getIndent(), getBasicOffset()); 112 } 113 114 /** 115 * Log an indentation error. 116 * 117 * @param ast the expression that caused the error 118 * @param subtypeName the type of the expression 119 * @param actualIndent the actual indent level of the expression 120 */ 121 protected final void logError(DetailAST ast, String subtypeName, 122 int actualIndent) { 123 logError(ast, subtypeName, actualIndent, getIndent()); 124 } 125 126 /** 127 * Log an indentation error. 128 * 129 * @param ast the expression that caused the error 130 * @param subtypeName the type of the expression 131 * @param actualIndent the actual indent level of the expression 132 * @param expectedIndent the expected indent level of the expression 133 */ 134 protected final void logError(DetailAST ast, String subtypeName, 135 int actualIndent, IndentLevel expectedIndent) { 136 final String typeStr; 137 138 if (subtypeName.isEmpty()) { 139 typeStr = ""; 140 } 141 else { 142 typeStr = " " + subtypeName; 143 } 144 String messageKey = IndentationCheck.MSG_ERROR; 145 if (expectedIndent.isMultiLevel()) { 146 messageKey = IndentationCheck.MSG_ERROR_MULTI; 147 } 148 indentCheck.indentationLog(ast, messageKey, 149 typeName + typeStr, actualIndent, expectedIndent); 150 } 151 152 /** 153 * Log child indentation error. 154 * 155 * @param ast the abstract syntax tree that causes the error 156 * @param actualIndent the actual indent level of the expression 157 * @param expectedIndent the expected indent level of the expression 158 */ 159 private void logChildError(DetailAST ast, 160 int actualIndent, 161 IndentLevel expectedIndent) { 162 String messageKey = IndentationCheck.MSG_CHILD_ERROR; 163 if (expectedIndent.isMultiLevel()) { 164 messageKey = IndentationCheck.MSG_CHILD_ERROR_MULTI; 165 } 166 indentCheck.indentationLog(ast, messageKey, 167 typeName, actualIndent, expectedIndent); 168 } 169 170 /** 171 * Determines if the given expression is at the start of a line. 172 * 173 * @param ast the expression to check 174 * 175 * @return true if it is, false otherwise 176 */ 177 protected final boolean isOnStartOfLine(DetailAST ast) { 178 return getLineStart(ast) == expandedTabsColumnNo(ast); 179 } 180 181 /** 182 * Searches in given subtree (including given node) for the token 183 * which represents first symbol for this subtree in file. 184 * 185 * @param ast a root of subtree in which the search should be performed. 186 * @return a token which occurs first in the file. 187 * @noinspection WeakerAccess 188 * @noinspectionreason WeakerAccess - we avoid 'protected' when possible 189 */ 190 public static DetailAST getFirstToken(DetailAST ast) { 191 DetailAST first = ast; 192 DetailAST child = ast.getFirstChild(); 193 194 while (child != null) { 195 final DetailAST toTest = getFirstToken(child); 196 if (toTest.getColumnNo() < first.getColumnNo()) { 197 first = toTest; 198 } 199 child = child.getNextSibling(); 200 } 201 202 return first; 203 } 204 205 /** 206 * Get the start of the line for the given expression. 207 * 208 * @param ast the expression to find the start of the line for 209 * 210 * @return the start of the line for the given expression 211 */ 212 protected final int getLineStart(DetailAST ast) { 213 return getLineStart(ast.getLineNo()); 214 } 215 216 /** 217 * Get the start of the line for the given line number. 218 * 219 * @param lineNo the line number to find the start for 220 * 221 * @return the start of the line for the given expression 222 */ 223 protected final int getLineStart(int lineNo) { 224 return getLineStart(indentCheck.getLine(lineNo - 1)); 225 } 226 227 /** 228 * Get the start of the specified line. 229 * 230 * @param line the specified line number 231 * 232 * @return the start of the specified line 233 */ 234 private int getLineStart(String line) { 235 int index = 0; 236 while (Character.isWhitespace(line.charAt(index))) { 237 index++; 238 } 239 return CommonUtil.lengthExpandedTabs( 240 line, index, indentCheck.getIndentationTabWidth()); 241 } 242 243 /** 244 * Checks that indentation should be increased after first line in checkLinesIndent(). 245 * 246 * @return true if indentation should be increased after 247 * first line in checkLinesIndent() 248 * false otherwise 249 */ 250 protected boolean shouldIncreaseIndent() { 251 return true; 252 } 253 254 /** 255 * Check the indentation for a set of lines. 256 * 257 * @param astSet the set of abstract syntax tree to check 258 * @param indentLevel the indentation level 259 * @param firstLineMatches whether or not the first line has to match 260 * @param firstLine first line of whole expression 261 * @param allowNesting whether or not subtree nesting is allowed 262 */ 263 private void checkLinesIndent(DetailAstSet astSet, 264 IndentLevel indentLevel, 265 boolean firstLineMatches, 266 int firstLine, 267 boolean allowNesting) { 268 if (!astSet.isEmpty()) { 269 // check first line 270 final DetailAST startLineAst = astSet.firstLine(); 271 final int endLine = astSet.lastLine(); 272 int startCol = expandedTabsColumnNo(astSet.firstLine()); 273 274 final int realStartCol = 275 getLineStart(indentCheck.getLine(startLineAst.getLineNo() - 1)); 276 277 if (firstLineMatches && !allowNesting) { 278 startCol = realStartCol; 279 } 280 281 if (realStartCol == startCol) { 282 checkLineIndent(startLineAst, indentLevel, 283 firstLineMatches); 284 } 285 286 // if first line starts the line, following lines are indented 287 // one level; but if the first line of this expression is 288 // nested with the previous expression (which is assumed if it 289 // doesn't start the line) then don't indent more, the first 290 // indentation is absorbed by the nesting 291 292 IndentLevel theLevel = indentLevel; 293 if (firstLineMatches 294 || firstLine > mainAst.getLineNo() && shouldIncreaseIndent()) { 295 theLevel = new IndentLevel(indentLevel, getBasicOffset()); 296 } 297 298 // check following lines 299 for (int i = startLineAst.getLineNo() + 1; i <= endLine; i++) { 300 final Integer col = astSet.getStartColumn(i); 301 // startCol could be null if this line didn't have an 302 // expression that was required to be checked (it could be 303 // checked by a child expression) 304 305 if (col != null) { 306 checkLineIndent(astSet.getAst(i), theLevel, false); 307 } 308 } 309 } 310 } 311 312 /** 313 * Check the indentation for a single-line. 314 * 315 * @param ast the abstract syntax tree to check 316 * @param indentLevel the indentation level 317 * @param mustMatch whether or not the indentation level must match 318 */ 319 private void checkLineIndent(DetailAST ast, 320 IndentLevel indentLevel, boolean mustMatch) { 321 final String line = indentCheck.getLine(ast.getLineNo() - 1); 322 final int start = getLineStart(line); 323 final int columnNumber = expandedTabsColumnNo(ast); 324 // if must match is set, it is a violation if the line start is not 325 // at the correct indention level; otherwise, it is an only a 326 // violation if this statement starts the line and it is less than 327 // the correct indentation level 328 if (mustMatch && !indentLevel.isAcceptable(start) 329 || !mustMatch && columnNumber == start && indentLevel.isGreaterThan(start)) { 330 logChildError(ast, start, indentLevel); 331 } 332 } 333 334 /** 335 * Checks indentation on wrapped lines between and including 336 * {@code firstNode} and {@code lastNode}. 337 * 338 * @param firstNode First node to start examining. 339 * @param lastNode Last node to examine inclusively. 340 */ 341 protected void checkWrappingIndentation(DetailAST firstNode, DetailAST lastNode) { 342 indentCheck.getLineWrappingHandler().checkIndentation(firstNode, lastNode); 343 } 344 345 /** 346 * Checks indentation on wrapped lines between and including 347 * {@code firstNode} and {@code lastNode}. 348 * 349 * @param firstNode First node to start examining. 350 * @param lastNode Last node to examine inclusively. 351 * @param wrappedIndentLevel Indentation all wrapped lines should use. 352 * @param startIndent Indentation first line before wrapped lines used. 353 * @param ignoreFirstLine Test if first line's indentation should be checked or not. 354 */ 355 protected void checkWrappingIndentation(DetailAST firstNode, DetailAST lastNode, 356 int wrappedIndentLevel, int startIndent, boolean ignoreFirstLine) { 357 indentCheck.getLineWrappingHandler().checkIndentation(firstNode, lastNode, 358 wrappedIndentLevel, startIndent, 359 LineWrappingHandler.LineWrappingOptions.ofBoolean(ignoreFirstLine)); 360 } 361 362 /** 363 * Check the indent level of the children of the specified parent 364 * expression. 365 * 366 * @param parentNode the parent whose children we are checking 367 * @param tokenTypes the token types to check 368 * @param startIndent the starting indent level 369 * @param firstLineMatches whether or not the first line needs to match 370 * @param allowNesting whether or not nested children are allowed 371 */ 372 protected final void checkChildren(DetailAST parentNode, 373 int[] tokenTypes, 374 IndentLevel startIndent, 375 boolean firstLineMatches, 376 boolean allowNesting) { 377 Arrays.sort(tokenTypes); 378 for (DetailAST child = parentNode.getFirstChild(); 379 child != null; 380 child = child.getNextSibling()) { 381 if (Arrays.binarySearch(tokenTypes, child.getType()) >= 0) { 382 checkExpressionSubtree(child, startIndent, 383 firstLineMatches, allowNesting); 384 } 385 } 386 } 387 388 /** 389 * Check the indentation level for an expression subtree. 390 * 391 * @param tree the expression subtree to check 392 * @param indentLevel the indentation level 393 * @param firstLineMatches whether or not the first line has to match 394 * @param allowNesting whether or not subtree nesting is allowed 395 */ 396 protected final void checkExpressionSubtree( 397 DetailAST tree, 398 IndentLevel indentLevel, 399 boolean firstLineMatches, 400 boolean allowNesting 401 ) { 402 final DetailAstSet subtreeAst = new DetailAstSet(indentCheck); 403 final int firstLine = getFirstLine(tree); 404 if (firstLineMatches && !allowNesting) { 405 final DetailAST firstAst = getFirstAstNode(tree); 406 subtreeAst.addAst(firstAst); 407 } 408 findSubtreeAst(subtreeAst, tree, allowNesting); 409 410 checkLinesIndent(subtreeAst, indentLevel, firstLineMatches, firstLine, allowNesting); 411 } 412 413 /** 414 * Get the first line number for given expression. 415 * 416 * @param tree the expression to find the first line for 417 * @return the first line of expression 418 */ 419 protected static int getFirstLine(DetailAST tree) { 420 return getFirstAstNode(tree).getLineNo(); 421 } 422 423 /** 424 * Get the first ast for given expression. 425 * 426 * @param ast the abstract syntax tree for which the starting ast is to be found 427 * 428 * @return the first ast of the expression 429 */ 430 protected static DetailAST getFirstAstNode(DetailAST ast) { 431 432 DetailAST curNode = ast; 433 DetailAST realStart = ast; 434 while (curNode != null) { 435 if (curNode.getLineNo() < realStart.getLineNo() 436 || curNode.getLineNo() == realStart.getLineNo() 437 && curNode.getColumnNo() < realStart.getColumnNo()) { 438 realStart = curNode; 439 } 440 DetailAST toVisit = curNode.getFirstChild(); 441 while (curNode != ast && toVisit == null) { 442 toVisit = curNode.getNextSibling(); 443 curNode = curNode.getParent(); 444 } 445 curNode = toVisit; 446 } 447 return realStart; 448 } 449 450 /** 451 * Get the column number for the start of a given expression, expanding 452 * tabs out into spaces in the process. 453 * 454 * @param ast the expression to find the start of 455 * 456 * @return the column number for the start of the expression 457 */ 458 protected final int expandedTabsColumnNo(DetailAST ast) { 459 final String line = 460 indentCheck.getLine(ast.getLineNo() - 1); 461 462 return CommonUtil.lengthExpandedTabs(line, ast.getColumnNo(), 463 indentCheck.getIndentationTabWidth()); 464 } 465 466 /** 467 * Find the set of abstract syntax tree for a given subtree. 468 * 469 * @param astSet the set of ast to add 470 * @param tree the subtree to examine 471 * @param allowNesting whether or not to allow nested subtrees 472 */ 473 protected final void findSubtreeAst(DetailAstSet astSet, DetailAST tree, 474 boolean allowNesting) { 475 if (!indentCheck.getHandlerFactory().isHandledType(tree.getType())) { 476 final int lineNum = tree.getLineNo(); 477 final Integer colNum = astSet.getStartColumn(lineNum); 478 479 final int thisLineColumn = expandedTabsColumnNo(tree); 480 if (colNum == null || thisLineColumn < colNum) { 481 astSet.addAst(tree); 482 } 483 484 // check children 485 for (DetailAST node = tree.getFirstChild(); 486 node != null; 487 node = node.getNextSibling()) { 488 findSubtreeAst(astSet, node, allowNesting); 489 } 490 } 491 } 492 493 /** 494 * Check the indentation level of modifiers. 495 */ 496 protected void checkModifiers() { 497 final DetailAST modifiers = 498 mainAst.findFirstToken(TokenTypes.MODIFIERS); 499 for (DetailAST modifier = modifiers.getFirstChild(); 500 modifier != null; 501 modifier = modifier.getNextSibling()) { 502 if (isOnStartOfLine(modifier) 503 && !getIndent().isAcceptable(expandedTabsColumnNo(modifier))) { 504 logError(modifier, "modifier", 505 expandedTabsColumnNo(modifier)); 506 } 507 } 508 } 509 510 /** 511 * Accessor for the IndentCheck attribute. 512 * 513 * @return the IndentCheck attribute 514 */ 515 protected final IndentationCheck getIndentCheck() { 516 return indentCheck; 517 } 518 519 /** 520 * Accessor for the MainAst attribute. 521 * 522 * @return the MainAst attribute 523 */ 524 protected final DetailAST getMainAst() { 525 return mainAst; 526 } 527 528 /** 529 * Accessor for the Parent attribute. 530 * 531 * @return the Parent attribute 532 */ 533 protected final AbstractExpressionHandler getParent() { 534 return parent; 535 } 536 537 /** 538 * A shortcut for {@code IndentationCheck} property. 539 * 540 * @return value of basicOffset property of {@code IndentationCheck} 541 */ 542 protected final int getBasicOffset() { 543 return indentCheck.getBasicOffset(); 544 } 545 546 /** 547 * A shortcut for {@code IndentationCheck} property. 548 * 549 * @return value of braceAdjustment property 550 * of {@code IndentationCheck} 551 */ 552 protected final int getBraceAdjustment() { 553 return indentCheck.getBraceAdjustment(); 554 } 555 556 /** 557 * Check the indentation of the right parenthesis. 558 * 559 * @param lparen left parenthesis associated with aRparen 560 * @param rparen parenthesis to check 561 */ 562 protected final void checkRightParen(DetailAST lparen, DetailAST rparen) { 563 if (rparen != null) { 564 // the rcurly can either be at the correct indentation, 565 // or not first on the line 566 final int rparenLevel = expandedTabsColumnNo(rparen); 567 // or has <lparen level> + 1 indentation 568 final int lparenLevel = expandedTabsColumnNo(lparen); 569 570 if (rparenLevel != lparenLevel + 1 571 && !getIndent().isAcceptable(rparenLevel) 572 && isOnStartOfLine(rparen)) { 573 logError(rparen, "rparen", rparenLevel); 574 } 575 } 576 } 577 578 /** 579 * Check the indentation of the left parenthesis. 580 * 581 * @param lparen parenthesis to check 582 */ 583 protected final void checkLeftParen(final DetailAST lparen) { 584 // the rcurly can either be at the correct indentation, or on the 585 // same line as the lcurly 586 if (lparen != null 587 && !getIndent().isAcceptable(expandedTabsColumnNo(lparen)) 588 && isOnStartOfLine(lparen)) { 589 logError(lparen, "lparen", expandedTabsColumnNo(lparen)); 590 } 591 } 592 593}