1 /*

     2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.tools.javadoc.main;

    27 

    28 import java.lang.reflect.Modifier;

    29 

    30 import com.sun.javadoc.*;

    31 import com.sun.source.util.TreePath;

    32 import com.sun.tools.javac.code.*;

    33 import com.sun.tools.javac.code.Symbol.*;

    34 import com.sun.tools.javac.code.Type;

    35 import static com.sun.tools.javac.code.TypeTag.CLASS;

    36 

    37 /**

    38  * Represents a method of a java class.

    39  *

    40  *  <p><b>This is NOT part of any supported API.

    41  *  If you write code that depends on this, you do so at your own risk.

    42  *  This code and its internal interfaces are subject to change or

    43  *  deletion without notice.</b>

    44  *

    45  * @since 1.2

    46  * @author Robert Field

    47  * @author Neal Gafter (rewrite)

    48  */

    49 

    50 public class MethodDocImpl

    51         extends ExecutableMemberDocImpl implements MethodDoc {

    52 

    53     /**

    54      * constructor.

    55      */

    56     public MethodDocImpl(DocEnv env, MethodSymbol sym) {

    57         super(env, sym);

    58     }

    59 

    60     /**

    61      * constructor.

    62      */

    63     public MethodDocImpl(DocEnv env, MethodSymbol sym, TreePath treePath) {

    64         super(env, sym, treePath);

    65     }

    66 

    67     /**

    68      * Return true if it is a method, which it is.

    69      * Note: constructors are not methods.

    70      * This method is overridden by AnnotationTypeElementDocImpl.

    71      *

    72      * @return true

    73      */

    74     public boolean isMethod() {

    75         return true;

    76     }

    77 

    78     /**

    79      * Return true if this method is default

    80      */

    81     public boolean isDefault() {

    82         return (sym.flags() & Flags.DEFAULT) != 0;

    83     }

    84 

    85     /**

    86      * Return true if this method is abstract

    87      */

    88     public boolean isAbstract() {

    89         return (Modifier.isAbstract(getModifiers()) && !isDefault());

    90     }

    91 

    92     /**

    93      * Get return type.

    94      *

    95      * @return the return type of this method, null if it

    96      * is a constructor.

    97      */

    98     public com.sun.javadoc.Type returnType() {

    99         return TypeMaker.getType(env, sym.type.getReturnType(), false);

   100     }

   101 

   102     /**

   103      * Return the class that originally defined the method that

   104      * is overridden by the current definition, or null if no

   105      * such class exists.

   106      *

   107      * @return a ClassDocImpl representing the superclass that

   108      * originally defined this method, null if this method does

   109      * not override a definition in a superclass.

   110      */

   111     public ClassDoc overriddenClass() {

   112         com.sun.javadoc.Type t = overriddenType();

   113         return (t != null) ? t.asClassDoc() : null;

   114     }

   115 

   116     /**

   117      * Return the type containing the method that this method overrides.

   118      * It may be a <code>ClassDoc</code> or a <code>ParameterizedType</code>.

   119      */

   120     public com.sun.javadoc.Type overriddenType() {

   121 

   122         if ((sym.flags() & Flags.STATIC) != 0) {

   123             return null;

   124         }

   125 

   126         ClassSymbol origin = (ClassSymbol)sym.owner;

   127         for (Type t = env.types.supertype(origin.type);

   128              t.hasTag(CLASS);

   129              t = env.types.supertype(t)) {

   130             ClassSymbol c = (ClassSymbol)t.tsym;

   131             for (Symbol sym2 : membersOf(c).getSymbolsByName(sym.name)) {

   132                 if (sym.overrides(sym2, origin, env.types, true)) {

   133                     return TypeMaker.getType(env, t);

   134                 }

   135             }

   136         }

   137         return null;

   138     }

   139 

   140     /**

   141      * Return the method that this method overrides.

   142      *

   143      * @return a MethodDoc representing a method definition

   144      * in a superclass this method overrides, null if

   145      * this method does not override.

   146      */

   147     public MethodDoc overriddenMethod() {

   148 

   149         // Real overriding only.  Static members are simply hidden.

   150         // Likewise for constructors, but the MethodSymbol.overrides

   151         // method takes this into account.

   152         if ((sym.flags() & Flags.STATIC) != 0) {

   153             return null;

   154         }

   155 

   156         // Derived from  com.sun.tools.javac.comp.Check.checkOverride .

   157 

   158         ClassSymbol origin = (ClassSymbol)sym.owner;

   159         for (Type t = env.types.supertype(origin.type);

   160              t.hasTag(CLASS);

   161              t = env.types.supertype(t)) {

   162             ClassSymbol c = (ClassSymbol)t.tsym;

   163             for (Symbol sym2 : membersOf(c).getSymbolsByName(sym.name)) {

   164                 if (sym.overrides(sym2, origin, env.types, true)) {

   165                     return env.getMethodDoc((MethodSymbol)sym2);

   166                 }

   167             }

   168         }

   169         return null;

   170     }

   171 

   172     /**Retrieve members of c, ignoring any CompletionFailures that occur. */

   173     private Scope membersOf(ClassSymbol c) {

   174         try {

   175             return c.members();

   176         } catch (CompletionFailure cf) {

   177             /* Quietly ignore completion failures and try again - the type

   178              * for which the CompletionFailure was thrown shouldn't be completed

   179              * again by the completer that threw the CompletionFailure.

   180              */

   181             return membersOf(c);

   182         }

   183     }

   184 

   185     /**

   186      * Tests whether this method overrides another.

   187      * The overridden method may be one declared in a superclass or

   188      * a superinterface (unlike {@link #overriddenMethod()}).

   189      *

   190      * <p> When a non-abstract method overrides an abstract one, it is

   191      * also said to <i>implement</i> the other.

   192      *

   193      * @param meth  the other method to examine

   194      * @return <tt>true</tt> if this method overrides the other

   195      */

   196     public boolean overrides(MethodDoc meth) {

   197         MethodSymbol overridee = ((MethodDocImpl) meth).sym;

   198         ClassSymbol origin = (ClassSymbol) sym.owner;

   199 

   200         return sym.name == overridee.name &&

   201 

   202                // not reflexive as per JLS

   203                sym != overridee &&

   204 

   205                // we don't care if overridee is static, though that wouldn't

   206                // compile

   207                !sym.isStatic() &&

   208 

   209                // sym, whose declaring type is the origin, must be

   210                // in a subtype of overridee's type

   211                env.types.asSuper(origin.type, overridee.owner) != null &&

   212 

   213                // check access and signatures; don't check return types

   214                sym.overrides(overridee, origin, env.types, false);

   215     }

   216 

   217 

   218     public String name() {

   219         if (name == null) {

   220             name = sym.name.toString();

   221         }

   222         return name;

   223     }

   224 

   225     private String name;

   226 

   227     public String qualifiedName() {

   228         if (qualifiedName == null) {

   229             qualifiedName =  sym.enclClass().getQualifiedName() + "." + sym.name;

   230         }

   231         return qualifiedName;

   232     }

   233 

   234     private String qualifiedName;

   235 

   236     /**

   237      * Returns a string representation of this method.  Includes the

   238      * qualified signature, the qualified method name, and any type

   239      * parameters.  Type parameters follow the class name, as they do

   240      * in the syntax for invoking methods with explicit type parameters.

   241      */

   242     public String toString() {

   243         return sym.enclClass().getQualifiedName() +

   244                 "." + typeParametersString() + name() + signature();

   245     }

   246 }