Source code

001///////////////////////////////////////////////////////////////////////////////////////////////
002// checkstyle: Checks Java source code and other text files for adherence to a set of rules.
003// Copyright (C) 2001-2025 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;
021
022import java.util.Optional;
023import java.util.Set;
024import java.util.regex.Pattern;
025
026import com.puppycrawl.tools.checkstyle.FileStatefulCheck;
027import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
028import com.puppycrawl.tools.checkstyle.api.DetailAST;
029import com.puppycrawl.tools.checkstyle.api.FullIdent;
030import com.puppycrawl.tools.checkstyle.api.TokenTypes;
031
032/**
033 * <div>
034 * Detects uncommented {@code main} methods.
035 * </div>
036 *
037 * <p>
038 * Rationale: A {@code main} method is often used for debugging purposes.
039 * When debugging is finished, developers often forget to remove the method,
040 * which changes the API and increases the size of the resulting class or JAR file.
041 * Except for the real program entry points, all {@code main} methods
042 * should be removed or commented out of the sources.
043 * </p>
044 * <ul>
045 * <li>
046 * Property {@code excludedClasses} - Specify pattern for qualified names of
047 * classes which are allowed to have a {@code main} method.
048 * Type is {@code java.util.regex.Pattern}.
049 * Default value is {@code "^$"}.
050 * </li>
051 * </ul>
052 *
053 * <p>
054 * Parent is {@code com.puppycrawl.tools.checkstyle.TreeWalker}
055 * </p>
056 *
057 * <p>
058 * Violation Message Keys:
059 * </p>
060 * <ul>
061 * <li>
062 * {@code uncommented.main}
063 * </li>
064 * </ul>
065 *
066 * @since 3.2
067 */
068@FileStatefulCheck
069public class UncommentedMainCheck
070    extends AbstractCheck {
071
072    /**
073     * A key is pointing to the warning message text in "messages.properties"
074     * file.
075     */
076    public static final String MSG_KEY = "uncommented.main";
077
078    /** Set of possible String array types. */
079    private static final Set<String> STRING_PARAMETER_NAMES = Set.of(
080        String[].class.getCanonicalName(),
081        String.class.getCanonicalName(),
082        String[].class.getSimpleName(),
083        String.class.getSimpleName()
084    );
085
086    /**
087     * Specify pattern for qualified names of classes which are allowed to
088     * have a {@code main} method.
089     */
090    private Pattern excludedClasses = Pattern.compile("^$");
091    /** Current class name. */
092    private String currentClass;
093    /** Current package. */
094    private FullIdent packageName;
095    /** Class definition depth. */
096    private int classDepth;
097
098    /**
099     * Setter to specify pattern for qualified names of classes which are allowed
100     * to have a {@code main} method.
101     *
102     * @param excludedClasses a pattern
103     * @since 3.2
104     */
105    public void setExcludedClasses(Pattern excludedClasses) {
106        this.excludedClasses = excludedClasses;
107    }
108
109    @Override
110    public int[] getAcceptableTokens() {
111        return getRequiredTokens();
112    }
113
114    @Override
115    public int[] getDefaultTokens() {
116        return getRequiredTokens();
117    }
118
119    @Override
120    public int[] getRequiredTokens() {
121        return new int[] {
122            TokenTypes.METHOD_DEF,
123            TokenTypes.CLASS_DEF,
124            TokenTypes.PACKAGE_DEF,
125            TokenTypes.RECORD_DEF,
126        };
127    }
128
129    @Override
130    public void beginTree(DetailAST rootAST) {
131        packageName = FullIdent.createFullIdent(null);
132        classDepth = 0;
133    }
134
135    @Override
136    public void leaveToken(DetailAST ast) {
137        if (ast.getType() == TokenTypes.CLASS_DEF) {
138            classDepth--;
139        }
140    }
141
142    @Override
143    public void visitToken(DetailAST ast) {
144        switch (ast.getType()) {
145            case TokenTypes.PACKAGE_DEF -> visitPackageDef(ast);
146            case TokenTypes.RECORD_DEF, TokenTypes.CLASS_DEF -> visitClassOrRecordDef(ast);
147            case TokenTypes.METHOD_DEF -> visitMethodDef(ast);
148            default -> throw new IllegalStateException(ast.toString());
149        }
150    }
151
152    /**
153     * Sets current package.
154     *
155     * @param packageDef node for package definition
156     */
157    private void visitPackageDef(DetailAST packageDef) {
158        packageName = FullIdent.createFullIdent(packageDef.getLastChild()
159                .getPreviousSibling());
160    }
161
162    /**
163     * If not inner class then change current class name.
164     *
165     * @param classOrRecordDef node for class or record definition
166     */
167    private void visitClassOrRecordDef(DetailAST classOrRecordDef) {
168        // we are not use inner classes because they can not
169        // have static methods
170        if (classDepth == 0) {
171            final DetailAST ident = classOrRecordDef.findFirstToken(TokenTypes.IDENT);
172            currentClass = packageName.getText() + "." + ident.getText();
173            classDepth++;
174        }
175    }
176
177    /**
178     * Checks method definition if this is
179     * {@code public static void main(String[])}.
180     *
181     * @param method method definition node
182     */
183    private void visitMethodDef(DetailAST method) {
184        if (classDepth == 1
185                // method not in inner class or in interface definition
186                && checkClassName()
187                && checkName(method)
188                && checkModifiers(method)
189                && checkType(method)
190                && checkParams(method)) {
191            log(method, MSG_KEY);
192        }
193    }
194
195    /**
196     * Checks that current class is not excluded.
197     *
198     * @return true if check passed, false otherwise
199     */
200    private boolean checkClassName() {
201        return !excludedClasses.matcher(currentClass).find();
202    }
203
204    /**
205     * Checks that method name is @quot;main@quot;.
206     *
207     * @param method the METHOD_DEF node
208     * @return true if check passed, false otherwise
209     */
210    private static boolean checkName(DetailAST method) {
211        final DetailAST ident = method.findFirstToken(TokenTypes.IDENT);
212        return "main".equals(ident.getText());
213    }
214
215    /**
216     * Checks that method has final and static modifiers.
217     *
218     * @param method the METHOD_DEF node
219     * @return true if check passed, false otherwise
220     */
221    private static boolean checkModifiers(DetailAST method) {
222        final DetailAST modifiers =
223            method.findFirstToken(TokenTypes.MODIFIERS);
224
225        return modifiers.findFirstToken(TokenTypes.LITERAL_PUBLIC) != null
226            && modifiers.findFirstToken(TokenTypes.LITERAL_STATIC) != null;
227    }
228
229    /**
230     * Checks that return type is {@code void}.
231     *
232     * @param method the METHOD_DEF node
233     * @return true if check passed, false otherwise
234     */
235    private static boolean checkType(DetailAST method) {
236        final DetailAST type =
237            method.findFirstToken(TokenTypes.TYPE).getFirstChild();
238        return type.getType() == TokenTypes.LITERAL_VOID;
239    }
240
241    /**
242     * Checks that method has only {@code String[]} or only {@code String...} param.
243     *
244     * @param method the METHOD_DEF node
245     * @return true if check passed, false otherwise
246     */
247    private static boolean checkParams(DetailAST method) {
248        boolean checkPassed = false;
249        final DetailAST params = method.findFirstToken(TokenTypes.PARAMETERS);
250
251        if (params.getChildCount() == 1) {
252            final DetailAST parameterType = params.getFirstChild().findFirstToken(TokenTypes.TYPE);
253            final boolean isArrayDeclaration =
254                parameterType.findFirstToken(TokenTypes.ARRAY_DECLARATOR) != null;
255            final Optional<DetailAST> varargs = Optional.ofNullable(
256                params.getFirstChild().findFirstToken(TokenTypes.ELLIPSIS));
257
258            if (isArrayDeclaration || varargs.isPresent()) {
259                checkPassed = isStringType(parameterType.getFirstChild());
260            }
261        }
262        return checkPassed;
263    }
264
265    /**
266     * Whether the type is java.lang.String.
267     *
268     * @param typeAst the type to check.
269     * @return true, if the type is java.lang.String.
270     */
271    private static boolean isStringType(DetailAST typeAst) {
272        final FullIdent type = FullIdent.createFullIdent(typeAst);
273        return STRING_PARAMETER_NAMES.contains(type.getText());
274    }
275
276}