001////////////////////////////////////////////////////////////////////////////////
002// checkstyle: Checks Java source code for adherence to a set of rules.
003// Copyright (C) 2001-2017 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.coding;
021
022import java.util.Deque;
023import java.util.LinkedList;
024
025import antlr.collections.AST;
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.TokenTypes;
030import com.puppycrawl.tools.checkstyle.utils.ScopeUtils;
031
032/**
033 * <p>
034 * Abstract class for checking that an overriding method with no parameters
035 * invokes the super method.
036 * </p>
037 * @author Rick Giles
038 */
039@FileStatefulCheck
040public abstract class AbstractSuperCheck
041        extends AbstractCheck {
042
043    /**
044     * A key is pointing to the warning message text in "messages.properties"
045     * file.
046     */
047    public static final String MSG_KEY = "missing.super.call";
048
049    /** Stack of methods. */
050    private final Deque<MethodNode> methodStack = new LinkedList<>();
051
052    /**
053     * Returns the name of the overriding method.
054     * @return the name of the overriding method.
055     */
056    protected abstract String getMethodName();
057
058    @Override
059    public int[] getAcceptableTokens() {
060        return getRequiredTokens();
061    }
062
063    @Override
064    public int[] getDefaultTokens() {
065        return getRequiredTokens();
066    }
067
068    @Override
069    public int[] getRequiredTokens() {
070        return new int[] {
071            TokenTypes.METHOD_DEF,
072            TokenTypes.LITERAL_SUPER,
073        };
074    }
075
076    @Override
077    public void beginTree(DetailAST rootAST) {
078        methodStack.clear();
079    }
080
081    @Override
082    public void visitToken(DetailAST ast) {
083        if (isOverridingMethod(ast)) {
084            methodStack.add(new MethodNode(ast));
085        }
086        else if (isSuperCall(ast)) {
087            final MethodNode methodNode = methodStack.getLast();
088            methodNode.setCallingSuper();
089        }
090    }
091
092    /**
093     * Determines whether a 'super' literal is a call to the super method
094     * for this check.
095     * @param literalSuperAst the AST node of a 'super' literal.
096     * @return true if ast is a call to the super method for this check.
097     */
098    private boolean isSuperCall(DetailAST literalSuperAst) {
099        boolean superCall = false;
100
101        if (literalSuperAst.getType() == TokenTypes.LITERAL_SUPER) {
102            // dot operator?
103            final DetailAST dotAst = literalSuperAst.getParent();
104
105            if (!isSameNameMethod(literalSuperAst)
106                && !hasArguments(dotAst)) {
107                superCall = isSuperCallInOverridingMethod(dotAst);
108            }
109        }
110        return superCall;
111    }
112
113    /**
114     * Determines whether a super call in overriding method.
115     *
116     * @param ast The AST node of a 'dot operator' in 'super' call.
117     * @return true if super call in overriding method.
118     */
119    private boolean isSuperCallInOverridingMethod(DetailAST ast) {
120        boolean inOverridingMethod = false;
121        DetailAST dotAst = ast;
122
123        while (dotAst.getType() != TokenTypes.CTOR_DEF
124                && dotAst.getType() != TokenTypes.INSTANCE_INIT) {
125
126            if (dotAst.getType() == TokenTypes.METHOD_DEF) {
127                inOverridingMethod = isOverridingMethod(dotAst);
128                break;
129            }
130            dotAst = dotAst.getParent();
131
132        }
133        return inOverridingMethod;
134    }
135
136    /**
137     * Does method have any arguments.
138     * @param methodCallDotAst DOT DetailAST
139     * @return true if any parameters found
140     */
141    private static boolean hasArguments(DetailAST methodCallDotAst) {
142        final DetailAST argumentsList = methodCallDotAst.getNextSibling();
143        return argumentsList.getChildCount() > 0;
144    }
145
146    /**
147     * Is same name of method.
148     * @param ast method AST
149     * @return true if method name is the same
150     */
151    private boolean isSameNameMethod(DetailAST ast) {
152
153        AST sibling = ast.getNextSibling();
154        // ignore type parameters
155        if (sibling != null
156            && sibling.getType() == TokenTypes.TYPE_ARGUMENTS) {
157            sibling = sibling.getNextSibling();
158        }
159        return sibling == null || !getMethodName().equals(sibling.getText());
160    }
161
162    @Override
163    public void leaveToken(DetailAST ast) {
164        if (isOverridingMethod(ast)) {
165            final MethodNode methodNode =
166                methodStack.removeLast();
167            if (!methodNode.isCallingSuper()) {
168                final DetailAST methodAST = methodNode.getMethod();
169                final DetailAST nameAST =
170                    methodAST.findFirstToken(TokenTypes.IDENT);
171                log(nameAST.getLineNo(), nameAST.getColumnNo(),
172                    MSG_KEY, nameAST.getText());
173            }
174        }
175    }
176
177    /**
178     * Determines whether an AST is a method definition for this check,
179     * with 0 parameters.
180     * @param ast the method definition AST.
181     * @return true if the method of ast is a method for this check.
182     */
183    private boolean isOverridingMethod(DetailAST ast) {
184        boolean overridingMethod = false;
185
186        if (ast.getType() == TokenTypes.METHOD_DEF
187                && !ScopeUtils.isInInterfaceOrAnnotationBlock(ast)) {
188            final DetailAST nameAST = ast.findFirstToken(TokenTypes.IDENT);
189            final String name = nameAST.getText();
190            final DetailAST modifiersAST = ast.findFirstToken(TokenTypes.MODIFIERS);
191
192            if (getMethodName().equals(name)
193                    && modifiersAST.findFirstToken(TokenTypes.LITERAL_NATIVE) == null) {
194                final DetailAST params = ast.findFirstToken(TokenTypes.PARAMETERS);
195                overridingMethod = params.getChildCount() == 0;
196            }
197        }
198        return overridingMethod;
199    }
200
201    /**
202     * Stack node for a method definition and a record of
203     * whether the method has a call to the super method.
204     * @author Rick Giles
205     */
206    private static class MethodNode {
207        /** Method definition. */
208        private final DetailAST method;
209
210        /** True if the overriding method calls the super method. */
211        private boolean callingSuper;
212
213        /**
214         * Constructs a stack node for a method definition.
215         * @param ast AST for the method definition.
216         */
217        MethodNode(DetailAST ast) {
218            method = ast;
219            callingSuper = false;
220        }
221
222        /**
223         * Records that the overriding method has a call to the super method.
224         */
225        public void setCallingSuper() {
226            callingSuper = true;
227        }
228
229        /**
230         * Determines whether the overriding method has a call to the super
231         * method.
232         * @return true if the overriding method has a call to the super method.
233         */
234        public boolean isCallingSuper() {
235            return callingSuper;
236        }
237
238        /**
239         * Returns the overriding method definition AST.
240         * @return the overriding method definition AST.
241         */
242        public DetailAST getMethod() {
243            return method;
244        }
245    }
246}