001////////////////////////////////////////////////////////////////////////////////
002// checkstyle: Checks Java source code for adherence to a set of rules.
003// Copyright (C) 2001-2018 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.whitespace;
021
022import com.puppycrawl.tools.checkstyle.StatelessCheck;
023import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
024import com.puppycrawl.tools.checkstyle.api.DetailAST;
025import com.puppycrawl.tools.checkstyle.api.TokenTypes;
026import com.puppycrawl.tools.checkstyle.utils.CommonUtils;
027
028/**
029 * Checks that a token is surrounded by whitespace.
030 *
031 * <p>By default the check will check the following operators:
032 *  {@link TokenTypes#LITERAL_ASSERT ASSERT},
033 *  {@link TokenTypes#ASSIGN ASSIGN},
034 *  {@link TokenTypes#BAND BAND},
035 *  {@link TokenTypes#BAND_ASSIGN BAND_ASSIGN},
036 *  {@link TokenTypes#BOR BOR},
037 *  {@link TokenTypes#BOR_ASSIGN BOR_ASSIGN},
038 *  {@link TokenTypes#BSR BSR},
039 *  {@link TokenTypes#BSR_ASSIGN BSR_ASSIGN},
040 *  {@link TokenTypes#BXOR BXOR},
041 *  {@link TokenTypes#BXOR_ASSIGN BXOR_ASSIGN},
042 *  {@link TokenTypes#COLON COLON},
043 *  {@link TokenTypes#DIV DIV},
044 *  {@link TokenTypes#DIV_ASSIGN DIV_ASSIGN},
045 *  {@link TokenTypes#DO_WHILE DO_WHILE},
046 *  {@link TokenTypes#EQUAL EQUAL},
047 *  {@link TokenTypes#GE GE},
048 *  {@link TokenTypes#GT GT},
049 *  {@link TokenTypes#LAND LAND},
050 *  {@link TokenTypes#LCURLY LCURLY},
051 *  {@link TokenTypes#LE LE},
052 *  {@link TokenTypes#LITERAL_CATCH LITERAL_CATCH},
053 *  {@link TokenTypes#LITERAL_DO LITERAL_DO},
054 *  {@link TokenTypes#LITERAL_ELSE LITERAL_ELSE},
055 *  {@link TokenTypes#LITERAL_FINALLY LITERAL_FINALLY},
056 *  {@link TokenTypes#LITERAL_FOR LITERAL_FOR},
057 *  {@link TokenTypes#LITERAL_IF LITERAL_IF},
058 *  {@link TokenTypes#LITERAL_RETURN LITERAL_RETURN},
059 *  {@link TokenTypes#LITERAL_SWITCH LITERAL_SWITCH},
060 *  {@link TokenTypes#LITERAL_SYNCHRONIZED LITERAL_SYNCHRONIZED},
061 *  {@link TokenTypes#LITERAL_TRY LITERAL_TRY},
062 *  {@link TokenTypes#LITERAL_WHILE LITERAL_WHILE},
063 *  {@link TokenTypes#LOR LOR},
064 *  {@link TokenTypes#LT LT},
065 *  {@link TokenTypes#MINUS MINUS},
066 *  {@link TokenTypes#MINUS_ASSIGN MINUS_ASSIGN},
067 *  {@link TokenTypes#MOD MOD},
068 *  {@link TokenTypes#MOD_ASSIGN MOD_ASSIGN},
069 *  {@link TokenTypes#NOT_EQUAL NOT_EQUAL},
070 *  {@link TokenTypes#PLUS PLUS},
071 *  {@link TokenTypes#PLUS_ASSIGN PLUS_ASSIGN},
072 *  {@link TokenTypes#QUESTION QUESTION},
073 *  {@link TokenTypes#RCURLY RCURLY},
074 *  {@link TokenTypes#SL SL},
075 *  {@link TokenTypes#SLIST SLIST},
076 *  {@link TokenTypes#SL_ASSIGN SL_ASSIGN},
077 *  {@link TokenTypes#SR SR},
078 *  {@link TokenTypes#SR_ASSIGN SR_ASSIGN},
079 *  {@link TokenTypes#STAR STAR},
080 *  {@link TokenTypes#STAR_ASSIGN STAR_ASSIGN},
081 *  {@link TokenTypes#LITERAL_ASSERT LITERAL_ASSERT},
082 *  {@link TokenTypes#TYPE_EXTENSION_AND TYPE_EXTENSION_AND}.
083 *
084 * <p>An example of how to configure the check is:
085 *
086 * <pre>
087 * &lt;module name="WhitespaceAround"/&gt;
088 * </pre>
089 *
090 * <p>An example of how to configure the check for whitespace only around
091 * assignment operators is:
092 *
093 * <pre>
094 * &lt;module name="WhitespaceAround"&gt;
095 *     &lt;property name="tokens"
096 *               value="ASSIGN,DIV_ASSIGN,PLUS_ASSIGN,MINUS_ASSIGN,STAR_ASSIGN,
097 *                      MOD_ASSIGN,SR_ASSIGN,BSR_ASSIGN,SL_ASSIGN,BXOR_ASSIGN,
098 *                      BOR_ASSIGN,BAND_ASSIGN"/&gt;
099 * &lt;/module&gt;
100 * </pre>
101 *
102 * <p>An example of how to configure the check for whitespace only around
103 * curly braces is:
104 * <pre>
105 * &lt;module name="WhitespaceAround"&gt;
106 *     &lt;property name="tokens"
107 *               value="LCURLY,RCURLY"/&gt;
108 * &lt;/module&gt;
109 * </pre>
110 *
111 * <p>In addition, this check can be configured to allow empty methods, types,
112 * for, while, do-while loops, lambdas and constructor bodies.
113 * For example:
114 *
115 * <pre>{@code
116 * public MyClass() {}      // empty constructor
117 * public void func() {}    // empty method
118 * public interface Foo {} // empty interface
119 * public class Foo {} // empty class
120 * public enum Foo {} // empty enum
121 * MyClass c = new MyClass() {}; // empty anonymous class
122 * while (i = 1) {} // empty while loop
123 * for (int i = 1; i &gt; 1; i++) {} // empty for loop
124 * do {} while (i = 1); // empty do-while loop
125 * Runnable noop = () -> {}; // empty lambda
126 * public @interface Beta {} // empty annotation type
127 * }</pre>
128 *
129 * <p>This check does not flag as violation double brace initialization like:</p>
130 * <pre>
131 *   new Properties() {{
132 *     setProperty("key", "value");
133 *   }};
134 * </pre>
135 *
136 * <p>To configure the check to allow empty method blocks use
137 *
138 * <pre>   &lt;property name="allowEmptyMethods" value="true" /&gt;</pre>
139 *
140 * <p>To configure the check to allow empty constructor blocks use
141 *
142 * <pre>   &lt;property name="allowEmptyConstructors" value="true" /&gt;</pre>
143 *
144 * <p>To configure the check to allow empty type blocks use
145 *
146 * <pre>   &lt;property name="allowEmptyTypes" value="true" /&gt;</pre>
147 *
148 * <p>To configure the check to allow empty loop blocks use
149 *
150 * <pre>   &lt;property name="allowEmptyLoops" value="true" /&gt;</pre>
151 *
152 * <p>To configure the check to allow empty lambdas blocks use
153 *
154 * <pre>   &lt;property name="allowEmptyLambdas" value="true" /&gt;</pre>
155 *
156 * <p>Also, this check can be configured to ignore the colon in an enhanced for
157 * loop. The colon in an enhanced for loop is ignored by default
158 *
159 * <p>To configure the check to ignore the colon
160 *
161 * <pre>   &lt;property name="ignoreEnhancedForColon" value="true" /&gt;</pre>
162 *
163 */
164@StatelessCheck
165public class WhitespaceAroundCheck extends AbstractCheck {
166
167    /**
168     * A key is pointing to the warning message text in "messages.properties"
169     * file.
170     */
171    public static final String MSG_WS_NOT_PRECEDED = "ws.notPreceded";
172
173    /**
174     * A key is pointing to the warning message text in "messages.properties"
175     * file.
176     */
177    public static final String MSG_WS_NOT_FOLLOWED = "ws.notFollowed";
178
179    /** Whether or not empty constructor bodies are allowed. */
180    private boolean allowEmptyConstructors;
181    /** Whether or not empty method bodies are allowed. */
182    private boolean allowEmptyMethods;
183    /** Whether or not empty classes, enums and interfaces are allowed. */
184    private boolean allowEmptyTypes;
185    /** Whether or not empty loops are allowed. */
186    private boolean allowEmptyLoops;
187    /** Whether or not empty lambda blocks are allowed. */
188    private boolean allowEmptyLambdas;
189    /** Whether or not empty catch blocks are allowed. */
190    private boolean allowEmptyCatches;
191    /** Whether or not to ignore a colon in a enhanced for loop. */
192    private boolean ignoreEnhancedForColon = true;
193
194    @Override
195    public int[] getDefaultTokens() {
196        return new int[] {
197            TokenTypes.ASSIGN,
198            TokenTypes.BAND,
199            TokenTypes.BAND_ASSIGN,
200            TokenTypes.BOR,
201            TokenTypes.BOR_ASSIGN,
202            TokenTypes.BSR,
203            TokenTypes.BSR_ASSIGN,
204            TokenTypes.BXOR,
205            TokenTypes.BXOR_ASSIGN,
206            TokenTypes.COLON,
207            TokenTypes.DIV,
208            TokenTypes.DIV_ASSIGN,
209            TokenTypes.DO_WHILE,
210            TokenTypes.EQUAL,
211            TokenTypes.GE,
212            TokenTypes.GT,
213            TokenTypes.LAMBDA,
214            TokenTypes.LAND,
215            TokenTypes.LCURLY,
216            TokenTypes.LE,
217            TokenTypes.LITERAL_CATCH,
218            TokenTypes.LITERAL_DO,
219            TokenTypes.LITERAL_ELSE,
220            TokenTypes.LITERAL_FINALLY,
221            TokenTypes.LITERAL_FOR,
222            TokenTypes.LITERAL_IF,
223            TokenTypes.LITERAL_RETURN,
224            TokenTypes.LITERAL_SWITCH,
225            TokenTypes.LITERAL_SYNCHRONIZED,
226            TokenTypes.LITERAL_TRY,
227            TokenTypes.LITERAL_WHILE,
228            TokenTypes.LOR,
229            TokenTypes.LT,
230            TokenTypes.MINUS,
231            TokenTypes.MINUS_ASSIGN,
232            TokenTypes.MOD,
233            TokenTypes.MOD_ASSIGN,
234            TokenTypes.NOT_EQUAL,
235            TokenTypes.PLUS,
236            TokenTypes.PLUS_ASSIGN,
237            TokenTypes.QUESTION,
238            TokenTypes.RCURLY,
239            TokenTypes.SL,
240            TokenTypes.SLIST,
241            TokenTypes.SL_ASSIGN,
242            TokenTypes.SR,
243            TokenTypes.SR_ASSIGN,
244            TokenTypes.STAR,
245            TokenTypes.STAR_ASSIGN,
246            TokenTypes.LITERAL_ASSERT,
247            TokenTypes.TYPE_EXTENSION_AND,
248        };
249    }
250
251    @Override
252    public int[] getAcceptableTokens() {
253        return new int[] {
254            TokenTypes.ASSIGN,
255            TokenTypes.ARRAY_INIT,
256            TokenTypes.BAND,
257            TokenTypes.BAND_ASSIGN,
258            TokenTypes.BOR,
259            TokenTypes.BOR_ASSIGN,
260            TokenTypes.BSR,
261            TokenTypes.BSR_ASSIGN,
262            TokenTypes.BXOR,
263            TokenTypes.BXOR_ASSIGN,
264            TokenTypes.COLON,
265            TokenTypes.DIV,
266            TokenTypes.DIV_ASSIGN,
267            TokenTypes.DO_WHILE,
268            TokenTypes.EQUAL,
269            TokenTypes.GE,
270            TokenTypes.GT,
271            TokenTypes.LAMBDA,
272            TokenTypes.LAND,
273            TokenTypes.LCURLY,
274            TokenTypes.LE,
275            TokenTypes.LITERAL_CATCH,
276            TokenTypes.LITERAL_DO,
277            TokenTypes.LITERAL_ELSE,
278            TokenTypes.LITERAL_FINALLY,
279            TokenTypes.LITERAL_FOR,
280            TokenTypes.LITERAL_IF,
281            TokenTypes.LITERAL_RETURN,
282            TokenTypes.LITERAL_SWITCH,
283            TokenTypes.LITERAL_SYNCHRONIZED,
284            TokenTypes.LITERAL_TRY,
285            TokenTypes.LITERAL_WHILE,
286            TokenTypes.LOR,
287            TokenTypes.LT,
288            TokenTypes.MINUS,
289            TokenTypes.MINUS_ASSIGN,
290            TokenTypes.MOD,
291            TokenTypes.MOD_ASSIGN,
292            TokenTypes.NOT_EQUAL,
293            TokenTypes.PLUS,
294            TokenTypes.PLUS_ASSIGN,
295            TokenTypes.QUESTION,
296            TokenTypes.RCURLY,
297            TokenTypes.SL,
298            TokenTypes.SLIST,
299            TokenTypes.SL_ASSIGN,
300            TokenTypes.SR,
301            TokenTypes.SR_ASSIGN,
302            TokenTypes.STAR,
303            TokenTypes.STAR_ASSIGN,
304            TokenTypes.LITERAL_ASSERT,
305            TokenTypes.TYPE_EXTENSION_AND,
306            TokenTypes.WILDCARD_TYPE,
307            TokenTypes.GENERIC_START,
308            TokenTypes.GENERIC_END,
309            TokenTypes.ELLIPSIS,
310        };
311    }
312
313    @Override
314    public int[] getRequiredTokens() {
315        return CommonUtils.EMPTY_INT_ARRAY;
316    }
317
318    /**
319     * Sets whether or not empty method bodies are allowed.
320     * @param allow {@code true} to allow empty method bodies.
321     */
322    public void setAllowEmptyMethods(boolean allow) {
323        allowEmptyMethods = allow;
324    }
325
326    /**
327     * Sets whether or not empty constructor bodies are allowed.
328     * @param allow {@code true} to allow empty constructor bodies.
329     */
330    public void setAllowEmptyConstructors(boolean allow) {
331        allowEmptyConstructors = allow;
332    }
333
334    /**
335     * Sets whether or not to ignore the whitespace around the
336     * colon in an enhanced for loop.
337     * @param ignore {@code true} to ignore enhanced for colon.
338     */
339    public void setIgnoreEnhancedForColon(boolean ignore) {
340        ignoreEnhancedForColon = ignore;
341    }
342
343    /**
344     * Sets whether or not empty type bodies are allowed.
345     * @param allow {@code true} to allow empty type bodies.
346     */
347    public void setAllowEmptyTypes(boolean allow) {
348        allowEmptyTypes = allow;
349    }
350
351    /**
352     * Sets whether or not empty loop bodies are allowed.
353     * @param allow {@code true} to allow empty loops bodies.
354     */
355    public void setAllowEmptyLoops(boolean allow) {
356        allowEmptyLoops = allow;
357    }
358
359    /**
360     * Sets whether or not empty lambdas bodies are allowed.
361     * @param allow {@code true} to allow empty lambda expressions.
362     */
363    public void setAllowEmptyLambdas(boolean allow) {
364        allowEmptyLambdas = allow;
365    }
366
367    /**
368     * Sets whether or not empty catch blocks are allowed.
369     * @param allow {@code true} to allow empty catch blocks.
370     */
371    public void setAllowEmptyCatches(boolean allow) {
372        allowEmptyCatches = allow;
373    }
374
375    @Override
376    public void visitToken(DetailAST ast) {
377        final int currentType = ast.getType();
378        if (!isNotRelevantSituation(ast, currentType)) {
379            final String line = getLine(ast.getLineNo() - 1);
380            final int before = ast.getColumnNo() - 1;
381            final int after = ast.getColumnNo() + ast.getText().length();
382
383            if (before >= 0) {
384                final char prevChar = line.charAt(before);
385                if (shouldCheckSeparationFromPreviousToken(ast)
386                        && !Character.isWhitespace(prevChar)) {
387                    log(ast.getLineNo(), ast.getColumnNo(),
388                            MSG_WS_NOT_PRECEDED, ast.getText());
389                }
390            }
391
392            if (after < line.length()) {
393                final char nextChar = line.charAt(after);
394                if (shouldCheckSeparationFromNextToken(ast, nextChar)
395                        && !Character.isWhitespace(nextChar)) {
396                    log(ast.getLineNo(), ast.getColumnNo() + ast.getText().length(),
397                            MSG_WS_NOT_FOLLOWED, ast.getText());
398                }
399            }
400        }
401    }
402
403    /**
404     * Is ast not a target of Check.
405     * @param ast ast
406     * @param currentType type of ast
407     * @return true is ok to skip validation
408     */
409    private boolean isNotRelevantSituation(DetailAST ast, int currentType) {
410        final int parentType = ast.getParent().getType();
411        final boolean starImport = currentType == TokenTypes.STAR
412                && parentType == TokenTypes.DOT;
413        final boolean slistInsideCaseGroup = currentType == TokenTypes.SLIST
414                && parentType == TokenTypes.CASE_GROUP;
415
416        final boolean starImportOrSlistInsideCaseGroup = starImport || slistInsideCaseGroup;
417        final boolean colonOfCaseOrDefaultOrForEach =
418                isColonOfCaseOrDefault(currentType, parentType)
419                        || isColonOfForEach(currentType, parentType);
420        final boolean emptyBlockOrType =
421                isEmptyBlock(ast, parentType)
422                    || allowEmptyTypes && isEmptyType(ast);
423
424        return starImportOrSlistInsideCaseGroup
425                || colonOfCaseOrDefaultOrForEach
426                || emptyBlockOrType
427                || isArrayInitialization(currentType, parentType);
428    }
429
430    /**
431     * Check if it should be checked if previous token is separated from current by
432     * whitespace.
433     * This function is needed to recognise double brace initialization as valid,
434     * unfortunately its not possible to implement this functionality
435     * in isNotRelevantSituation method, because in this method when we return
436     * true(is not relevant) ast is later doesn't check at all. For example:
437     * new Properties() {{setProperty("double curly braces", "are not a style error");
438     * }};
439     * For second left curly brace in first line when we would return true from
440     * isNotRelevantSituation it wouldn't later check that the next token(setProperty)
441     * is not separated from previous token.
442     * @param ast current AST.
443     * @return true if it should be checked if previous token is separated by whitespace,
444     *      false otherwise.
445     */
446    private static boolean shouldCheckSeparationFromPreviousToken(DetailAST ast) {
447        return !isPartOfDoubleBraceInitializerForPreviousToken(ast);
448    }
449
450    /**
451     * Check if it should be checked if next token is separated from current by
452     * whitespace. Explanation why this method is needed is identical to one
453     * included in shouldCheckSeparationFromPreviousToken method.
454     * @param ast current AST.
455     * @param nextChar next character.
456     * @return true if it should be checked if next token is separated by whitespace,
457     *      false otherwise.
458     */
459    private static boolean shouldCheckSeparationFromNextToken(DetailAST ast, char nextChar) {
460        return !(ast.getType() == TokenTypes.LITERAL_RETURN
461                    && ast.getFirstChild().getType() == TokenTypes.SEMI)
462                && ast.getType() != TokenTypes.ARRAY_INIT
463                && !isAnonymousInnerClassEnd(ast.getType(), nextChar)
464                && !isPartOfDoubleBraceInitializerForNextToken(ast);
465    }
466
467    /**
468     * Check for "})" or "};" or "},". Happens with anon-inners
469     * @param currentType token
470     * @param nextChar next symbol
471     * @return true is that is end of anon inner class
472     */
473    private static boolean isAnonymousInnerClassEnd(int currentType, char nextChar) {
474        return currentType == TokenTypes.RCURLY
475                && (nextChar == ')'
476                        || nextChar == ';'
477                        || nextChar == ','
478                        || nextChar == '.');
479    }
480
481    /**
482     * Is empty block.
483     * @param ast ast
484     * @param parentType parent
485     * @return true is block is empty
486     */
487    private boolean isEmptyBlock(DetailAST ast, int parentType) {
488        return isEmptyMethodBlock(ast, parentType)
489                || isEmptyCtorBlock(ast, parentType)
490                || isEmptyLoop(ast, parentType)
491                || isEmptyLambda(ast, parentType)
492                || isEmptyCatch(ast, parentType);
493    }
494
495    /**
496     * Tests if a given {@code DetailAST} is part of an empty block.
497     * An example empty block might look like the following
498     * <p>
499     * <pre>   public void myMethod(int val) {}</pre>
500     * </p>
501     * In the above, the method body is an empty block ("{}").
502     *
503     * @param ast the {@code DetailAST} to test.
504     * @param parentType the token type of {@code ast}'s parent.
505     * @param match the parent token type we're looking to match.
506     * @return {@code true} if {@code ast} makes up part of an
507     *         empty block contained under a {@code match} token type
508     *         node.
509     */
510    private static boolean isEmptyBlock(DetailAST ast, int parentType, int match) {
511        final boolean result;
512        final int type = ast.getType();
513        if (type == TokenTypes.RCURLY) {
514            final DetailAST parent = ast.getParent();
515            final DetailAST grandParent = ast.getParent().getParent();
516            result = parentType == TokenTypes.SLIST
517                    && parent.getFirstChild().getType() == TokenTypes.RCURLY
518                    && grandParent.getType() == match;
519        }
520        else {
521            result = type == TokenTypes.SLIST
522                && parentType == match
523                && ast.getFirstChild().getType() == TokenTypes.RCURLY;
524        }
525        return result;
526    }
527
528    /**
529     * Whether colon belongs to cases or defaults.
530     * @param currentType current
531     * @param parentType parent
532     * @return true if current token in colon of case or default tokens
533     */
534    private static boolean isColonOfCaseOrDefault(int currentType, int parentType) {
535        return currentType == TokenTypes.COLON
536                && (parentType == TokenTypes.LITERAL_DEFAULT
537                        || parentType == TokenTypes.LITERAL_CASE);
538    }
539
540    /**
541     * Whether colon belongs to for-each.
542     * @param currentType current
543     * @param parentType parent
544     * @return true if current token in colon of for-each token
545     */
546    private boolean isColonOfForEach(int currentType, int parentType) {
547        return currentType == TokenTypes.COLON
548                && parentType == TokenTypes.FOR_EACH_CLAUSE
549                && ignoreEnhancedForColon;
550    }
551
552    /**
553     * Is array initialization.
554     * @param currentType current token
555     * @param parentType parent token
556     * @return true is current token inside array initialization
557     */
558    private static boolean isArrayInitialization(int currentType, int parentType) {
559        return (currentType == TokenTypes.RCURLY || currentType == TokenTypes.LCURLY)
560                && (parentType == TokenTypes.ARRAY_INIT
561                        || parentType == TokenTypes.ANNOTATION_ARRAY_INIT);
562    }
563
564    /**
565     * Test if the given {@code DetailAST} is part of an allowed empty
566     * method block.
567     * @param ast the {@code DetailAST} to test.
568     * @param parentType the token type of {@code ast}'s parent.
569     * @return {@code true} if {@code ast} makes up part of an
570     *         allowed empty method block.
571     */
572    private boolean isEmptyMethodBlock(DetailAST ast, int parentType) {
573        return allowEmptyMethods
574                && isEmptyBlock(ast, parentType, TokenTypes.METHOD_DEF);
575    }
576
577    /**
578     * Test if the given {@code DetailAST} is part of an allowed empty
579     * constructor (ctor) block.
580     * @param ast the {@code DetailAST} to test.
581     * @param parentType the token type of {@code ast}'s parent.
582     * @return {@code true} if {@code ast} makes up part of an
583     *         allowed empty constructor block.
584     */
585    private boolean isEmptyCtorBlock(DetailAST ast, int parentType) {
586        return allowEmptyConstructors
587                && isEmptyBlock(ast, parentType, TokenTypes.CTOR_DEF);
588    }
589
590    /**
591     * Checks if loop is empty.
592     * @param ast ast the {@code DetailAST} to test.
593     * @param parentType the token type of {@code ast}'s parent.
594     * @return {@code true} if {@code ast} makes up part of an
595     *         allowed empty loop block.
596     */
597    private boolean isEmptyLoop(DetailAST ast, int parentType) {
598        return allowEmptyLoops
599                && (isEmptyBlock(ast, parentType, TokenTypes.LITERAL_FOR)
600                        || isEmptyBlock(ast, parentType, TokenTypes.LITERAL_WHILE)
601                        || isEmptyBlock(ast, parentType, TokenTypes.LITERAL_DO));
602    }
603
604    /**
605     * Test if the given {@code DetailAST} is part of an allowed empty
606     * lambda block.
607     * @param ast the {@code DetailAST} to test.
608     * @param parentType the token type of {@code ast}'s parent.
609     * @return {@code true} if {@code ast} makes up part of an
610     *         allowed empty lambda block.
611     */
612    private boolean isEmptyLambda(DetailAST ast, int parentType) {
613        return allowEmptyLambdas && isEmptyBlock(ast, parentType, TokenTypes.LAMBDA);
614    }
615
616    /**
617     * Tests if the given {@code DetailAst} is part of an allowed empty
618     * catch block.
619     * @param ast the {@code DetailAst} to test.
620     * @param parentType the token type of {@code ast}'s parent
621     * @return {@code true} if {@code ast} makes up part of an
622     *         allowed empty catch block.
623     */
624    private boolean isEmptyCatch(DetailAST ast, int parentType) {
625        return allowEmptyCatches && isEmptyBlock(ast, parentType, TokenTypes.LITERAL_CATCH);
626    }
627
628    /**
629     * Test if the given {@code DetailAST} is part of an empty block.
630     * An example empty block might look like the following
631     * <p>
632     * <pre>   class Foo {}</pre>
633     * </p>
634     *
635     * @param ast ast the {@code DetailAST} to test.
636     * @return {@code true} if {@code ast} makes up part of an
637     *         empty block contained under a {@code match} token type
638     *         node.
639     */
640    private static boolean isEmptyType(DetailAST ast) {
641        final int type = ast.getType();
642        final DetailAST nextSibling = ast.getNextSibling();
643        final DetailAST previousSibling = ast.getPreviousSibling();
644        return type == TokenTypes.LCURLY
645                    && nextSibling.getType() == TokenTypes.RCURLY
646                || type == TokenTypes.RCURLY
647                    && previousSibling != null
648                    && previousSibling.getType() == TokenTypes.LCURLY;
649    }
650
651    /**
652     * Check if given ast is part of double brace initializer and if it
653     * should omit checking if previous token is separated by whitespace.
654     * @param ast ast to check
655     * @return true if it should omit checking for previous token, false otherwise
656     */
657    private static boolean isPartOfDoubleBraceInitializerForPreviousToken(DetailAST ast) {
658        final boolean initializerBeginsAfterClassBegins = ast.getType() == TokenTypes.SLIST
659                && ast.getParent().getType() == TokenTypes.INSTANCE_INIT;
660        final boolean classEndsAfterInitializerEnds = ast.getType() == TokenTypes.RCURLY
661                && ast.getPreviousSibling() != null
662                && ast.getPreviousSibling().getType() == TokenTypes.INSTANCE_INIT;
663        return initializerBeginsAfterClassBegins || classEndsAfterInitializerEnds;
664    }
665
666    /**
667     * Check if given ast is part of double brace initializer and if it
668     * should omit checking if next token is separated by whitespace.
669     * See <a href="https://github.com/checkstyle/checkstyle/pull/2845">
670     * PR#2845</a> for more information why this function was needed.
671     * @param ast ast to check
672     * @return true if it should omit checking for next token, false otherwise
673     */
674    private static boolean isPartOfDoubleBraceInitializerForNextToken(DetailAST ast) {
675        final boolean classBeginBeforeInitializerBegin = ast.getType() == TokenTypes.LCURLY
676            && ast.getNextSibling().getType() == TokenTypes.INSTANCE_INIT;
677        final boolean initializerEndsBeforeClassEnds = ast.getType() == TokenTypes.RCURLY
678            && ast.getParent().getType() == TokenTypes.SLIST
679            && ast.getParent().getParent().getType() == TokenTypes.INSTANCE_INIT
680            && ast.getParent().getParent().getNextSibling().getType() == TokenTypes.RCURLY;
681        return classBeginBeforeInitializerBegin || initializerEndsBeforeClassEnds;
682    }
683
684}