jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java@4a6f853f8721 (annotated)

src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java@4a6f853f8721 (annotated)

src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java

Thu, 02 Jan 2014 02:15:21 -0800

author: bpatel
date: Thu, 02 Jan 2014 02:15:21 -0800
changeset 2233: 4a6f853f8721
parent 2113: 7d266a2b31b2
child 2525: 2eb010b6cb22
child 2906: d3a51adc115f
permissions: -rw-r--r--

8029143: javadoc standard doclet should add Functional Interface blurb when @FunctionalInterface annotation is present
Reviewed-by: jjg

 /*
  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.tools.javadoc;
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
 import java.net.URI;
 import java.util.HashSet;
 import java.util.Set;
 import javax.tools.FileObject;
 import javax.tools.JavaFileManager.Location;
 import javax.tools.StandardJavaFileManager;
 import javax.tools.StandardLocation;
 import com.sun.javadoc.*;
 import com.sun.source.util.TreePath;
 import com.sun.tools.javac.code.Flags;
 import com.sun.tools.javac.code.Kinds;
 import com.sun.tools.javac.code.Scope;
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Type.ClassType;
 import com.sun.tools.javac.code.TypeTag;
 import com.sun.tools.javac.comp.AttrContext;
 import com.sun.tools.javac.comp.Env;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
 import com.sun.tools.javac.tree.JCTree.JCImport;
 import com.sun.tools.javac.tree.TreeInfo;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 import com.sun.tools.javac.util.Position;
 import static com.sun.tools.javac.code.Kinds.*;
 import static com.sun.tools.javac.code.TypeTag.CLASS;
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
 /**
  * Represents a java class and provides access to information
  * about the class, the class' comment and tags, and the
  * members of the class.  A ClassDocImpl only exists if it was
  * processed in this run of javadoc.  References to classes
  * which may or may not have been processed in this run are
  * referred to using Type (which can be converted to ClassDocImpl,
  * if possible).
  *
  *  <p><b>This is NOT part of any supported API.
  *  If you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  *
  * @see Type
  *
  * @since 1.2
  * @author Robert Field
  * @author Neal Gafter (rewrite)
  * @author Scott Seligman (generics, enums, annotations)
  */
 public class ClassDocImpl extends ProgramElementDocImpl implements ClassDoc {
     public final ClassType type;        // protected->public for debugging
     protected final ClassSymbol tsym;
     boolean isIncluded = false;         // Set in RootDocImpl
     private SerializedForm serializedForm;
     /**
      * Constructor
      */
     public ClassDocImpl(DocEnv env, ClassSymbol sym) {
         this(env, sym, null);
     }
     /**
      * Constructor
      */
     public ClassDocImpl(DocEnv env, ClassSymbol sym, TreePath treePath) {
         super(env, sym, treePath);
         this.type = (ClassType)sym.type;
         this.tsym = sym;
     }
     public com.sun.javadoc.Type getElementType() {
         return null;
     }
     /**
      * Returns the flags in terms of javac's flags
      */
     protected long getFlags() {
         return getFlags(tsym);
     }
     /**
      * Returns the flags of a ClassSymbol in terms of javac's flags
      */
     static long getFlags(ClassSymbol clazz) {
         while (true) {
             try {
                 return clazz.flags();
             } catch (CompletionFailure ex) {
                 /* Quietly ignore completion failures.
                  * Note that a CompletionFailure can only
                  * occur as a result of calling complete(),
                  * which will always remove the current
                  * completer, leaving it to be null or
                  * follow-up completer. Thus the loop
                  * is guaranteed to eventually terminate.
                  */
             }
         }
     }
     /**
      * Is a ClassSymbol an annotation type?
      */
     static boolean isAnnotationType(ClassSymbol clazz) {
         return (getFlags(clazz) & Flags.ANNOTATION) != 0;
     }
     /**
      * Identify the containing class
      */
     protected ClassSymbol getContainingClass() {
         return tsym.owner.enclClass();
     }
     /**
      * Return true if this is a class, not an interface.
      */
     @Override
     public boolean isClass() {
         return !Modifier.isInterface(getModifiers());
     }
     /**
      * Return true if this is a ordinary class,
      * not an enumeration, exception, an error, or an interface.
      */
     @Override
     public boolean isOrdinaryClass() {
         if (isEnum() || isInterface() || isAnnotationType()) {
             return false;
         }
         for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
             if (t.tsym == env.syms.errorType.tsym ||
                 t.tsym == env.syms.exceptionType.tsym) {
                 return false;
             }
         }
         return true;
     }
     /**
      * Return true if this is an enumeration.
      * (For legacy doclets, return false.)
      */
     @Override
     public boolean isEnum() {
         return (getFlags() & Flags.ENUM) != 0
                &&
                !env.legacyDoclet;
     }
     /**
      * Return true if this is an interface, but not an annotation type.
      * Overridden by AnnotationTypeDocImpl.
      */
     @Override
     public boolean isInterface() {
         return Modifier.isInterface(getModifiers());
     }
     /**
      * Return true if this is an exception class
      */
     @Override
     public boolean isException() {
         if (isEnum() || isInterface() || isAnnotationType()) {
             return false;
         }
         for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
             if (t.tsym == env.syms.exceptionType.tsym) {
                 return true;
             }
         }
         return false;
     }
     /**
      * Return true if this is an error class
      */
     @Override
     public boolean isError() {
         if (isEnum() || isInterface() || isAnnotationType()) {
             return false;
         }
         for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
             if (t.tsym == env.syms.errorType.tsym) {
                 return true;
             }
         }
         return false;
     }
     /**
      * Return true if this is a throwable class
      */
     public boolean isThrowable() {
         if (isEnum() || isInterface() || isAnnotationType()) {
             return false;
         }
         for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
             if (t.tsym == env.syms.throwableType.tsym) {
                 return true;
             }
         }
         return false;
     }
     /**
      * Return true if this class is abstract
      */
     public boolean isAbstract() {
         return Modifier.isAbstract(getModifiers());
     }
     /**
      * Returns true if this class was synthesized by the compiler.
      */
     public boolean isSynthetic() {
         return (getFlags() & Flags.SYNTHETIC) != 0;
     }
     /**
      * Return true if this class is included in the active set.
      * A ClassDoc is included iff either it is specified on the
      * commandline, or if it's containing package is specified
      * on the command line, or if it is a member class of an
      * included class.
      */
     public boolean isIncluded() {
         if (isIncluded) {
             return true;
         }
         if (env.shouldDocument(tsym)) {
             // Class is nameable from top-level and
             // the class and all enclosing classes
             // pass the modifier filter.
             if (containingPackage().isIncluded()) {
                 return isIncluded=true;
             }
             ClassDoc outer = containingClass();
             if (outer != null && outer.isIncluded()) {
                 return isIncluded=true;
             }
         }
         return false;
     }
     /**
      * Return the package that this class is contained in.
      */
     @Override
     public PackageDoc containingPackage() {
         PackageDocImpl p = env.getPackageDoc(tsym.packge());
         if (p.setDocPath == false) {
             FileObject docPath;
             try {
                 Location location = env.fileManager.hasLocation(StandardLocation.SOURCE_PATH)
                     ? StandardLocation.SOURCE_PATH : StandardLocation.CLASS_PATH;
                 docPath = env.fileManager.getFileForInput(
                         location, p.qualifiedName(), "package.html");
             } catch (IOException e) {
                 docPath = null;
             }
             if (docPath == null) {
                 // fall back on older semantics of looking in same directory as
                 // source file for this class
                 SourcePosition po = position();
                 if (env.fileManager instanceof StandardJavaFileManager &&
                         po instanceof SourcePositionImpl) {
                     URI uri = ((SourcePositionImpl) po).filename.toUri();
                     if ("file".equals(uri.getScheme())) {
                         File f = new File(uri);
                         File dir = f.getParentFile();
                         if (dir != null) {
                             File pf = new File(dir, "package.html");
                             if (pf.exists()) {
                                 StandardJavaFileManager sfm = (StandardJavaFileManager) env.fileManager;
                                 docPath = sfm.getJavaFileObjects(pf).iterator().next();
                             }
                         }
                     }
                 }
             }
             p.setDocPath(docPath);
         }
         return p;
     }
     /**
      * Return the class name without package qualifier - but with
      * enclosing class qualifier - as a String.
      * <pre>
      * Examples:
      *  for java.util.Hashtable
      *  return Hashtable
      *  for java.util.Map.Entry
      *  return Map.Entry
      * </pre>
      */
     public String name() {
         if (name == null) {
             name = getClassName(tsym, false);
         }
         return name;
     }
     private String name;
     /**
      * Return the qualified class name as a String.
      * <pre>
      * Example:
      *  for java.util.Hashtable
      *  return java.util.Hashtable
      *  if no qualifier, just return flat name
      * </pre>
      */
     public String qualifiedName() {
         if (qualifiedName == null) {
             qualifiedName = getClassName(tsym, true);
         }
         return qualifiedName;
     }
     private String qualifiedName;
     /**
      * Return unqualified name of type excluding any dimension information.
      * <p>
      * For example, a two dimensional array of String returns 'String'.
      */
     public String typeName() {
         return name();
     }
     /**
      * Return qualified name of type excluding any dimension information.
      *<p>
      * For example, a two dimensional array of String
      * returns 'java.lang.String'.
      */
     public String qualifiedTypeName() {
         return qualifiedName();
     }
     /**
      * Return the simple name of this type.
      */
     public String simpleTypeName() {
         if (simpleTypeName == null) {
             simpleTypeName = tsym.name.toString();
         }
         return simpleTypeName;
     }
     private String simpleTypeName;
     /**
      * Return the qualified name and any type parameters.
      * Each parameter is a type variable with optional bounds.
      */
     @Override
     public String toString() {
         return classToString(env, tsym, true);
     }
     /**
      * Return the class name as a string.  If "full" is true the name is
      * qualified, otherwise it is qualified by its enclosing class(es) only.
      */
     static String getClassName(ClassSymbol c, boolean full) {
         if (full) {
             return c.getQualifiedName().toString();
         } else {
             String n = "";
             for ( ; c != null; c = c.owner.enclClass()) {
                 n = c.name + (n.equals("") ? "" : ".") + n;
             }
             return n;
         }
     }
     /**
      * Return the class name with any type parameters as a string.
      * Each parameter is a type variable with optional bounds.
      * If "full" is true all names are qualified, otherwise they are
      * qualified by their enclosing class(es) only.
      */
     static String classToString(DocEnv env, ClassSymbol c, boolean full) {
         StringBuilder s = new StringBuilder();
         if (!c.isInner()) {             // if c is not an inner class
             s.append(getClassName(c, full));
         } else {
             // c is an inner class, so include type params of outer.
             ClassSymbol encl = c.owner.enclClass();
             s.append(classToString(env, encl, full))
              .append('.')
              .append(c.name);
         }
         s.append(TypeMaker.typeParametersString(env, c, full));
         return s.toString();
     }
     /**
      * Is this class (or any enclosing class) generic?  That is, does
      * it have type parameters?
      */
     static boolean isGeneric(ClassSymbol c) {
         return c.type.allparams().nonEmpty();
     }
     /**
      * Return the formal type parameters of this class or interface.
      * Return an empty array if there are none.
      */
     public TypeVariable[] typeParameters() {
         if (env.legacyDoclet) {
             return new TypeVariable[0];
         }
         TypeVariable res[] = new TypeVariable[type.getTypeArguments().length()];
         TypeMaker.getTypes(env, type.getTypeArguments(), res);
         return res;
     }
     /**
      * Return the type parameter tags of this class or interface.
      */
     public ParamTag[] typeParamTags() {
         return (env.legacyDoclet)
             ? new ParamTag[0]
             : comment().typeParamTags();
     }
     /**
      * Return the modifier string for this class. If it's an interface
      * exclude 'abstract' keyword from the modifier string
      */
     @Override
     public String modifiers() {
         return Modifier.toString(modifierSpecifier());
     }
     @Override
     public int modifierSpecifier() {
         int modifiers = getModifiers();
         return (isInterface() || isAnnotationType())
                 ? modifiers & ~Modifier.ABSTRACT
                 : modifiers;
     }
     /**
      * Return the superclass of this class
      *
      * @return the ClassDocImpl for the superclass of this class, null
      * if there is no superclass.
      */
     public ClassDoc superclass() {
         if (isInterface() || isAnnotationType()) return null;
         if (tsym == env.syms.objectType.tsym) return null;
         ClassSymbol c = (ClassSymbol)env.types.supertype(type).tsym;
         if (c == null || c == tsym) c = (ClassSymbol)env.syms.objectType.tsym;
         return env.getClassDoc(c);
     }
     /**
      * Return the superclass of this class.  Return null if this is an
      * interface.  A superclass is represented by either a
      * <code>ClassDoc</code> or a <code>ParameterizedType</code>.
      */
     public com.sun.javadoc.Type superclassType() {
         if (isInterface() || isAnnotationType() ||
                 (tsym == env.syms.objectType.tsym))
             return null;
         Type sup = env.types.supertype(type);
         return TypeMaker.getType(env,
                                  (sup.hasTag(TypeTag.NONE)) ? env.syms.objectType : sup);
     }
     /**
      * Test whether this class is a subclass of the specified class.
      *
      * @param cd the candidate superclass.
      * @return true if cd is a superclass of this class.
      */
     public boolean subclassOf(ClassDoc cd) {
         return tsym.isSubClass(((ClassDocImpl)cd).tsym, env.types);
     }
     /**
      * Return interfaces implemented by this class or interfaces
      * extended by this interface.
      *
      * @return An array of ClassDocImpl representing the interfaces.
      * Return an empty array if there are no interfaces.
      */
     public ClassDoc[] interfaces() {
         ListBuffer<ClassDocImpl> ta = new ListBuffer<ClassDocImpl>();
         for (Type t : env.types.interfaces(type)) {
             ta.append(env.getClassDoc((ClassSymbol)t.tsym));
         }
         //### Cache ta here?
         return ta.toArray(new ClassDocImpl[ta.length()]);
     }
     /**
      * Return interfaces implemented by this class or interfaces extended
      * by this interface. Includes only directly-declared interfaces, not
      * inherited interfaces.
      * Return an empty array if there are no interfaces.
      */
     public com.sun.javadoc.Type[] interfaceTypes() {
         //### Cache result here?
         return TypeMaker.getTypes(env, env.types.interfaces(type));
     }
     /**
      * Return fields in class.
      * @param filter include only the included fields if filter==true
      */
     public FieldDoc[] fields(boolean filter) {
         return fields(filter, false);
     }
     /**
      * Return included fields in class.
      */
     public FieldDoc[] fields() {
         return fields(true, false);
     }
     /**
      * Return the enum constants if this is an enum type.
      */
     public FieldDoc[] enumConstants() {
         return fields(false, true);
     }
     /**
      * Return fields in class.
      * @param filter  if true, return only the included fields
      * @param enumConstants  if true, return the enum constants instead
      */
     private FieldDoc[] fields(boolean filter, boolean enumConstants) {
         List<FieldDocImpl> fields = List.nil();
         for (Scope.Entry e = tsym.members().elems; e != null; e = e.sibling) {
             if (e.sym != null && e.sym.kind == VAR) {
                 VarSymbol s = (VarSymbol)e.sym;
                 boolean isEnum = ((s.flags() & Flags.ENUM) != 0) &&
                                  !env.legacyDoclet;
                 if (isEnum == enumConstants &&
                         (!filter || env.shouldDocument(s))) {
                     fields = fields.prepend(env.getFieldDoc(s));
                 }
             }
         }
         return fields.toArray(new FieldDocImpl[fields.length()]);
     }
     /**
      * Return methods in class.
      * This method is overridden by AnnotationTypeDocImpl.
      *
      * @param filter include only the included methods if filter==true
      * @return an array of MethodDocImpl for representing the visible
      * methods in this class.  Does not include constructors.
      */
     public MethodDoc[] methods(boolean filter) {
         Names names = tsym.name.table.names;
         List<MethodDocImpl> methods = List.nil();
         for (Scope.Entry e = tsym.members().elems; e != null; e = e.sibling) {
             if (e.sym != null
                 && e.sym.kind == Kinds.MTH
                 && e.sym.name != names.init
                 && e.sym.name != names.clinit) {
                 MethodSymbol s = (MethodSymbol)e.sym;
                 if (!filter || env.shouldDocument(s)) {
                     methods = methods.prepend(env.getMethodDoc(s));
                 }
             }
         }
         //### Cache methods here?
         return methods.toArray(new MethodDocImpl[methods.length()]);
     }
     /**
      * Return included methods in class.
      *
      * @return an array of MethodDocImpl for representing the visible
      * methods in this class.  Does not include constructors.
      */
     public MethodDoc[] methods() {
         return methods(true);
     }
     /**
      * Return constructors in class.
      *
      * @param filter include only the included constructors if filter==true
      * @return an array of ConstructorDocImpl for representing the visible
      * constructors in this class.
      */
     public ConstructorDoc[] constructors(boolean filter) {
         Names names = tsym.name.table.names;
         List<ConstructorDocImpl> constructors = List.nil();
         for (Scope.Entry e = tsym.members().elems; e != null; e = e.sibling) {
             if (e.sym != null &&
                 e.sym.kind == Kinds.MTH && e.sym.name == names.init) {
                 MethodSymbol s = (MethodSymbol)e.sym;
                 if (!filter || env.shouldDocument(s)) {
                     constructors = constructors.prepend(env.getConstructorDoc(s));
                 }
             }
         }
         //### Cache constructors here?
         return constructors.toArray(new ConstructorDocImpl[constructors.length()]);
     }
     /**
      * Return included constructors in class.
      *
      * @return an array of ConstructorDocImpl for representing the visible
      * constructors in this class.
      */
     public ConstructorDoc[] constructors() {
         return constructors(true);
     }
     /**
      * Adds all inner classes of this class, and their
      * inner classes recursively, to the list l.
      */
     void addAllClasses(ListBuffer<ClassDocImpl> l, boolean filtered) {
         try {
             if (isSynthetic()) return;
             // sometimes synthetic classes are not marked synthetic
             if (!JavadocTool.isValidClassName(tsym.name.toString())) return;
             if (filtered && !env.shouldDocument(tsym)) return;
             if (l.contains(this)) return;
             l.append(this);
             List<ClassDocImpl> more = List.nil();
             for (Scope.Entry e = tsym.members().elems; e != null;
                  e = e.sibling) {
                 if (e.sym != null && e.sym.kind == Kinds.TYP) {
                     ClassSymbol s = (ClassSymbol)e.sym;
                     ClassDocImpl c = env.getClassDoc(s);
                     if (c.isSynthetic()) continue;
                     if (c != null) more = more.prepend(c);
                 }
             }
             // this extra step preserves the ordering from oldjavadoc
             for (; more.nonEmpty(); more=more.tail) {
                 more.head.addAllClasses(l, filtered);
             }
         } catch (CompletionFailure e) {
             // quietly ignore completion failures
         }
     }
     /**
      * Return inner classes within this class.
      *
      * @param filter include only the included inner classes if filter==true.
      * @return an array of ClassDocImpl for representing the visible
      * classes defined in this class. Anonymous and local classes
      * are not included.
      */
     public ClassDoc[] innerClasses(boolean filter) {
         ListBuffer<ClassDocImpl> innerClasses = new ListBuffer<ClassDocImpl>();
         for (Scope.Entry e = tsym.members().elems; e != null; e = e.sibling) {
             if (e.sym != null && e.sym.kind == Kinds.TYP) {
                 ClassSymbol s = (ClassSymbol)e.sym;
                 if ((s.flags_field & Flags.SYNTHETIC) != 0) continue;
                 if (!filter || env.isVisible(s)) {
                     innerClasses.prepend(env.getClassDoc(s));
                 }
             }
         }
         //### Cache classes here?
         return innerClasses.toArray(new ClassDocImpl[innerClasses.length()]);
     }
     /**
      * Return included inner classes within this class.
      *
      * @return an array of ClassDocImpl for representing the visible
      * classes defined in this class. Anonymous and local classes
      * are not included.
      */
     public ClassDoc[] innerClasses() {
         return innerClasses(true);
     }
     /**
      * Find a class within the context of this class.
      * Search order: qualified name, in this class (inner),
      * in this package, in the class imports, in the package
      * imports.
      * Return the ClassDocImpl if found, null if not found.
      */
     //### The specified search order is not the normal rule the
     //### compiler would use.  Leave as specified or change it?
     public ClassDoc findClass(String className) {
         ClassDoc searchResult = searchClass(className);
         if (searchResult == null) {
             ClassDocImpl enclosingClass = (ClassDocImpl)containingClass();
             //Expand search space to include enclosing class.
             while (enclosingClass != null && enclosingClass.containingClass() != null) {
                 enclosingClass = (ClassDocImpl)enclosingClass.containingClass();
             }
             searchResult = enclosingClass == null ?
                 null : enclosingClass.searchClass(className);
         }
         return searchResult;
     }
     private ClassDoc searchClass(String className) {
         Names names = tsym.name.table.names;
         // search by qualified name first
         ClassDoc cd = env.lookupClass(className);
         if (cd != null) {
             return cd;
         }
         // search inner classes
         //### Add private entry point to avoid creating array?
         //### Replicate code in innerClasses here to avoid consing?
         for (ClassDoc icd : innerClasses()) {
             if (icd.name().equals(className) ||
                     //### This is from original javadoc but it looks suspicious to me...
                     //### I believe it is attempting to compensate for the confused
                     //### convention of including the nested class qualifiers in the
                     //### 'name' of the inner class, rather than the true simple name.
                     icd.name().endsWith("." + className)) {
                 return icd;
             } else {
                 ClassDoc innercd = ((ClassDocImpl) icd).searchClass(className);
                 if (innercd != null) {
                     return innercd;
                 }
             }
         }
         // check in this package
         cd = containingPackage().findClass(className);
         if (cd != null) {
             return cd;
         }
         // make sure that this symbol has been completed
         if (tsym.completer != null) {
             tsym.complete();
         }
         // search imports
         if (tsym.sourcefile != null) {
             //### This information is available only for source classes.
             Env<AttrContext> compenv = env.enter.getEnv(tsym);
             if (compenv == null) return null;
             Scope s = compenv.toplevel.namedImportScope;
             for (Scope.Entry e = s.lookup(names.fromString(className)); e.scope != null; e = e.next()) {
                 if (e.sym.kind == Kinds.TYP) {
                     ClassDoc c = env.getClassDoc((ClassSymbol)e.sym);
                     return c;
                 }
             }
             s = compenv.toplevel.starImportScope;
             for (Scope.Entry e = s.lookup(names.fromString(className)); e.scope != null; e = e.next()) {
                 if (e.sym.kind == Kinds.TYP) {
                     ClassDoc c = env.getClassDoc((ClassSymbol)e.sym);
                     return c;
                 }
             }
         }
         return null; // not found
     }
     private boolean hasParameterTypes(MethodSymbol method, String[] argTypes) {
         if (argTypes == null) {
             // wildcard
             return true;
         }
         int i = 0;
         List<Type> types = method.type.getParameterTypes();
         if (argTypes.length != types.length()) {
             return false;
         }
         for (Type t : types) {
             String argType = argTypes[i++];
             // For vararg method, "T..." matches type T[].
             if (i == argTypes.length) {
                 argType = argType.replace("...", "[]");
             }
             if (!hasTypeName(env.types.erasure(t), argType)) {  //###(gj)
                 return false;
             }
         }
         return true;
     }
     // where
     private boolean hasTypeName(Type t, String name) {
         return
             name.equals(TypeMaker.getTypeName(t, true))
             ||
             name.equals(TypeMaker.getTypeName(t, false))
             ||
             (qualifiedName() + "." + name).equals(TypeMaker.getTypeName(t, true));
     }
     /**
      * Find a method in this class scope.
      * Search order: this class, interfaces, superclasses, outerclasses.
      * Note that this is not necessarily what the compiler would do!
      *
      * @param methodName the unqualified name to search for.
      * @param paramTypes the array of Strings for method parameter types.
      * @return the first MethodDocImpl which matches, null if not found.
      */
     public MethodDocImpl findMethod(String methodName, String[] paramTypes) {
         // Use hash table 'searched' to avoid searching same class twice.
         //### It is not clear how this could happen.
         return searchMethod(methodName, paramTypes, new HashSet<ClassDocImpl>());
     }
     private MethodDocImpl searchMethod(String methodName,
                                        String[] paramTypes, Set<ClassDocImpl> searched) {
         //### Note that this search is not necessarily what the compiler would do!
         Names names = tsym.name.table.names;
         // do not match constructors
         if (names.init.contentEquals(methodName)) {
             return null;
         }
         ClassDocImpl cdi;
         MethodDocImpl mdi;
         if (searched.contains(this)) {
             return null;
         }
         searched.add(this);
         //DEBUG
         /*---------------------------------*
          System.out.print("searching " + this + " for " + methodName);
          if (paramTypes == null) {
          System.out.println("()");
          } else {
          System.out.print("(");
          for (int k=0; k < paramTypes.length; k++) {
          System.out.print(paramTypes[k]);
          if ((k + 1) < paramTypes.length) {
          System.out.print(", ");
          }
          }
          System.out.println(")");
          }
          *---------------------------------*/
         // search current class
         Scope.Entry e = tsym.members().lookup(names.fromString(methodName));
         //### Using modifier filter here isn't really correct,
         //### but emulates the old behavior.  Instead, we should
         //### apply the normal rules of visibility and inheritance.
         if (paramTypes == null) {
             // If no parameters specified, we are allowed to return
             // any method with a matching name.  In practice, the old
             // code returned the first method, which is now the last!
             // In order to provide textually identical results, we
             // attempt to emulate the old behavior.
             MethodSymbol lastFound = null;
             for (; e.scope != null; e = e.next()) {
                 if (e.sym.kind == Kinds.MTH) {
                     //### Should intern methodName as Name.
                     if (e.sym.name.toString().equals(methodName)) {
                         lastFound = (MethodSymbol)e.sym;
                     }
                 }
             }
             if (lastFound != null) {
                 return env.getMethodDoc(lastFound);
             }
         } else {
             for (; e.scope != null; e = e.next()) {
                 if (e.sym != null &&
                     e.sym.kind == Kinds.MTH) {
                     //### Should intern methodName as Name.
                     if (hasParameterTypes((MethodSymbol)e.sym, paramTypes)) {
                         return env.getMethodDoc((MethodSymbol)e.sym);
                     }
                 }
             }
         }
         //### If we found a MethodDoc above, but which did not pass
         //### the modifier filter, we should return failure here!
         // search superclass
         cdi = (ClassDocImpl)superclass();
         if (cdi != null) {
             mdi = cdi.searchMethod(methodName, paramTypes, searched);
             if (mdi != null) {
                 return mdi;
             }
         }
         // search interfaces
         ClassDoc intf[] = interfaces();
         for (int i = 0; i < intf.length; i++) {
             cdi = (ClassDocImpl)intf[i];
             mdi = cdi.searchMethod(methodName, paramTypes, searched);
             if (mdi != null) {
                 return mdi;
             }
         }
         // search enclosing class
         cdi = (ClassDocImpl)containingClass();
         if (cdi != null) {
             mdi = cdi.searchMethod(methodName, paramTypes, searched);
             if (mdi != null) {
                 return mdi;
             }
         }
         //###(gj) As a temporary measure until type variables are better
         //### handled, try again without the parameter types.
         //### This should most often find the right method, and occassionally
         //### find the wrong one.
         //if (paramTypes != null) {
         //    return findMethod(methodName, null);
         //}
         return null;
     }
     /**
      * Find constructor in this class.
      *
      * @param constrName the unqualified name to search for.
      * @param paramTypes the array of Strings for constructor parameters.
      * @return the first ConstructorDocImpl which matches, null if not found.
      */
     public ConstructorDoc findConstructor(String constrName,
                                           String[] paramTypes) {
         Names names = tsym.name.table.names;
         for (Scope.Entry e = tsym.members().lookup(names.fromString("<init>")); e.scope != null; e = e.next()) {
             if (e.sym.kind == Kinds.MTH) {
                 if (hasParameterTypes((MethodSymbol)e.sym, paramTypes)) {
                     return env.getConstructorDoc((MethodSymbol)e.sym);
                 }
             }
         }
         //###(gj) As a temporary measure until type variables are better
         //### handled, try again without the parameter types.
         //### This will often find the right constructor, and occassionally
         //### find the wrong one.
         //if (paramTypes != null) {
         //    return findConstructor(constrName, null);
         //}
         return null;
     }
     /**
      * Find a field in this class scope.
      * Search order: this class, outerclasses, interfaces,
      * superclasses. IMP: If see tag is defined in an inner class,
      * which extends a super class and if outerclass and the super
      * class have a visible field in common then Java compiler cribs
      * about the ambiguity, but the following code will search in the
      * above given search order.
      *
      * @param fieldName the unqualified name to search for.
      * @return the first FieldDocImpl which matches, null if not found.
      */
     public FieldDoc findField(String fieldName) {
         return searchField(fieldName, new HashSet<ClassDocImpl>());
     }
     private FieldDocImpl searchField(String fieldName, Set<ClassDocImpl> searched) {
         Names names = tsym.name.table.names;
         if (searched.contains(this)) {
             return null;
         }
         searched.add(this);
         for (Scope.Entry e = tsym.members().lookup(names.fromString(fieldName)); e.scope != null; e = e.next()) {
             if (e.sym.kind == Kinds.VAR) {
                 //### Should intern fieldName as Name.
                 return env.getFieldDoc((VarSymbol)e.sym);
             }
         }
         //### If we found a FieldDoc above, but which did not pass
         //### the modifier filter, we should return failure here!
         ClassDocImpl cdi = (ClassDocImpl)containingClass();
         if (cdi != null) {
             FieldDocImpl fdi = cdi.searchField(fieldName, searched);
             if (fdi != null) {
                 return fdi;
             }
         }
         // search superclass
         cdi = (ClassDocImpl)superclass();
         if (cdi != null) {
             FieldDocImpl fdi = cdi.searchField(fieldName, searched);
             if (fdi != null) {
                 return fdi;
             }
         }
         // search interfaces
         ClassDoc intf[] = interfaces();
         for (int i = 0; i < intf.length; i++) {
             cdi = (ClassDocImpl)intf[i];
             FieldDocImpl fdi = cdi.searchField(fieldName, searched);
             if (fdi != null) {
                 return fdi;
             }
         }
         return null;
     }
     /**
      * Get the list of classes declared as imported.
      * These are called "single-type-import declarations" in the JLS.
      * This method is deprecated in the ClassDoc interface.
      *
      * @return an array of ClassDocImpl representing the imported classes.
      *
      * @deprecated  Import declarations are implementation details that
      *          should not be exposed here.  In addition, not all imported
      *          classes are imported through single-type-import declarations.
      */
     @Deprecated
     public ClassDoc[] importedClasses() {
         // information is not available for binary classfiles
         if (tsym.sourcefile == null) return new ClassDoc[0];
         ListBuffer<ClassDocImpl> importedClasses = new ListBuffer<ClassDocImpl>();
         Env<AttrContext> compenv = env.enter.getEnv(tsym);
         if (compenv == null) return new ClassDocImpl[0];
         Name asterisk = tsym.name.table.names.asterisk;
         for (JCTree t : compenv.toplevel.defs) {
             if (t.hasTag(IMPORT)) {
                 JCTree imp = ((JCImport) t).qualid;
                 if ((TreeInfo.name(imp) != asterisk) &&
                         (imp.type.tsym.kind & Kinds.TYP) != 0) {
                     importedClasses.append(
                             env.getClassDoc((ClassSymbol)imp.type.tsym));
                 }
             }
         }
         return importedClasses.toArray(new ClassDocImpl[importedClasses.length()]);
     }
     /**
      * Get the list of packages declared as imported.
      * These are called "type-import-on-demand declarations" in the JLS.
      * This method is deprecated in the ClassDoc interface.
      *
      * @return an array of PackageDocImpl representing the imported packages.
      *
      * ###NOTE: the syntax supports importing all inner classes from a class as well.
      * @deprecated  Import declarations are implementation details that
      *          should not be exposed here.  In addition, this method's
      *          return type does not allow for all type-import-on-demand
      *          declarations to be returned.
      */
     @Deprecated
     public PackageDoc[] importedPackages() {
         // information is not available for binary classfiles
         if (tsym.sourcefile == null) return new PackageDoc[0];
         ListBuffer<PackageDocImpl> importedPackages = new ListBuffer<PackageDocImpl>();
         //### Add the implicit "import java.lang.*" to the result
         Names names = tsym.name.table.names;
         importedPackages.append(env.getPackageDoc(env.reader.enterPackage(names.java_lang)));
         Env<AttrContext> compenv = env.enter.getEnv(tsym);
         if (compenv == null) return new PackageDocImpl[0];
         for (JCTree t : compenv.toplevel.defs) {
             if (t.hasTag(IMPORT)) {
                 JCTree imp = ((JCImport) t).qualid;
                 if (TreeInfo.name(imp) == names.asterisk) {
                     JCFieldAccess sel = (JCFieldAccess)imp;
                     Symbol s = sel.selected.type.tsym;
                     PackageDocImpl pdoc = env.getPackageDoc(s.packge());
                     if (!importedPackages.contains(pdoc))
                         importedPackages.append(pdoc);
                 }
             }
         }
         return importedPackages.toArray(new PackageDocImpl[importedPackages.length()]);
     }
     /**
      * Return the type's dimension information.
      * Always return "", as this is not an array type.
      */
     public String dimension() {
         return "";
     }
     /**
      * Return this type as a class, which it already is.
      */
     public ClassDoc asClassDoc() {
         return this;
     }
     /**
      * Return null (unless overridden), as this is not an annotation type.
      */
     public AnnotationTypeDoc asAnnotationTypeDoc() {
         return null;
     }
     /**
      * Return null, as this is not a class instantiation.
      */
     public ParameterizedType asParameterizedType() {
         return null;
     }
     /**
      * Return null, as this is not a type variable.
      */
     public TypeVariable asTypeVariable() {
         return null;
     }
     /**
      * Return null, as this is not a wildcard type.
      */
     public WildcardType asWildcardType() {
         return null;
     }
     /**
      * Returns null, as this is not an annotated type.
      */
     public AnnotatedType asAnnotatedType() {
         return null;
     }
     /**
      * Return false, as this is not a primitive type.
      */
     public boolean isPrimitive() {
         return false;
     }
     //--- Serialization ---
     //### These methods ignore modifier filter.
     /**
      * Return true if this class implements <code>java.io.Serializable</code>.
      *
      * Since <code>java.io.Externalizable</code> extends
      * <code>java.io.Serializable</code>,
      * Externalizable objects are also Serializable.
      */
     public boolean isSerializable() {
         try {
             return env.types.isSubtype(type, env.syms.serializableType);
         } catch (CompletionFailure ex) {
             // quietly ignore completion failures
             return false;
         }
     }
     /**
      * Return true if this class implements
      * <code>java.io.Externalizable</code>.
      */
     public boolean isExternalizable() {
         try {
             return env.types.isSubtype(type, env.externalizableSym.type);
         } catch (CompletionFailure ex) {
             // quietly ignore completion failures
             return false;
         }
     }
     /**
      * Return the serialization methods for this class.
      *
      * @return an array of <code>MethodDocImpl</code> that represents
      * the serialization methods for this class.
      */
     public MethodDoc[] serializationMethods() {
         if (serializedForm == null) {
             serializedForm = new SerializedForm(env, tsym, this);
         }
         //### Clone this?
         return serializedForm.methods();
     }
     /**
      * Return the Serializable fields of class.<p>
      *
      * Return either a list of default fields documented by
      * <code>serial</code> tag<br>
      * or return a single <code>FieldDoc</code> for
      * <code>serialPersistentField</code> member.
      * There should be a <code>serialField</code> tag for
      * each Serializable field defined by an <code>ObjectStreamField</code>
      * array component of <code>serialPersistentField</code>.
      *
      * @returns an array of <code>FieldDoc</code> for the Serializable fields
      * of this class.
      *
      * @see #definesSerializableFields()
      * @see SerialFieldTagImpl
      */
     public FieldDoc[] serializableFields() {
         if (serializedForm == null) {
             serializedForm = new SerializedForm(env, tsym, this);
         }
         //### Clone this?
         return serializedForm.fields();
     }
     /**
      * Return true if Serializable fields are explicitly defined with
      * the special class member <code>serialPersistentFields</code>.
      *
      * @see #serializableFields()
      * @see SerialFieldTagImpl
      */
     public boolean definesSerializableFields() {
         if (!isSerializable() || isExternalizable()) {
             return false;
         } else {
             if (serializedForm == null) {
                 serializedForm = new SerializedForm(env, tsym, this);
             }
             //### Clone this?
             return serializedForm.definesSerializableFields();
         }
     }
     /**
      * Determine if a class is a RuntimeException.
      * <p>
      * Used only by ThrowsTagImpl.
      */
     boolean isRuntimeException() {
         return tsym.isSubClass(env.syms.runtimeExceptionType.tsym, env.types);
     }
     /**
      * Return the source position of the entity, or null if
      * no position is available.
      */
     @Override
     public SourcePosition position() {
         if (tsym.sourcefile == null) return null;
         return SourcePositionImpl.make(tsym.sourcefile,
                                        (tree==null) ? Position.NOPOS : tree.pos,
                                        lineMap);
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java@4a6f853f8721 (annotated)

src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java