langtools/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/main/ClassDocImpl.java
author jjg
Mon, 09 May 2016 16:52:15 -0700
changeset 37938 42baa89d2156
parent 36526 langtools/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/ClassDocImpl.java@3b41f1c69604
child 38617 d93a7f64e231
permissions -rw-r--r--
8075703: jdk.javadoc module exports com.sun.tools.javadoc package which contains a lot of internal API. Reviewed-by: ksrini
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     1
/*
30066
d74c06a92bd8 8078600: Infinite loop when compiling annotations with -XDcompletionDeps
alundblad
parents: 27224
diff changeset
     2
 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
06bc494ca11e Initial load
duke
parents:
diff changeset
     4
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
06bc494ca11e Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 3782
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 3782
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    10
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
06bc494ca11e Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
06bc494ca11e Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
06bc494ca11e Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
06bc494ca11e Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
06bc494ca11e Initial load
duke
parents:
diff changeset
    16
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
06bc494ca11e Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
06bc494ca11e Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
06bc494ca11e Initial load
duke
parents:
diff changeset
    20
 *
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 3782
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 3782
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 3782
diff changeset
    23
 * questions.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    24
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    25
37938
42baa89d2156 8075703: jdk.javadoc module exports com.sun.tools.javadoc package which contains a lot of internal API.
jjg
parents: 36526
diff changeset
    26
package com.sun.tools.javadoc.main;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    27
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    28
import java.io.File;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    29
import java.io.IOException;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    30
import java.lang.reflect.Modifier;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    31
import java.net.URI;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    32
import java.util.HashSet;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    33
import java.util.Set;
14802
969e90f68ac5 8004828: refactor init of *DocImpl classes
jjg
parents: 14359
diff changeset
    34
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    35
import javax.tools.FileObject;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    36
import javax.tools.JavaFileManager.Location;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    37
import javax.tools.StandardJavaFileManager;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    38
import javax.tools.StandardLocation;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    39
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    40
import com.sun.javadoc.*;
14802
969e90f68ac5 8004828: refactor init of *DocImpl classes
jjg
parents: 14359
diff changeset
    41
import com.sun.source.util.TreePath;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    42
import com.sun.tools.javac.code.Flags;
06bc494ca11e Initial load
duke
parents:
diff changeset
    43
import com.sun.tools.javac.code.Kinds;
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
    44
import com.sun.tools.javac.code.Kinds.KindSelector;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    45
import com.sun.tools.javac.code.Scope;
06bc494ca11e Initial load
duke
parents:
diff changeset
    46
import com.sun.tools.javac.code.Symbol;
06bc494ca11e Initial load
duke
parents:
diff changeset
    47
import com.sun.tools.javac.code.Symbol.*;
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    48
import com.sun.tools.javac.code.Type;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    49
import com.sun.tools.javac.code.Type.ClassType;
18915
dcc9c8265f65 8016640: compiler hangs if the generics arity of a base class is wrong
mcimadamore
parents: 17275
diff changeset
    50
import com.sun.tools.javac.code.TypeTag;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    51
import com.sun.tools.javac.comp.AttrContext;
06bc494ca11e Initial load
duke
parents:
diff changeset
    52
import com.sun.tools.javac.comp.Env;
06bc494ca11e Initial load
duke
parents:
diff changeset
    53
import com.sun.tools.javac.tree.JCTree;
06bc494ca11e Initial load
duke
parents:
diff changeset
    54
import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
06bc494ca11e Initial load
duke
parents:
diff changeset
    55
import com.sun.tools.javac.tree.JCTree.JCImport;
06bc494ca11e Initial load
duke
parents:
diff changeset
    56
import com.sun.tools.javac.tree.TreeInfo;
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    57
import com.sun.tools.javac.util.List;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    58
import com.sun.tools.javac.util.ListBuffer;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    59
import com.sun.tools.javac.util.Name;
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 10
diff changeset
    60
import com.sun.tools.javac.util.Names;
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
    61
import com.sun.tools.javac.util.Position;
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
    62
import static com.sun.tools.javac.code.Kinds.Kind.*;
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
    63
import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;
14359
d4099818ab70 7200915: convert TypeTags from a series of small ints to an enum
jjg
parents: 14260
diff changeset
    64
import static com.sun.tools.javac.code.TypeTag.CLASS;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 10203
diff changeset
    65
import static com.sun.tools.javac.tree.JCTree.Tag.*;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    66
06bc494ca11e Initial load
duke
parents:
diff changeset
    67
/**
06bc494ca11e Initial load
duke
parents:
diff changeset
    68
 * Represents a java class and provides access to information
06bc494ca11e Initial load
duke
parents:
diff changeset
    69
 * about the class, the class' comment and tags, and the
06bc494ca11e Initial load
duke
parents:
diff changeset
    70
 * members of the class.  A ClassDocImpl only exists if it was
06bc494ca11e Initial load
duke
parents:
diff changeset
    71
 * processed in this run of javadoc.  References to classes
06bc494ca11e Initial load
duke
parents:
diff changeset
    72
 * which may or may not have been processed in this run are
06bc494ca11e Initial load
duke
parents:
diff changeset
    73
 * referred to using Type (which can be converted to ClassDocImpl,
06bc494ca11e Initial load
duke
parents:
diff changeset
    74
 * if possible).
06bc494ca11e Initial load
duke
parents:
diff changeset
    75
 *
14260
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14259
diff changeset
    76
 *  <p><b>This is NOT part of any supported API.
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14259
diff changeset
    77
 *  If you write code that depends on this, you do so at your own risk.
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14259
diff changeset
    78
 *  This code and its internal interfaces are subject to change or
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14259
diff changeset
    79
 *  deletion without notice.</b>
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14259
diff changeset
    80
 *
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    81
 * @see Type
06bc494ca11e Initial load
duke
parents:
diff changeset
    82
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    83
 * @since 1.2
06bc494ca11e Initial load
duke
parents:
diff changeset
    84
 * @author Robert Field
06bc494ca11e Initial load
duke
parents:
diff changeset
    85
 * @author Neal Gafter (rewrite)
06bc494ca11e Initial load
duke
parents:
diff changeset
    86
 * @author Scott Seligman (generics, enums, annotations)
06bc494ca11e Initial load
duke
parents:
diff changeset
    87
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    88
06bc494ca11e Initial load
duke
parents:
diff changeset
    89
public class ClassDocImpl extends ProgramElementDocImpl implements ClassDoc {
06bc494ca11e Initial load
duke
parents:
diff changeset
    90
06bc494ca11e Initial load
duke
parents:
diff changeset
    91
    public final ClassType type;        // protected->public for debugging
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 32800
diff changeset
    92
    public final ClassSymbol tsym;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    93
06bc494ca11e Initial load
duke
parents:
diff changeset
    94
    boolean isIncluded = false;         // Set in RootDocImpl
06bc494ca11e Initial load
duke
parents:
diff changeset
    95
06bc494ca11e Initial load
duke
parents:
diff changeset
    96
    private SerializedForm serializedForm;
06bc494ca11e Initial load
duke
parents:
diff changeset
    97
06bc494ca11e Initial load
duke
parents:
diff changeset
    98
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    99
     * Constructor
06bc494ca11e Initial load
duke
parents:
diff changeset
   100
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   101
    public ClassDocImpl(DocEnv env, ClassSymbol sym) {
14802
969e90f68ac5 8004828: refactor init of *DocImpl classes
jjg
parents: 14359
diff changeset
   102
        this(env, sym, null);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   103
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   104
06bc494ca11e Initial load
duke
parents:
diff changeset
   105
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   106
     * Constructor
06bc494ca11e Initial load
duke
parents:
diff changeset
   107
     */
14802
969e90f68ac5 8004828: refactor init of *DocImpl classes
jjg
parents: 14359
diff changeset
   108
    public ClassDocImpl(DocEnv env, ClassSymbol sym, TreePath treePath) {
969e90f68ac5 8004828: refactor init of *DocImpl classes
jjg
parents: 14359
diff changeset
   109
        super(env, sym, treePath);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   110
        this.type = (ClassType)sym.type;
06bc494ca11e Initial load
duke
parents:
diff changeset
   111
        this.tsym = sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
   112
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   113
16969
b58d8a70d921 8009686: Generated javadoc documentation should be able to display type annotation on an array
bpatel
parents: 15385
diff changeset
   114
    public com.sun.javadoc.Type getElementType() {
b58d8a70d921 8009686: Generated javadoc documentation should be able to display type annotation on an array
bpatel
parents: 15385
diff changeset
   115
        return null;
b58d8a70d921 8009686: Generated javadoc documentation should be able to display type annotation on an array
bpatel
parents: 15385
diff changeset
   116
    }
b58d8a70d921 8009686: Generated javadoc documentation should be able to display type annotation on an array
bpatel
parents: 15385
diff changeset
   117
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   118
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   119
     * Returns the flags in terms of javac's flags
06bc494ca11e Initial load
duke
parents:
diff changeset
   120
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   121
    protected long getFlags() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   122
        return getFlags(tsym);
06bc494ca11e Initial load
duke
parents:
diff changeset
   123
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   124
06bc494ca11e Initial load
duke
parents:
diff changeset
   125
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   126
     * Returns the flags of a ClassSymbol in terms of javac's flags
06bc494ca11e Initial load
duke
parents:
diff changeset
   127
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   128
    static long getFlags(ClassSymbol clazz) {
32800
8457813125e3 8135307: CompletionFailure thrown when calling FieldDoc.type, if the field's type is missing
jlahoda
parents: 31751
diff changeset
   129
        try {
8457813125e3 8135307: CompletionFailure thrown when calling FieldDoc.type, if the field's type is missing
jlahoda
parents: 31751
diff changeset
   130
            return clazz.flags();
8457813125e3 8135307: CompletionFailure thrown when calling FieldDoc.type, if the field's type is missing
jlahoda
parents: 31751
diff changeset
   131
        } catch (CompletionFailure ex) {
8457813125e3 8135307: CompletionFailure thrown when calling FieldDoc.type, if the field's type is missing
jlahoda
parents: 31751
diff changeset
   132
            /* Quietly ignore completion failures and try again - the type
8457813125e3 8135307: CompletionFailure thrown when calling FieldDoc.type, if the field's type is missing
jlahoda
parents: 31751
diff changeset
   133
             * for which the CompletionFailure was thrown shouldn't be completed
8457813125e3 8135307: CompletionFailure thrown when calling FieldDoc.type, if the field's type is missing
jlahoda
parents: 31751
diff changeset
   134
             * again by the completer that threw the CompletionFailure.
8457813125e3 8135307: CompletionFailure thrown when calling FieldDoc.type, if the field's type is missing
jlahoda
parents: 31751
diff changeset
   135
             */
8457813125e3 8135307: CompletionFailure thrown when calling FieldDoc.type, if the field's type is missing
jlahoda
parents: 31751
diff changeset
   136
            return getFlags(clazz);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   137
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   138
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   139
06bc494ca11e Initial load
duke
parents:
diff changeset
   140
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   141
     * Is a ClassSymbol an annotation type?
06bc494ca11e Initial load
duke
parents:
diff changeset
   142
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   143
    static boolean isAnnotationType(ClassSymbol clazz) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   144
        return (getFlags(clazz) & Flags.ANNOTATION) != 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   145
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   146
06bc494ca11e Initial load
duke
parents:
diff changeset
   147
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   148
     * Identify the containing class
06bc494ca11e Initial load
duke
parents:
diff changeset
   149
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   150
    protected ClassSymbol getContainingClass() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   151
        return tsym.owner.enclClass();
06bc494ca11e Initial load
duke
parents:
diff changeset
   152
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   153
06bc494ca11e Initial load
duke
parents:
diff changeset
   154
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   155
     * Return true if this is a class, not an interface.
06bc494ca11e Initial load
duke
parents:
diff changeset
   156
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   157
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   158
    public boolean isClass() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   159
        return !Modifier.isInterface(getModifiers());
06bc494ca11e Initial load
duke
parents:
diff changeset
   160
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   161
06bc494ca11e Initial load
duke
parents:
diff changeset
   162
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   163
     * Return true if this is a ordinary class,
06bc494ca11e Initial load
duke
parents:
diff changeset
   164
     * not an enumeration, exception, an error, or an interface.
06bc494ca11e Initial load
duke
parents:
diff changeset
   165
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   166
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   167
    public boolean isOrdinaryClass() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   168
        if (isEnum() || isInterface() || isAnnotationType()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   169
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   170
        }
14359
d4099818ab70 7200915: convert TypeTags from a series of small ints to an enum
jjg
parents: 14260
diff changeset
   171
        for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   172
            if (t.tsym == env.syms.errorType.tsym ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   173
                t.tsym == env.syms.exceptionType.tsym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   174
                return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   175
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   176
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   177
        return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   178
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   179
06bc494ca11e Initial load
duke
parents:
diff changeset
   180
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   181
     * Return true if this is an enumeration.
06bc494ca11e Initial load
duke
parents:
diff changeset
   182
     * (For legacy doclets, return false.)
06bc494ca11e Initial load
duke
parents:
diff changeset
   183
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   184
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   185
    public boolean isEnum() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   186
        return (getFlags() & Flags.ENUM) != 0
06bc494ca11e Initial load
duke
parents:
diff changeset
   187
               &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   188
               !env.legacyDoclet;
06bc494ca11e Initial load
duke
parents:
diff changeset
   189
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   190
06bc494ca11e Initial load
duke
parents:
diff changeset
   191
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   192
     * Return true if this is an interface, but not an annotation type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   193
     * Overridden by AnnotationTypeDocImpl.
06bc494ca11e Initial load
duke
parents:
diff changeset
   194
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   195
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   196
    public boolean isInterface() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   197
        return Modifier.isInterface(getModifiers());
06bc494ca11e Initial load
duke
parents:
diff changeset
   198
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   199
06bc494ca11e Initial load
duke
parents:
diff changeset
   200
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   201
     * Return true if this is an exception class
06bc494ca11e Initial load
duke
parents:
diff changeset
   202
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   203
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   204
    public boolean isException() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   205
        if (isEnum() || isInterface() || isAnnotationType()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   206
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   207
        }
14359
d4099818ab70 7200915: convert TypeTags from a series of small ints to an enum
jjg
parents: 14260
diff changeset
   208
        for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   209
            if (t.tsym == env.syms.exceptionType.tsym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   210
                return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   211
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   212
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   213
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   214
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   215
06bc494ca11e Initial load
duke
parents:
diff changeset
   216
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   217
     * Return true if this is an error class
06bc494ca11e Initial load
duke
parents:
diff changeset
   218
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   219
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   220
    public boolean isError() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   221
        if (isEnum() || isInterface() || isAnnotationType()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   222
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   223
        }
14359
d4099818ab70 7200915: convert TypeTags from a series of small ints to an enum
jjg
parents: 14260
diff changeset
   224
        for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   225
            if (t.tsym == env.syms.errorType.tsym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   226
                return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   227
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   228
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   229
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   230
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   231
06bc494ca11e Initial load
duke
parents:
diff changeset
   232
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   233
     * Return true if this is a throwable class
06bc494ca11e Initial load
duke
parents:
diff changeset
   234
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   235
    public boolean isThrowable() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   236
        if (isEnum() || isInterface() || isAnnotationType()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   237
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   238
        }
14359
d4099818ab70 7200915: convert TypeTags from a series of small ints to an enum
jjg
parents: 14260
diff changeset
   239
        for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   240
            if (t.tsym == env.syms.throwableType.tsym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   241
                return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   242
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   243
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   244
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   245
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   246
06bc494ca11e Initial load
duke
parents:
diff changeset
   247
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   248
     * Return true if this class is abstract
06bc494ca11e Initial load
duke
parents:
diff changeset
   249
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   250
    public boolean isAbstract() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   251
        return Modifier.isAbstract(getModifiers());
06bc494ca11e Initial load
duke
parents:
diff changeset
   252
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   253
06bc494ca11e Initial load
duke
parents:
diff changeset
   254
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   255
     * Returns true if this class was synthesized by the compiler.
06bc494ca11e Initial load
duke
parents:
diff changeset
   256
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   257
    public boolean isSynthetic() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   258
        return (getFlags() & Flags.SYNTHETIC) != 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   259
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   260
06bc494ca11e Initial load
duke
parents:
diff changeset
   261
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   262
     * Return true if this class is included in the active set.
06bc494ca11e Initial load
duke
parents:
diff changeset
   263
     * A ClassDoc is included iff either it is specified on the
06bc494ca11e Initial load
duke
parents:
diff changeset
   264
     * commandline, or if it's containing package is specified
06bc494ca11e Initial load
duke
parents:
diff changeset
   265
     * on the command line, or if it is a member class of an
06bc494ca11e Initial load
duke
parents:
diff changeset
   266
     * included class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   267
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   268
06bc494ca11e Initial load
duke
parents:
diff changeset
   269
    public boolean isIncluded() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   270
        if (isIncluded) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   271
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   272
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   273
        if (env.shouldDocument(tsym)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   274
            // Class is nameable from top-level and
06bc494ca11e Initial load
duke
parents:
diff changeset
   275
            // the class and all enclosing classes
06bc494ca11e Initial load
duke
parents:
diff changeset
   276
            // pass the modifier filter.
06bc494ca11e Initial load
duke
parents:
diff changeset
   277
            if (containingPackage().isIncluded()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   278
                return isIncluded=true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   279
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   280
            ClassDoc outer = containingClass();
06bc494ca11e Initial load
duke
parents:
diff changeset
   281
            if (outer != null && outer.isIncluded()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   282
                return isIncluded=true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   283
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   284
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   285
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   286
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   287
06bc494ca11e Initial load
duke
parents:
diff changeset
   288
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   289
     * Return the package that this class is contained in.
06bc494ca11e Initial load
duke
parents:
diff changeset
   290
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   291
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   292
    public PackageDoc containingPackage() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   293
        PackageDocImpl p = env.getPackageDoc(tsym.packge());
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   294
        if (p.setDocPath == false) {
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   295
            FileObject docPath;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   296
            try {
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   297
                Location location = env.fileManager.hasLocation(StandardLocation.SOURCE_PATH)
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   298
                    ? StandardLocation.SOURCE_PATH : StandardLocation.CLASS_PATH;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   299
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   300
                docPath = env.fileManager.getFileForInput(
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   301
                        location, p.qualifiedName(), "package.html");
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   302
            } catch (IOException e) {
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   303
                docPath = null;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   304
            }
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   305
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   306
            if (docPath == null) {
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   307
                // fall back on older semantics of looking in same directory as
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   308
                // source file for this class
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   309
                SourcePosition po = position();
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   310
                if (env.fileManager instanceof StandardJavaFileManager &&
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   311
                        po instanceof SourcePositionImpl) {
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   312
                    URI uri = ((SourcePositionImpl) po).filename.toUri();
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   313
                    if ("file".equals(uri.getScheme())) {
3782
ae62279eeb46 6419701: DefaultFileManager clean up: URI.create
jjg
parents: 2212
diff changeset
   314
                        File f = new File(uri);
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   315
                        File dir = f.getParentFile();
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   316
                        if (dir != null) {
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   317
                            File pf = new File(dir, "package.html");
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   318
                            if (pf.exists()) {
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   319
                                StandardJavaFileManager sfm = (StandardJavaFileManager) env.fileManager;
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   320
                                docPath = sfm.getJavaFileObjects(pf).iterator().next();
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   321
                            }
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   322
                        }
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   323
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   324
                    }
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   325
                }
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   326
            }
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   327
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
   328
            p.setDocPath(docPath);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   329
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   330
        return p;
06bc494ca11e Initial load
duke
parents:
diff changeset
   331
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   332
06bc494ca11e Initial load
duke
parents:
diff changeset
   333
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   334
     * Return the class name without package qualifier - but with
06bc494ca11e Initial load
duke
parents:
diff changeset
   335
     * enclosing class qualifier - as a String.
06bc494ca11e Initial load
duke
parents:
diff changeset
   336
     * <pre>
06bc494ca11e Initial load
duke
parents:
diff changeset
   337
     * Examples:
06bc494ca11e Initial load
duke
parents:
diff changeset
   338
     *  for java.util.Hashtable
06bc494ca11e Initial load
duke
parents:
diff changeset
   339
     *  return Hashtable
06bc494ca11e Initial load
duke
parents:
diff changeset
   340
     *  for java.util.Map.Entry
06bc494ca11e Initial load
duke
parents:
diff changeset
   341
     *  return Map.Entry
06bc494ca11e Initial load
duke
parents:
diff changeset
   342
     * </pre>
06bc494ca11e Initial load
duke
parents:
diff changeset
   343
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   344
    public String name() {
17275
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   345
        if (name == null) {
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   346
            name = getClassName(tsym, false);
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   347
        }
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   348
        return name;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   349
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   350
17275
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   351
    private String name;
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   352
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   353
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   354
     * Return the qualified class name as a String.
06bc494ca11e Initial load
duke
parents:
diff changeset
   355
     * <pre>
06bc494ca11e Initial load
duke
parents:
diff changeset
   356
     * Example:
06bc494ca11e Initial load
duke
parents:
diff changeset
   357
     *  for java.util.Hashtable
06bc494ca11e Initial load
duke
parents:
diff changeset
   358
     *  return java.util.Hashtable
06bc494ca11e Initial load
duke
parents:
diff changeset
   359
     *  if no qualifier, just return flat name
06bc494ca11e Initial load
duke
parents:
diff changeset
   360
     * </pre>
06bc494ca11e Initial load
duke
parents:
diff changeset
   361
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   362
    public String qualifiedName() {
17275
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   363
        if (qualifiedName == null) {
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   364
            qualifiedName = getClassName(tsym, true);
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   365
        }
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   366
        return qualifiedName;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   367
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   368
17275
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   369
    private String qualifiedName;
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   370
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   371
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   372
     * Return unqualified name of type excluding any dimension information.
06bc494ca11e Initial load
duke
parents:
diff changeset
   373
     * <p>
06bc494ca11e Initial load
duke
parents:
diff changeset
   374
     * For example, a two dimensional array of String returns 'String'.
06bc494ca11e Initial load
duke
parents:
diff changeset
   375
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   376
    public String typeName() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   377
        return name();
06bc494ca11e Initial load
duke
parents:
diff changeset
   378
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   379
06bc494ca11e Initial load
duke
parents:
diff changeset
   380
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   381
     * Return qualified name of type excluding any dimension information.
06bc494ca11e Initial load
duke
parents:
diff changeset
   382
     *<p>
06bc494ca11e Initial load
duke
parents:
diff changeset
   383
     * For example, a two dimensional array of String
06bc494ca11e Initial load
duke
parents:
diff changeset
   384
     * returns 'java.lang.String'.
06bc494ca11e Initial load
duke
parents:
diff changeset
   385
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   386
    public String qualifiedTypeName() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   387
        return qualifiedName();
06bc494ca11e Initial load
duke
parents:
diff changeset
   388
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   389
06bc494ca11e Initial load
duke
parents:
diff changeset
   390
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   391
     * Return the simple name of this type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   392
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   393
    public String simpleTypeName() {
17275
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   394
        if (simpleTypeName == null) {
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   395
            simpleTypeName = tsym.name.toString();
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   396
        }
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   397
        return simpleTypeName;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   398
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   399
17275
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   400
    private String simpleTypeName;
bcaa1940863a 8012656: cache frequently used name strings for DocImpl classes
jjg
parents: 16969
diff changeset
   401
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   402
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   403
     * Return the qualified name and any type parameters.
06bc494ca11e Initial load
duke
parents:
diff changeset
   404
     * Each parameter is a type variable with optional bounds.
06bc494ca11e Initial load
duke
parents:
diff changeset
   405
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   406
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   407
    public String toString() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   408
        return classToString(env, tsym, true);
06bc494ca11e Initial load
duke
parents:
diff changeset
   409
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   410
06bc494ca11e Initial load
duke
parents:
diff changeset
   411
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   412
     * Return the class name as a string.  If "full" is true the name is
06bc494ca11e Initial load
duke
parents:
diff changeset
   413
     * qualified, otherwise it is qualified by its enclosing class(es) only.
06bc494ca11e Initial load
duke
parents:
diff changeset
   414
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   415
    static String getClassName(ClassSymbol c, boolean full) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   416
        if (full) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   417
            return c.getQualifiedName().toString();
06bc494ca11e Initial load
duke
parents:
diff changeset
   418
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   419
            String n = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
   420
            for ( ; c != null; c = c.owner.enclClass()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   421
                n = c.name + (n.equals("") ? "" : ".") + n;
06bc494ca11e Initial load
duke
parents:
diff changeset
   422
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   423
            return n;
06bc494ca11e Initial load
duke
parents:
diff changeset
   424
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   425
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   426
06bc494ca11e Initial load
duke
parents:
diff changeset
   427
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   428
     * Return the class name with any type parameters as a string.
06bc494ca11e Initial load
duke
parents:
diff changeset
   429
     * Each parameter is a type variable with optional bounds.
06bc494ca11e Initial load
duke
parents:
diff changeset
   430
     * If "full" is true all names are qualified, otherwise they are
06bc494ca11e Initial load
duke
parents:
diff changeset
   431
     * qualified by their enclosing class(es) only.
06bc494ca11e Initial load
duke
parents:
diff changeset
   432
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   433
    static String classToString(DocEnv env, ClassSymbol c, boolean full) {
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   434
        StringBuilder s = new StringBuilder();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   435
        if (!c.isInner()) {             // if c is not an inner class
06bc494ca11e Initial load
duke
parents:
diff changeset
   436
            s.append(getClassName(c, full));
06bc494ca11e Initial load
duke
parents:
diff changeset
   437
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   438
            // c is an inner class, so include type params of outer.
06bc494ca11e Initial load
duke
parents:
diff changeset
   439
            ClassSymbol encl = c.owner.enclClass();
06bc494ca11e Initial load
duke
parents:
diff changeset
   440
            s.append(classToString(env, encl, full))
06bc494ca11e Initial load
duke
parents:
diff changeset
   441
             .append('.')
06bc494ca11e Initial load
duke
parents:
diff changeset
   442
             .append(c.name);
06bc494ca11e Initial load
duke
parents:
diff changeset
   443
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   444
        s.append(TypeMaker.typeParametersString(env, c, full));
06bc494ca11e Initial load
duke
parents:
diff changeset
   445
        return s.toString();
06bc494ca11e Initial load
duke
parents:
diff changeset
   446
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   447
06bc494ca11e Initial load
duke
parents:
diff changeset
   448
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   449
     * Is this class (or any enclosing class) generic?  That is, does
06bc494ca11e Initial load
duke
parents:
diff changeset
   450
     * it have type parameters?
06bc494ca11e Initial load
duke
parents:
diff changeset
   451
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   452
    static boolean isGeneric(ClassSymbol c) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   453
        return c.type.allparams().nonEmpty();
06bc494ca11e Initial load
duke
parents:
diff changeset
   454
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   455
06bc494ca11e Initial load
duke
parents:
diff changeset
   456
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   457
     * Return the formal type parameters of this class or interface.
06bc494ca11e Initial load
duke
parents:
diff changeset
   458
     * Return an empty array if there are none.
06bc494ca11e Initial load
duke
parents:
diff changeset
   459
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   460
    public TypeVariable[] typeParameters() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   461
        if (env.legacyDoclet) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   462
            return new TypeVariable[0];
06bc494ca11e Initial load
duke
parents:
diff changeset
   463
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   464
        TypeVariable res[] = new TypeVariable[type.getTypeArguments().length()];
06bc494ca11e Initial load
duke
parents:
diff changeset
   465
        TypeMaker.getTypes(env, type.getTypeArguments(), res);
06bc494ca11e Initial load
duke
parents:
diff changeset
   466
        return res;
06bc494ca11e Initial load
duke
parents:
diff changeset
   467
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   468
06bc494ca11e Initial load
duke
parents:
diff changeset
   469
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   470
     * Return the type parameter tags of this class or interface.
06bc494ca11e Initial load
duke
parents:
diff changeset
   471
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   472
    public ParamTag[] typeParamTags() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   473
        return (env.legacyDoclet)
06bc494ca11e Initial load
duke
parents:
diff changeset
   474
            ? new ParamTag[0]
06bc494ca11e Initial load
duke
parents:
diff changeset
   475
            : comment().typeParamTags();
06bc494ca11e Initial load
duke
parents:
diff changeset
   476
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   477
06bc494ca11e Initial load
duke
parents:
diff changeset
   478
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   479
     * Return the modifier string for this class. If it's an interface
06bc494ca11e Initial load
duke
parents:
diff changeset
   480
     * exclude 'abstract' keyword from the modifier string
06bc494ca11e Initial load
duke
parents:
diff changeset
   481
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   482
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   483
    public String modifiers() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   484
        return Modifier.toString(modifierSpecifier());
06bc494ca11e Initial load
duke
parents:
diff changeset
   485
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   486
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
   487
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   488
    public int modifierSpecifier() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   489
        int modifiers = getModifiers();
06bc494ca11e Initial load
duke
parents:
diff changeset
   490
        return (isInterface() || isAnnotationType())
06bc494ca11e Initial load
duke
parents:
diff changeset
   491
                ? modifiers & ~Modifier.ABSTRACT
06bc494ca11e Initial load
duke
parents:
diff changeset
   492
                : modifiers;
06bc494ca11e Initial load
duke
parents:
diff changeset
   493
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   494
06bc494ca11e Initial load
duke
parents:
diff changeset
   495
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   496
     * Return the superclass of this class
06bc494ca11e Initial load
duke
parents:
diff changeset
   497
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   498
     * @return the ClassDocImpl for the superclass of this class, null
06bc494ca11e Initial load
duke
parents:
diff changeset
   499
     * if there is no superclass.
06bc494ca11e Initial load
duke
parents:
diff changeset
   500
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   501
    public ClassDoc superclass() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   502
        if (isInterface() || isAnnotationType()) return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   503
        if (tsym == env.syms.objectType.tsym) return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   504
        ClassSymbol c = (ClassSymbol)env.types.supertype(type).tsym;
06bc494ca11e Initial load
duke
parents:
diff changeset
   505
        if (c == null || c == tsym) c = (ClassSymbol)env.syms.objectType.tsym;
06bc494ca11e Initial load
duke
parents:
diff changeset
   506
        return env.getClassDoc(c);
06bc494ca11e Initial load
duke
parents:
diff changeset
   507
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   508
06bc494ca11e Initial load
duke
parents:
diff changeset
   509
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   510
     * Return the superclass of this class.  Return null if this is an
06bc494ca11e Initial load
duke
parents:
diff changeset
   511
     * interface.  A superclass is represented by either a
06bc494ca11e Initial load
duke
parents:
diff changeset
   512
     * <code>ClassDoc</code> or a <code>ParameterizedType</code>.
06bc494ca11e Initial load
duke
parents:
diff changeset
   513
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   514
    public com.sun.javadoc.Type superclassType() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   515
        if (isInterface() || isAnnotationType() ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   516
                (tsym == env.syms.objectType.tsym))
06bc494ca11e Initial load
duke
parents:
diff changeset
   517
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   518
        Type sup = env.types.supertype(type);
06bc494ca11e Initial load
duke
parents:
diff changeset
   519
        return TypeMaker.getType(env,
18915
dcc9c8265f65 8016640: compiler hangs if the generics arity of a base class is wrong
mcimadamore
parents: 17275
diff changeset
   520
                                 (sup.hasTag(TypeTag.NONE)) ? env.syms.objectType : sup);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   521
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   522
06bc494ca11e Initial load
duke
parents:
diff changeset
   523
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   524
     * Test whether this class is a subclass of the specified class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   525
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   526
     * @param cd the candidate superclass.
06bc494ca11e Initial load
duke
parents:
diff changeset
   527
     * @return true if cd is a superclass of this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   528
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   529
    public boolean subclassOf(ClassDoc cd) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   530
        return tsym.isSubClass(((ClassDocImpl)cd).tsym, env.types);
06bc494ca11e Initial load
duke
parents:
diff changeset
   531
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   532
06bc494ca11e Initial load
duke
parents:
diff changeset
   533
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   534
     * Return interfaces implemented by this class or interfaces
06bc494ca11e Initial load
duke
parents:
diff changeset
   535
     * extended by this interface.
06bc494ca11e Initial load
duke
parents:
diff changeset
   536
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   537
     * @return An array of ClassDocImpl representing the interfaces.
06bc494ca11e Initial load
duke
parents:
diff changeset
   538
     * Return an empty array if there are no interfaces.
06bc494ca11e Initial load
duke
parents:
diff changeset
   539
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   540
    public ClassDoc[] interfaces() {
22163
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
   541
        ListBuffer<ClassDocImpl> ta = new ListBuffer<>();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   542
        for (Type t : env.types.interfaces(type)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   543
            ta.append(env.getClassDoc((ClassSymbol)t.tsym));
06bc494ca11e Initial load
duke
parents:
diff changeset
   544
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   545
        //### Cache ta here?
06bc494ca11e Initial load
duke
parents:
diff changeset
   546
        return ta.toArray(new ClassDocImpl[ta.length()]);
06bc494ca11e Initial load
duke
parents:
diff changeset
   547
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   548
06bc494ca11e Initial load
duke
parents:
diff changeset
   549
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   550
     * Return interfaces implemented by this class or interfaces extended
06bc494ca11e Initial load
duke
parents:
diff changeset
   551
     * by this interface. Includes only directly-declared interfaces, not
06bc494ca11e Initial load
duke
parents:
diff changeset
   552
     * inherited interfaces.
06bc494ca11e Initial load
duke
parents:
diff changeset
   553
     * Return an empty array if there are no interfaces.
06bc494ca11e Initial load
duke
parents:
diff changeset
   554
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   555
    public com.sun.javadoc.Type[] interfaceTypes() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   556
        //### Cache result here?
06bc494ca11e Initial load
duke
parents:
diff changeset
   557
        return TypeMaker.getTypes(env, env.types.interfaces(type));
06bc494ca11e Initial load
duke
parents:
diff changeset
   558
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   559
06bc494ca11e Initial load
duke
parents:
diff changeset
   560
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   561
     * Return fields in class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   562
     * @param filter include only the included fields if filter==true
06bc494ca11e Initial load
duke
parents:
diff changeset
   563
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   564
    public FieldDoc[] fields(boolean filter) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   565
        return fields(filter, false);
06bc494ca11e Initial load
duke
parents:
diff changeset
   566
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   567
06bc494ca11e Initial load
duke
parents:
diff changeset
   568
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   569
     * Return included fields in class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   570
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   571
    public FieldDoc[] fields() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   572
        return fields(true, false);
06bc494ca11e Initial load
duke
parents:
diff changeset
   573
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   574
06bc494ca11e Initial load
duke
parents:
diff changeset
   575
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   576
     * Return the enum constants if this is an enum type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   577
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   578
    public FieldDoc[] enumConstants() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   579
        return fields(false, true);
06bc494ca11e Initial load
duke
parents:
diff changeset
   580
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   581
06bc494ca11e Initial load
duke
parents:
diff changeset
   582
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   583
     * Return fields in class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   584
     * @param filter  if true, return only the included fields
06bc494ca11e Initial load
duke
parents:
diff changeset
   585
     * @param enumConstants  if true, return the enum constants instead
06bc494ca11e Initial load
duke
parents:
diff changeset
   586
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   587
    private FieldDoc[] fields(boolean filter, boolean enumConstants) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   588
        List<FieldDocImpl> fields = List.nil();
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   589
        for (Symbol sym : tsym.members().getSymbols(NON_RECURSIVE)) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   590
            if (sym != null && sym.kind == VAR) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   591
                VarSymbol s = (VarSymbol)sym;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   592
                boolean isEnum = ((s.flags() & Flags.ENUM) != 0) &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   593
                                 !env.legacyDoclet;
06bc494ca11e Initial load
duke
parents:
diff changeset
   594
                if (isEnum == enumConstants &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   595
                        (!filter || env.shouldDocument(s))) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   596
                    fields = fields.prepend(env.getFieldDoc(s));
06bc494ca11e Initial load
duke
parents:
diff changeset
   597
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   598
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   599
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   600
        return fields.toArray(new FieldDocImpl[fields.length()]);
06bc494ca11e Initial load
duke
parents:
diff changeset
   601
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   602
06bc494ca11e Initial load
duke
parents:
diff changeset
   603
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   604
     * Return methods in class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   605
     * This method is overridden by AnnotationTypeDocImpl.
06bc494ca11e Initial load
duke
parents:
diff changeset
   606
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   607
     * @param filter include only the included methods if filter==true
06bc494ca11e Initial load
duke
parents:
diff changeset
   608
     * @return an array of MethodDocImpl for representing the visible
06bc494ca11e Initial load
duke
parents:
diff changeset
   609
     * methods in this class.  Does not include constructors.
06bc494ca11e Initial load
duke
parents:
diff changeset
   610
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   611
    public MethodDoc[] methods(boolean filter) {
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 10
diff changeset
   612
        Names names = tsym.name.table.names;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   613
        List<MethodDocImpl> methods = List.nil();
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   614
        for (Symbol sym :tsym.members().getSymbols(NON_RECURSIVE)) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   615
            if (sym != null
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
   616
                && sym.kind == MTH
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   617
                && sym.name != names.init
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   618
                && sym.name != names.clinit) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   619
                MethodSymbol s = (MethodSymbol)sym;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   620
                if (!filter || env.shouldDocument(s)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   621
                    methods = methods.prepend(env.getMethodDoc(s));
06bc494ca11e Initial load
duke
parents:
diff changeset
   622
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   623
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   624
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   625
        //### Cache methods here?
06bc494ca11e Initial load
duke
parents:
diff changeset
   626
        return methods.toArray(new MethodDocImpl[methods.length()]);
06bc494ca11e Initial load
duke
parents:
diff changeset
   627
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   628
06bc494ca11e Initial load
duke
parents:
diff changeset
   629
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   630
     * Return included methods in class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   631
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   632
     * @return an array of MethodDocImpl for representing the visible
06bc494ca11e Initial load
duke
parents:
diff changeset
   633
     * methods in this class.  Does not include constructors.
06bc494ca11e Initial load
duke
parents:
diff changeset
   634
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   635
    public MethodDoc[] methods() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   636
        return methods(true);
06bc494ca11e Initial load
duke
parents:
diff changeset
   637
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   638
06bc494ca11e Initial load
duke
parents:
diff changeset
   639
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   640
     * Return constructors in class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   641
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   642
     * @param filter include only the included constructors if filter==true
06bc494ca11e Initial load
duke
parents:
diff changeset
   643
     * @return an array of ConstructorDocImpl for representing the visible
06bc494ca11e Initial load
duke
parents:
diff changeset
   644
     * constructors in this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   645
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   646
    public ConstructorDoc[] constructors(boolean filter) {
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 10
diff changeset
   647
        Names names = tsym.name.table.names;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   648
        List<ConstructorDocImpl> constructors = List.nil();
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   649
        for (Symbol sym : tsym.members().getSymbols(NON_RECURSIVE)) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   650
            if (sym != null &&
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
   651
                sym.kind == MTH && sym.name == names.init) {
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   652
                MethodSymbol s = (MethodSymbol)sym;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   653
                if (!filter || env.shouldDocument(s)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   654
                    constructors = constructors.prepend(env.getConstructorDoc(s));
06bc494ca11e Initial load
duke
parents:
diff changeset
   655
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   656
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   657
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   658
        //### Cache constructors here?
06bc494ca11e Initial load
duke
parents:
diff changeset
   659
        return constructors.toArray(new ConstructorDocImpl[constructors.length()]);
06bc494ca11e Initial load
duke
parents:
diff changeset
   660
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   661
06bc494ca11e Initial load
duke
parents:
diff changeset
   662
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   663
     * Return included constructors in class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   664
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   665
     * @return an array of ConstructorDocImpl for representing the visible
06bc494ca11e Initial load
duke
parents:
diff changeset
   666
     * constructors in this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   667
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   668
    public ConstructorDoc[] constructors() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   669
        return constructors(true);
06bc494ca11e Initial load
duke
parents:
diff changeset
   670
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   671
06bc494ca11e Initial load
duke
parents:
diff changeset
   672
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   673
     * Adds all inner classes of this class, and their
06bc494ca11e Initial load
duke
parents:
diff changeset
   674
     * inner classes recursively, to the list l.
06bc494ca11e Initial load
duke
parents:
diff changeset
   675
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   676
    void addAllClasses(ListBuffer<ClassDocImpl> l, boolean filtered) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   677
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   678
            if (isSynthetic()) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   679
            // sometimes synthetic classes are not marked synthetic
06bc494ca11e Initial load
duke
parents:
diff changeset
   680
            if (!JavadocTool.isValidClassName(tsym.name.toString())) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   681
            if (filtered && !env.shouldDocument(tsym)) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   682
            if (l.contains(this)) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   683
            l.append(this);
06bc494ca11e Initial load
duke
parents:
diff changeset
   684
            List<ClassDocImpl> more = List.nil();
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   685
            for (Symbol sym : tsym.members().getSymbols(NON_RECURSIVE)) {
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
   686
                if (sym != null && sym.kind == TYP) {
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   687
                    ClassSymbol s = (ClassSymbol)sym;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   688
                    ClassDocImpl c = env.getClassDoc(s);
06bc494ca11e Initial load
duke
parents:
diff changeset
   689
                    if (c.isSynthetic()) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
   690
                    if (c != null) more = more.prepend(c);
06bc494ca11e Initial load
duke
parents:
diff changeset
   691
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   692
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   693
            // this extra step preserves the ordering from oldjavadoc
06bc494ca11e Initial load
duke
parents:
diff changeset
   694
            for (; more.nonEmpty(); more=more.tail) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   695
                more.head.addAllClasses(l, filtered);
06bc494ca11e Initial load
duke
parents:
diff changeset
   696
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   697
        } catch (CompletionFailure e) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   698
            // quietly ignore completion failures
06bc494ca11e Initial load
duke
parents:
diff changeset
   699
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   700
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   701
06bc494ca11e Initial load
duke
parents:
diff changeset
   702
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   703
     * Return inner classes within this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   704
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   705
     * @param filter include only the included inner classes if filter==true.
06bc494ca11e Initial load
duke
parents:
diff changeset
   706
     * @return an array of ClassDocImpl for representing the visible
06bc494ca11e Initial load
duke
parents:
diff changeset
   707
     * classes defined in this class. Anonymous and local classes
06bc494ca11e Initial load
duke
parents:
diff changeset
   708
     * are not included.
06bc494ca11e Initial load
duke
parents:
diff changeset
   709
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   710
    public ClassDoc[] innerClasses(boolean filter) {
22163
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
   711
        ListBuffer<ClassDocImpl> innerClasses = new ListBuffer<>();
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   712
        for (Symbol sym : tsym.members().getSymbols(NON_RECURSIVE)) {
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
   713
            if (sym != null && sym.kind == TYP) {
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   714
                ClassSymbol s = (ClassSymbol)sym;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   715
                if ((s.flags_field & Flags.SYNTHETIC) != 0) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
   716
                if (!filter || env.isVisible(s)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   717
                    innerClasses.prepend(env.getClassDoc(s));
06bc494ca11e Initial load
duke
parents:
diff changeset
   718
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   719
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   720
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   721
        //### Cache classes here?
06bc494ca11e Initial load
duke
parents:
diff changeset
   722
        return innerClasses.toArray(new ClassDocImpl[innerClasses.length()]);
06bc494ca11e Initial load
duke
parents:
diff changeset
   723
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   724
06bc494ca11e Initial load
duke
parents:
diff changeset
   725
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   726
     * Return included inner classes within this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   727
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   728
     * @return an array of ClassDocImpl for representing the visible
06bc494ca11e Initial load
duke
parents:
diff changeset
   729
     * classes defined in this class. Anonymous and local classes
06bc494ca11e Initial load
duke
parents:
diff changeset
   730
     * are not included.
06bc494ca11e Initial load
duke
parents:
diff changeset
   731
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   732
    public ClassDoc[] innerClasses() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   733
        return innerClasses(true);
06bc494ca11e Initial load
duke
parents:
diff changeset
   734
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   735
06bc494ca11e Initial load
duke
parents:
diff changeset
   736
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   737
     * Find a class within the context of this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   738
     * Search order: qualified name, in this class (inner),
06bc494ca11e Initial load
duke
parents:
diff changeset
   739
     * in this package, in the class imports, in the package
06bc494ca11e Initial load
duke
parents:
diff changeset
   740
     * imports.
06bc494ca11e Initial load
duke
parents:
diff changeset
   741
     * Return the ClassDocImpl if found, null if not found.
06bc494ca11e Initial load
duke
parents:
diff changeset
   742
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   743
    //### The specified search order is not the normal rule the
06bc494ca11e Initial load
duke
parents:
diff changeset
   744
    //### compiler would use.  Leave as specified or change it?
06bc494ca11e Initial load
duke
parents:
diff changeset
   745
    public ClassDoc findClass(String className) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   746
        ClassDoc searchResult = searchClass(className);
06bc494ca11e Initial load
duke
parents:
diff changeset
   747
        if (searchResult == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   748
            ClassDocImpl enclosingClass = (ClassDocImpl)containingClass();
06bc494ca11e Initial load
duke
parents:
diff changeset
   749
            //Expand search space to include enclosing class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   750
            while (enclosingClass != null && enclosingClass.containingClass() != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   751
                enclosingClass = (ClassDocImpl)enclosingClass.containingClass();
06bc494ca11e Initial load
duke
parents:
diff changeset
   752
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   753
            searchResult = enclosingClass == null ?
06bc494ca11e Initial load
duke
parents:
diff changeset
   754
                null : enclosingClass.searchClass(className);
06bc494ca11e Initial load
duke
parents:
diff changeset
   755
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   756
        return searchResult;
06bc494ca11e Initial load
duke
parents:
diff changeset
   757
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   758
06bc494ca11e Initial load
duke
parents:
diff changeset
   759
    private ClassDoc searchClass(String className) {
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 10
diff changeset
   760
        Names names = tsym.name.table.names;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   761
06bc494ca11e Initial load
duke
parents:
diff changeset
   762
        // search by qualified name first
06bc494ca11e Initial load
duke
parents:
diff changeset
   763
        ClassDoc cd = env.lookupClass(className);
06bc494ca11e Initial load
duke
parents:
diff changeset
   764
        if (cd != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   765
            return cd;
06bc494ca11e Initial load
duke
parents:
diff changeset
   766
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   767
06bc494ca11e Initial load
duke
parents:
diff changeset
   768
        // search inner classes
06bc494ca11e Initial load
duke
parents:
diff changeset
   769
        //### Add private entry point to avoid creating array?
06bc494ca11e Initial load
duke
parents:
diff changeset
   770
        //### Replicate code in innerClasses here to avoid consing?
10203
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   771
        for (ClassDoc icd : innerClasses()) {
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   772
            if (icd.name().equals(className) ||
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   773
                    //### This is from original javadoc but it looks suspicious to me...
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   774
                    //### I believe it is attempting to compensate for the confused
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   775
                    //### convention of including the nested class qualifiers in the
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   776
                    //### 'name' of the inner class, rather than the true simple name.
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   777
                    icd.name().endsWith("." + className)) {
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   778
                return icd;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   779
            } else {
10203
cca843a7d258 7064544: (javadoc) miscellaneous fixes requested by netbeans
ksrini
parents: 8631
diff changeset
   780
                ClassDoc innercd = ((ClassDocImpl) icd).searchClass(className);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   781
                if (innercd != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   782
                    return innercd;
06bc494ca11e Initial load
duke
parents:
diff changeset
   783
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   784
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   785
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   786
06bc494ca11e Initial load
duke
parents:
diff changeset
   787
        // check in this package
06bc494ca11e Initial load
duke
parents:
diff changeset
   788
        cd = containingPackage().findClass(className);
06bc494ca11e Initial load
duke
parents:
diff changeset
   789
        if (cd != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   790
            return cd;
06bc494ca11e Initial load
duke
parents:
diff changeset
   791
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   792
06bc494ca11e Initial load
duke
parents:
diff changeset
   793
        // make sure that this symbol has been completed
30066
d74c06a92bd8 8078600: Infinite loop when compiling annotations with -XDcompletionDeps
alundblad
parents: 27224
diff changeset
   794
        tsym.complete();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   795
06bc494ca11e Initial load
duke
parents:
diff changeset
   796
        // search imports
06bc494ca11e Initial load
duke
parents:
diff changeset
   797
06bc494ca11e Initial load
duke
parents:
diff changeset
   798
        if (tsym.sourcefile != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   799
06bc494ca11e Initial load
duke
parents:
diff changeset
   800
            //### This information is available only for source classes.
06bc494ca11e Initial load
duke
parents:
diff changeset
   801
06bc494ca11e Initial load
duke
parents:
diff changeset
   802
            Env<AttrContext> compenv = env.enter.getEnv(tsym);
06bc494ca11e Initial load
duke
parents:
diff changeset
   803
            if (compenv == null) return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   804
06bc494ca11e Initial load
duke
parents:
diff changeset
   805
            Scope s = compenv.toplevel.namedImportScope;
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   806
            for (Symbol sym : s.getSymbolsByName(names.fromString(className))) {
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
   807
                if (sym.kind == TYP) {
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   808
                    ClassDoc c = env.getClassDoc((ClassSymbol)sym);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   809
                    return c;
06bc494ca11e Initial load
duke
parents:
diff changeset
   810
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   811
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   812
06bc494ca11e Initial load
duke
parents:
diff changeset
   813
            s = compenv.toplevel.starImportScope;
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   814
            for (Symbol sym : s.getSymbolsByName(names.fromString(className))) {
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
   815
                if (sym.kind == TYP) {
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   816
                    ClassDoc c = env.getClassDoc((ClassSymbol)sym);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   817
                    return c;
06bc494ca11e Initial load
duke
parents:
diff changeset
   818
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   819
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   820
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   821
06bc494ca11e Initial load
duke
parents:
diff changeset
   822
        return null; // not found
06bc494ca11e Initial load
duke
parents:
diff changeset
   823
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   824
06bc494ca11e Initial load
duke
parents:
diff changeset
   825
06bc494ca11e Initial load
duke
parents:
diff changeset
   826
    private boolean hasParameterTypes(MethodSymbol method, String[] argTypes) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   827
06bc494ca11e Initial load
duke
parents:
diff changeset
   828
        if (argTypes == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   829
            // wildcard
06bc494ca11e Initial load
duke
parents:
diff changeset
   830
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   831
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   832
06bc494ca11e Initial load
duke
parents:
diff changeset
   833
        int i = 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   834
        List<Type> types = method.type.getParameterTypes();
06bc494ca11e Initial load
duke
parents:
diff changeset
   835
06bc494ca11e Initial load
duke
parents:
diff changeset
   836
        if (argTypes.length != types.length()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   837
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   838
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   839
06bc494ca11e Initial load
duke
parents:
diff changeset
   840
        for (Type t : types) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   841
            String argType = argTypes[i++];
06bc494ca11e Initial load
duke
parents:
diff changeset
   842
            // For vararg method, "T..." matches type T[].
06bc494ca11e Initial load
duke
parents:
diff changeset
   843
            if (i == argTypes.length) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   844
                argType = argType.replace("...", "[]");
06bc494ca11e Initial load
duke
parents:
diff changeset
   845
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   846
            if (!hasTypeName(env.types.erasure(t), argType)) {  //###(gj)
06bc494ca11e Initial load
duke
parents:
diff changeset
   847
                return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   848
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   849
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   850
        return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   851
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   852
    // where
06bc494ca11e Initial load
duke
parents:
diff changeset
   853
    private boolean hasTypeName(Type t, String name) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   854
        return
06bc494ca11e Initial load
duke
parents:
diff changeset
   855
            name.equals(TypeMaker.getTypeName(t, true))
06bc494ca11e Initial load
duke
parents:
diff changeset
   856
            ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   857
            name.equals(TypeMaker.getTypeName(t, false))
06bc494ca11e Initial load
duke
parents:
diff changeset
   858
            ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   859
            (qualifiedName() + "." + name).equals(TypeMaker.getTypeName(t, true));
06bc494ca11e Initial load
duke
parents:
diff changeset
   860
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   861
06bc494ca11e Initial load
duke
parents:
diff changeset
   862
06bc494ca11e Initial load
duke
parents:
diff changeset
   863
06bc494ca11e Initial load
duke
parents:
diff changeset
   864
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   865
     * Find a method in this class scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
   866
     * Search order: this class, interfaces, superclasses, outerclasses.
06bc494ca11e Initial load
duke
parents:
diff changeset
   867
     * Note that this is not necessarily what the compiler would do!
06bc494ca11e Initial load
duke
parents:
diff changeset
   868
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   869
     * @param methodName the unqualified name to search for.
14259
fb94a1df0d53 8000208: fix langtools javadoc comment issues
jjg
parents: 14258
diff changeset
   870
     * @param paramTypes the array of Strings for method parameter types.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   871
     * @return the first MethodDocImpl which matches, null if not found.
06bc494ca11e Initial load
duke
parents:
diff changeset
   872
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   873
    public MethodDocImpl findMethod(String methodName, String[] paramTypes) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   874
        // Use hash table 'searched' to avoid searching same class twice.
06bc494ca11e Initial load
duke
parents:
diff changeset
   875
        //### It is not clear how this could happen.
22165
ec53c8946fc2 8030807: langtools should still build using jdk 7
vromero
parents: 22163
diff changeset
   876
        return searchMethod(methodName, paramTypes, new HashSet<ClassDocImpl>());
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   877
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   878
06bc494ca11e Initial load
duke
parents:
diff changeset
   879
    private MethodDocImpl searchMethod(String methodName,
06bc494ca11e Initial load
duke
parents:
diff changeset
   880
                                       String[] paramTypes, Set<ClassDocImpl> searched) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   881
        //### Note that this search is not necessarily what the compiler would do!
06bc494ca11e Initial load
duke
parents:
diff changeset
   882
7071
8bcda461a06a 6551367: javadoc throws ClassCastException when an @link tries to reference constructor.
sundar
parents: 5520
diff changeset
   883
        Names names = tsym.name.table.names;
8bcda461a06a 6551367: javadoc throws ClassCastException when an @link tries to reference constructor.
sundar
parents: 5520
diff changeset
   884
        // do not match constructors
8bcda461a06a 6551367: javadoc throws ClassCastException when an @link tries to reference constructor.
sundar
parents: 5520
diff changeset
   885
        if (names.init.contentEquals(methodName)) {
8bcda461a06a 6551367: javadoc throws ClassCastException when an @link tries to reference constructor.
sundar
parents: 5520
diff changeset
   886
            return null;
8bcda461a06a 6551367: javadoc throws ClassCastException when an @link tries to reference constructor.
sundar
parents: 5520
diff changeset
   887
        }
8bcda461a06a 6551367: javadoc throws ClassCastException when an @link tries to reference constructor.
sundar
parents: 5520
diff changeset
   888
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   889
        ClassDocImpl cdi;
06bc494ca11e Initial load
duke
parents:
diff changeset
   890
        MethodDocImpl mdi;
06bc494ca11e Initial load
duke
parents:
diff changeset
   891
06bc494ca11e Initial load
duke
parents:
diff changeset
   892
        if (searched.contains(this)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   893
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   894
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   895
        searched.add(this);
06bc494ca11e Initial load
duke
parents:
diff changeset
   896
06bc494ca11e Initial load
duke
parents:
diff changeset
   897
        //DEBUG
06bc494ca11e Initial load
duke
parents:
diff changeset
   898
        /*---------------------------------*
06bc494ca11e Initial load
duke
parents:
diff changeset
   899
         System.out.print("searching " + this + " for " + methodName);
06bc494ca11e Initial load
duke
parents:
diff changeset
   900
         if (paramTypes == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   901
         System.out.println("()");
06bc494ca11e Initial load
duke
parents:
diff changeset
   902
         } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   903
         System.out.print("(");
06bc494ca11e Initial load
duke
parents:
diff changeset
   904
         for (int k=0; k < paramTypes.length; k++) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   905
         System.out.print(paramTypes[k]);
06bc494ca11e Initial load
duke
parents:
diff changeset
   906
         if ((k + 1) < paramTypes.length) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   907
         System.out.print(", ");
06bc494ca11e Initial load
duke
parents:
diff changeset
   908
         }
06bc494ca11e Initial load
duke
parents:
diff changeset
   909
         }
06bc494ca11e Initial load
duke
parents:
diff changeset
   910
         System.out.println(")");
06bc494ca11e Initial load
duke
parents:
diff changeset
   911
         }
06bc494ca11e Initial load
duke
parents:
diff changeset
   912
         *---------------------------------*/
06bc494ca11e Initial load
duke
parents:
diff changeset
   913
06bc494ca11e Initial load
duke
parents:
diff changeset
   914
        // search current class
06bc494ca11e Initial load
duke
parents:
diff changeset
   915
06bc494ca11e Initial load
duke
parents:
diff changeset
   916
        //### Using modifier filter here isn't really correct,
06bc494ca11e Initial load
duke
parents:
diff changeset
   917
        //### but emulates the old behavior.  Instead, we should
06bc494ca11e Initial load
duke
parents:
diff changeset
   918
        //### apply the normal rules of visibility and inheritance.
06bc494ca11e Initial load
duke
parents:
diff changeset
   919
06bc494ca11e Initial load
duke
parents:
diff changeset
   920
        if (paramTypes == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   921
            // If no parameters specified, we are allowed to return
06bc494ca11e Initial load
duke
parents:
diff changeset
   922
            // any method with a matching name.  In practice, the old
06bc494ca11e Initial load
duke
parents:
diff changeset
   923
            // code returned the first method, which is now the last!
06bc494ca11e Initial load
duke
parents:
diff changeset
   924
            // In order to provide textually identical results, we
06bc494ca11e Initial load
duke
parents:
diff changeset
   925
            // attempt to emulate the old behavior.
06bc494ca11e Initial load
duke
parents:
diff changeset
   926
            MethodSymbol lastFound = null;
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   927
            for (Symbol sym : tsym.members().getSymbolsByName(names.fromString(methodName))) {
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
   928
                if (sym.kind == MTH) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   929
                    //### Should intern methodName as Name.
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   930
                    if (sym.name.toString().equals(methodName)) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   931
                        lastFound = (MethodSymbol)sym;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   932
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   933
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   934
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   935
            if (lastFound != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   936
                return env.getMethodDoc(lastFound);
06bc494ca11e Initial load
duke
parents:
diff changeset
   937
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   938
        } else {
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   939
            for (Symbol sym : tsym.members().getSymbolsByName(names.fromString(methodName))) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   940
                if (sym != null &&
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
   941
                    sym.kind == MTH) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   942
                    //### Should intern methodName as Name.
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   943
                    if (hasParameterTypes((MethodSymbol)sym, paramTypes)) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
   944
                        return env.getMethodDoc((MethodSymbol)sym);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   945
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   946
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   947
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   948
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   949
06bc494ca11e Initial load
duke
parents:
diff changeset
   950
        //### If we found a MethodDoc above, but which did not pass
06bc494ca11e Initial load
duke
parents:
diff changeset
   951
        //### the modifier filter, we should return failure here!
06bc494ca11e Initial load
duke
parents:
diff changeset
   952
06bc494ca11e Initial load
duke
parents:
diff changeset
   953
        // search superclass
06bc494ca11e Initial load
duke
parents:
diff changeset
   954
        cdi = (ClassDocImpl)superclass();
06bc494ca11e Initial load
duke
parents:
diff changeset
   955
        if (cdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   956
            mdi = cdi.searchMethod(methodName, paramTypes, searched);
06bc494ca11e Initial load
duke
parents:
diff changeset
   957
            if (mdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   958
                return mdi;
06bc494ca11e Initial load
duke
parents:
diff changeset
   959
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   960
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   961
06bc494ca11e Initial load
duke
parents:
diff changeset
   962
        // search interfaces
22159
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 21020
diff changeset
   963
        for (ClassDoc intf : interfaces()) {
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 21020
diff changeset
   964
            cdi = (ClassDocImpl) intf;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   965
            mdi = cdi.searchMethod(methodName, paramTypes, searched);
06bc494ca11e Initial load
duke
parents:
diff changeset
   966
            if (mdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   967
                return mdi;
06bc494ca11e Initial load
duke
parents:
diff changeset
   968
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   969
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   970
06bc494ca11e Initial load
duke
parents:
diff changeset
   971
        // search enclosing class
06bc494ca11e Initial load
duke
parents:
diff changeset
   972
        cdi = (ClassDocImpl)containingClass();
06bc494ca11e Initial load
duke
parents:
diff changeset
   973
        if (cdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   974
            mdi = cdi.searchMethod(methodName, paramTypes, searched);
06bc494ca11e Initial load
duke
parents:
diff changeset
   975
            if (mdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   976
                return mdi;
06bc494ca11e Initial load
duke
parents:
diff changeset
   977
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   978
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   979
06bc494ca11e Initial load
duke
parents:
diff changeset
   980
        //###(gj) As a temporary measure until type variables are better
06bc494ca11e Initial load
duke
parents:
diff changeset
   981
        //### handled, try again without the parameter types.
06bc494ca11e Initial load
duke
parents:
diff changeset
   982
        //### This should most often find the right method, and occassionally
06bc494ca11e Initial load
duke
parents:
diff changeset
   983
        //### find the wrong one.
06bc494ca11e Initial load
duke
parents:
diff changeset
   984
        //if (paramTypes != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   985
        //    return findMethod(methodName, null);
06bc494ca11e Initial load
duke
parents:
diff changeset
   986
        //}
06bc494ca11e Initial load
duke
parents:
diff changeset
   987
06bc494ca11e Initial load
duke
parents:
diff changeset
   988
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   989
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   990
06bc494ca11e Initial load
duke
parents:
diff changeset
   991
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   992
     * Find constructor in this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   993
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   994
     * @param constrName the unqualified name to search for.
14259
fb94a1df0d53 8000208: fix langtools javadoc comment issues
jjg
parents: 14258
diff changeset
   995
     * @param paramTypes the array of Strings for constructor parameters.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   996
     * @return the first ConstructorDocImpl which matches, null if not found.
06bc494ca11e Initial load
duke
parents:
diff changeset
   997
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   998
    public ConstructorDoc findConstructor(String constrName,
06bc494ca11e Initial load
duke
parents:
diff changeset
   999
                                          String[] paramTypes) {
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 10
diff changeset
  1000
        Names names = tsym.name.table.names;
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
  1001
        for (Symbol sym : tsym.members().getSymbolsByName(names.fromString("<init>"))) {
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
  1002
            if (sym.kind == MTH) {
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
  1003
                if (hasParameterTypes((MethodSymbol)sym, paramTypes)) {
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
  1004
                    return env.getConstructorDoc((MethodSymbol)sym);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1005
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1006
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1007
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1008
06bc494ca11e Initial load
duke
parents:
diff changeset
  1009
        //###(gj) As a temporary measure until type variables are better
06bc494ca11e Initial load
duke
parents:
diff changeset
  1010
        //### handled, try again without the parameter types.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1011
        //### This will often find the right constructor, and occassionally
06bc494ca11e Initial load
duke
parents:
diff changeset
  1012
        //### find the wrong one.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1013
        //if (paramTypes != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1014
        //    return findConstructor(constrName, null);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1015
        //}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1016
06bc494ca11e Initial load
duke
parents:
diff changeset
  1017
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1018
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1019
06bc494ca11e Initial load
duke
parents:
diff changeset
  1020
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1021
     * Find a field in this class scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1022
     * Search order: this class, outerclasses, interfaces,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1023
     * superclasses. IMP: If see tag is defined in an inner class,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1024
     * which extends a super class and if outerclass and the super
06bc494ca11e Initial load
duke
parents:
diff changeset
  1025
     * class have a visible field in common then Java compiler cribs
06bc494ca11e Initial load
duke
parents:
diff changeset
  1026
     * about the ambiguity, but the following code will search in the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1027
     * above given search order.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1028
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1029
     * @param fieldName the unqualified name to search for.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1030
     * @return the first FieldDocImpl which matches, null if not found.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1031
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1032
    public FieldDoc findField(String fieldName) {
22165
ec53c8946fc2 8030807: langtools should still build using jdk 7
vromero
parents: 22163
diff changeset
  1033
        return searchField(fieldName, new HashSet<ClassDocImpl>());
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1034
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1035
06bc494ca11e Initial load
duke
parents:
diff changeset
  1036
    private FieldDocImpl searchField(String fieldName, Set<ClassDocImpl> searched) {
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 10
diff changeset
  1037
        Names names = tsym.name.table.names;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1038
        if (searched.contains(this)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1039
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1040
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1041
        searched.add(this);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1042
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
  1043
        for (Symbol sym : tsym.members().getSymbolsByName(names.fromString(fieldName))) {
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
  1044
            if (sym.kind == VAR) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1045
                //### Should intern fieldName as Name.
25443
9187d77f2c64 8031569: Refactor javac scope implementation to enable lazy imports
jlahoda
parents: 23799
diff changeset
  1046
                return env.getFieldDoc((VarSymbol)sym);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1047
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1048
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1049
06bc494ca11e Initial load
duke
parents:
diff changeset
  1050
        //### If we found a FieldDoc above, but which did not pass
06bc494ca11e Initial load
duke
parents:
diff changeset
  1051
        //### the modifier filter, we should return failure here!
06bc494ca11e Initial load
duke
parents:
diff changeset
  1052
06bc494ca11e Initial load
duke
parents:
diff changeset
  1053
        ClassDocImpl cdi = (ClassDocImpl)containingClass();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1054
        if (cdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1055
            FieldDocImpl fdi = cdi.searchField(fieldName, searched);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1056
            if (fdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1057
                return fdi;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1058
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1059
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1060
06bc494ca11e Initial load
duke
parents:
diff changeset
  1061
        // search superclass
06bc494ca11e Initial load
duke
parents:
diff changeset
  1062
        cdi = (ClassDocImpl)superclass();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1063
        if (cdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1064
            FieldDocImpl fdi = cdi.searchField(fieldName, searched);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1065
            if (fdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1066
                return fdi;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1067
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1068
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1069
06bc494ca11e Initial load
duke
parents:
diff changeset
  1070
        // search interfaces
22159
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 21020
diff changeset
  1071
        for (ClassDoc intf : interfaces()) {
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 21020
diff changeset
  1072
            cdi = (ClassDocImpl) intf;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1073
            FieldDocImpl fdi = cdi.searchField(fieldName, searched);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1074
            if (fdi != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1075
                return fdi;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1076
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1077
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1078
06bc494ca11e Initial load
duke
parents:
diff changeset
  1079
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1080
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1081
06bc494ca11e Initial load
duke
parents:
diff changeset
  1082
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1083
     * Get the list of classes declared as imported.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1084
     * These are called "single-type-import declarations" in the JLS.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1085
     * This method is deprecated in the ClassDoc interface.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1086
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1087
     * @return an array of ClassDocImpl representing the imported classes.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1088
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1089
     * @deprecated  Import declarations are implementation details that
06bc494ca11e Initial load
duke
parents:
diff changeset
  1090
     *          should not be exposed here.  In addition, not all imported
06bc494ca11e Initial load
duke
parents:
diff changeset
  1091
     *          classes are imported through single-type-import declarations.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1092
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1093
    @Deprecated
06bc494ca11e Initial load
duke
parents:
diff changeset
  1094
    public ClassDoc[] importedClasses() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1095
        // information is not available for binary classfiles
06bc494ca11e Initial load
duke
parents:
diff changeset
  1096
        if (tsym.sourcefile == null) return new ClassDoc[0];
06bc494ca11e Initial load
duke
parents:
diff changeset
  1097
22163
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
  1098
        ListBuffer<ClassDocImpl> importedClasses = new ListBuffer<>();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1099
06bc494ca11e Initial load
duke
parents:
diff changeset
  1100
        Env<AttrContext> compenv = env.enter.getEnv(tsym);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1101
        if (compenv == null) return new ClassDocImpl[0];
06bc494ca11e Initial load
duke
parents:
diff changeset
  1102
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 10
diff changeset
  1103
        Name asterisk = tsym.name.table.names.asterisk;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1104
        for (JCTree t : compenv.toplevel.defs) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 10203
diff changeset
  1105
            if (t.hasTag(IMPORT)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1106
                JCTree imp = ((JCImport) t).qualid;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1107
                if ((TreeInfo.name(imp) != asterisk) &&
27224
228abfa87080 8054457: Refactor Symbol kinds from small ints to an enum
emc
parents: 25874
diff changeset
  1108
                    imp.type.tsym.kind.matches(KindSelector.TYP)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1109
                    importedClasses.append(
06bc494ca11e Initial load
duke
parents:
diff changeset
  1110
                            env.getClassDoc((ClassSymbol)imp.type.tsym));
06bc494ca11e Initial load
duke
parents:
diff changeset
  1111
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1112
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1113
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1114
06bc494ca11e Initial load
duke
parents:
diff changeset
  1115
        return importedClasses.toArray(new ClassDocImpl[importedClasses.length()]);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1116
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1117
06bc494ca11e Initial load
duke
parents:
diff changeset
  1118
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1119
     * Get the list of packages declared as imported.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1120
     * These are called "type-import-on-demand declarations" in the JLS.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1121
     * This method is deprecated in the ClassDoc interface.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1122
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1123
     * @return an array of PackageDocImpl representing the imported packages.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1124
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1125
     * ###NOTE: the syntax supports importing all inner classes from a class as well.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1126
     * @deprecated  Import declarations are implementation details that
06bc494ca11e Initial load
duke
parents:
diff changeset
  1127
     *          should not be exposed here.  In addition, this method's
06bc494ca11e Initial load
duke
parents:
diff changeset
  1128
     *          return type does not allow for all type-import-on-demand
06bc494ca11e Initial load
duke
parents:
diff changeset
  1129
     *          declarations to be returned.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1130
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1131
    @Deprecated
06bc494ca11e Initial load
duke
parents:
diff changeset
  1132
    public PackageDoc[] importedPackages() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1133
        // information is not available for binary classfiles
06bc494ca11e Initial load
duke
parents:
diff changeset
  1134
        if (tsym.sourcefile == null) return new PackageDoc[0];
06bc494ca11e Initial load
duke
parents:
diff changeset
  1135
22163
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
  1136
        ListBuffer<PackageDocImpl> importedPackages = new ListBuffer<>();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1137
06bc494ca11e Initial load
duke
parents:
diff changeset
  1138
        //### Add the implicit "import java.lang.*" to the result
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 10
diff changeset
  1139
        Names names = tsym.name.table.names;
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 32800
diff changeset
  1140
        importedPackages.append(env.getPackageDoc(env.syms.enterPackage(env.syms.java_base, names.java_lang)));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1141
06bc494ca11e Initial load
duke
parents:
diff changeset
  1142
        Env<AttrContext> compenv = env.enter.getEnv(tsym);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1143
        if (compenv == null) return new PackageDocImpl[0];
06bc494ca11e Initial load
duke
parents:
diff changeset
  1144
06bc494ca11e Initial load
duke
parents:
diff changeset
  1145
        for (JCTree t : compenv.toplevel.defs) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 10203
diff changeset
  1146
            if (t.hasTag(IMPORT)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1147
                JCTree imp = ((JCImport) t).qualid;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1148
                if (TreeInfo.name(imp) == names.asterisk) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1149
                    JCFieldAccess sel = (JCFieldAccess)imp;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1150
                    Symbol s = sel.selected.type.tsym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1151
                    PackageDocImpl pdoc = env.getPackageDoc(s.packge());
06bc494ca11e Initial load
duke
parents:
diff changeset
  1152
                    if (!importedPackages.contains(pdoc))
06bc494ca11e Initial load
duke
parents:
diff changeset
  1153
                        importedPackages.append(pdoc);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1154
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1155
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1156
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1157
06bc494ca11e Initial load
duke
parents:
diff changeset
  1158
        return importedPackages.toArray(new PackageDocImpl[importedPackages.length()]);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1159
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1160
06bc494ca11e Initial load
duke
parents:
diff changeset
  1161
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1162
     * Return the type's dimension information.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1163
     * Always return "", as this is not an array type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1164
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1165
    public String dimension() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1166
        return "";
06bc494ca11e Initial load
duke
parents:
diff changeset
  1167
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1168
06bc494ca11e Initial load
duke
parents:
diff changeset
  1169
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1170
     * Return this type as a class, which it already is.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1171
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1172
    public ClassDoc asClassDoc() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1173
        return this;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1174
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1175
06bc494ca11e Initial load
duke
parents:
diff changeset
  1176
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1177
     * Return null (unless overridden), as this is not an annotation type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1178
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1179
    public AnnotationTypeDoc asAnnotationTypeDoc() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1180
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1181
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1182
06bc494ca11e Initial load
duke
parents:
diff changeset
  1183
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1184
     * Return null, as this is not a class instantiation.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1185
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1186
    public ParameterizedType asParameterizedType() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1187
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1188
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1189
06bc494ca11e Initial load
duke
parents:
diff changeset
  1190
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1191
     * Return null, as this is not a type variable.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1192
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1193
    public TypeVariable asTypeVariable() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1194
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1195
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1196
06bc494ca11e Initial load
duke
parents:
diff changeset
  1197
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1198
     * Return null, as this is not a wildcard type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1199
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1200
    public WildcardType asWildcardType() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1201
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1202
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1203
06bc494ca11e Initial load
duke
parents:
diff changeset
  1204
    /**
15385
ee1eebe7e210 8006775: JSR 308: Compiler changes in JDK8
jjg
parents: 14951
diff changeset
  1205
     * Returns null, as this is not an annotated type.
ee1eebe7e210 8006775: JSR 308: Compiler changes in JDK8
jjg
parents: 14951
diff changeset
  1206
     */
ee1eebe7e210 8006775: JSR 308: Compiler changes in JDK8
jjg
parents: 14951
diff changeset
  1207
    public AnnotatedType asAnnotatedType() {
ee1eebe7e210 8006775: JSR 308: Compiler changes in JDK8
jjg
parents: 14951
diff changeset
  1208
        return null;
ee1eebe7e210 8006775: JSR 308: Compiler changes in JDK8
jjg
parents: 14951
diff changeset
  1209
    }
ee1eebe7e210 8006775: JSR 308: Compiler changes in JDK8
jjg
parents: 14951
diff changeset
  1210
ee1eebe7e210 8006775: JSR 308: Compiler changes in JDK8
jjg
parents: 14951
diff changeset
  1211
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1212
     * Return false, as this is not a primitive type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1213
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1214
    public boolean isPrimitive() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1215
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1216
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1217
06bc494ca11e Initial load
duke
parents:
diff changeset
  1218
    //--- Serialization ---
06bc494ca11e Initial load
duke
parents:
diff changeset
  1219
06bc494ca11e Initial load
duke
parents:
diff changeset
  1220
    //### These methods ignore modifier filter.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1221
06bc494ca11e Initial load
duke
parents:
diff changeset
  1222
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1223
     * Return true if this class implements <code>java.io.Serializable</code>.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1224
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1225
     * Since <code>java.io.Externalizable</code> extends
06bc494ca11e Initial load
duke
parents:
diff changeset
  1226
     * <code>java.io.Serializable</code>,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1227
     * Externalizable objects are also Serializable.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1228
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1229
    public boolean isSerializable() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1230
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1231
            return env.types.isSubtype(type, env.syms.serializableType);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1232
        } catch (CompletionFailure ex) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1233
            // quietly ignore completion failures
06bc494ca11e Initial load
duke
parents:
diff changeset
  1234
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1235
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1236
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1237
06bc494ca11e Initial load
duke
parents:
diff changeset
  1238
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1239
     * Return true if this class implements
06bc494ca11e Initial load
duke
parents:
diff changeset
  1240
     * <code>java.io.Externalizable</code>.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1241
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1242
    public boolean isExternalizable() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1243
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1244
            return env.types.isSubtype(type, env.externalizableSym.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1245
        } catch (CompletionFailure ex) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1246
            // quietly ignore completion failures
06bc494ca11e Initial load
duke
parents:
diff changeset
  1247
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1248
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1249
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1250
06bc494ca11e Initial load
duke
parents:
diff changeset
  1251
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1252
     * Return the serialization methods for this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1253
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1254
     * @return an array of <code>MethodDocImpl</code> that represents
06bc494ca11e Initial load
duke
parents:
diff changeset
  1255
     * the serialization methods for this class.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1256
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1257
    public MethodDoc[] serializationMethods() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1258
        if (serializedForm == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1259
            serializedForm = new SerializedForm(env, tsym, this);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1260
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1261
        //### Clone this?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1262
        return serializedForm.methods();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1263
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1264
06bc494ca11e Initial load
duke
parents:
diff changeset
  1265
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1266
     * Return the Serializable fields of class.<p>
06bc494ca11e Initial load
duke
parents:
diff changeset
  1267
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1268
     * Return either a list of default fields documented by
06bc494ca11e Initial load
duke
parents:
diff changeset
  1269
     * <code>serial</code> tag<br>
06bc494ca11e Initial load
duke
parents:
diff changeset
  1270
     * or return a single <code>FieldDoc</code> for
06bc494ca11e Initial load
duke
parents:
diff changeset
  1271
     * <code>serialPersistentField</code> member.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1272
     * There should be a <code>serialField</code> tag for
06bc494ca11e Initial load
duke
parents:
diff changeset
  1273
     * each Serializable field defined by an <code>ObjectStreamField</code>
06bc494ca11e Initial load
duke
parents:
diff changeset
  1274
     * array component of <code>serialPersistentField</code>.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1275
     *
31751
ec251536a004 8080880: some docs cleanup for langtools
avstepan
parents: 30066
diff changeset
  1276
     * @return an array of {@code FieldDoc} for the Serializable fields
ec251536a004 8080880: some docs cleanup for langtools
avstepan
parents: 30066
diff changeset
  1277
     *         of this class.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1278
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1279
     * @see #definesSerializableFields()
06bc494ca11e Initial load
duke
parents:
diff changeset
  1280
     * @see SerialFieldTagImpl
06bc494ca11e Initial load
duke
parents:
diff changeset
  1281
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1282
    public FieldDoc[] serializableFields() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1283
        if (serializedForm == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1284
            serializedForm = new SerializedForm(env, tsym, this);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1285
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1286
        //### Clone this?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1287
        return serializedForm.fields();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1288
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1289
06bc494ca11e Initial load
duke
parents:
diff changeset
  1290
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1291
     * Return true if Serializable fields are explicitly defined with
06bc494ca11e Initial load
duke
parents:
diff changeset
  1292
     * the special class member <code>serialPersistentFields</code>.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1293
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1294
     * @see #serializableFields()
06bc494ca11e Initial load
duke
parents:
diff changeset
  1295
     * @see SerialFieldTagImpl
06bc494ca11e Initial load
duke
parents:
diff changeset
  1296
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1297
    public boolean definesSerializableFields() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1298
        if (!isSerializable() || isExternalizable()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1299
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1300
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1301
            if (serializedForm == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1302
                serializedForm = new SerializedForm(env, tsym, this);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1303
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1304
            //### Clone this?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1305
            return serializedForm.definesSerializableFields();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1306
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1307
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1308
06bc494ca11e Initial load
duke
parents:
diff changeset
  1309
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1310
     * Determine if a class is a RuntimeException.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1311
     * <p>
06bc494ca11e Initial load
duke
parents:
diff changeset
  1312
     * Used only by ThrowsTagImpl.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1313
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1314
    boolean isRuntimeException() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1315
        return tsym.isSubClass(env.syms.runtimeExceptionType.tsym, env.types);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1316
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1317
06bc494ca11e Initial load
duke
parents:
diff changeset
  1318
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1319
     * Return the source position of the entity, or null if
06bc494ca11e Initial load
duke
parents:
diff changeset
  1320
     * no position is available.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1321
     */
8631
664f84942e74 6866185: Util.getPackageSourcePath should use lastIndexOf not indexOf and related cleanup
jjg
parents: 7681
diff changeset
  1322
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1323
    public SourcePosition position() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1324
        if (tsym.sourcefile == null) return null;
1869
0e193a8f3520 6794582: javadoc should read files using a FileManager
jjg
parents: 1264
diff changeset
  1325
        return SourcePositionImpl.make(tsym.sourcefile,
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1326
                                       (tree==null) ? Position.NOPOS : tree.pos,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1327
                                       lineMap);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1328
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1329
}