jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java

equal deleted inserted replaced

-:43e7e44d63da
+:7f68545b5128
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
-import javax.lang.model.SourceVersion;
 import javax.tools.JavaFileObject;
 import javax.tools.JavaFileManager;
-import javax.tools.JavaFileManager.Location;
-import javax.tools.StandardJavaFileManager;
-import static javax.tools.StandardLocation.*;
 import com.sun.tools.javac.comp.Annotate;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Type.*;
 /** Switch: preserve parameter names from the variable table.
 */
 public boolean saveParameterNames;
 /**
-* Switch: cache completion failures unless -XDdev is used
-*/
-private boolean cacheCompletionFailure;
-/**
-* Switch: prefer source files instead of newer when both source
-* and class are available
-**/
-public boolean preferSource;
-/**
-* Switch: Search classpath and sourcepath for classes before the
-* bootclasspath
-*/
-public boolean userPathsFirst;
-/**
 * The currently selected profile.
 */
 public final Profile profile;
 /** The log to use for verbose output
 Types types;
 /** The name table. */
 final Names names;
-/** Force a completion failure on this name
-*/
-final Name completionFailureName;
 /** Access to files
 */
 private final JavaFileManager fileManager;
 /** Factory for diagnostics
 */
 JCDiagnostic.Factory diagFactory;
-/** Can be reassigned from outside:
-*  the completer to be used for ".java" files. If this remains unassigned
-*  ".java" files will not be loaded.
-*/
-public SourceCompleter sourceCompleter = null;
 /** The current scope where type variables are entered.
 */
 protected Scope typevars;
 /**
 * The set of attribute names for which warnings have been generated for the current class
 */
 Set<Name> warnedAttrs = new HashSet<>();
-/**
-* Completer that delegates to the complete-method of this class.
-*/
-private final Completer thisCompleter = new Completer() {
-@Override
-public void complete(Symbol sym) throws CompletionFailure {
-ClassReader.this.complete(sym);
-}
-};
-public Completer getCompleter() {
-return thisCompleter;
-}
 /** Get the ClassReader instance for this invocation. */
 public static ClassReader instance(Context context) {
 ClassReader instance = context.get(classReaderKey);
 if (instance == null)
 allowVarargs     = source.allowVarargs();
 allowAnnotations = source.allowAnnotations();
 allowSimplifiedVarargs = source.allowSimplifiedVarargs();
 saveParameterNames = options.isSet("save-parameter-names");
-cacheCompletionFailure = options.isUnset("dev");
-preferSource = "source".equals(options.get("-Xprefer"));
-userPathsFirst = options.isSet(XXUSERPATHSFIRST);
 profile = Profile.instance(context);
-completionFailureName =
-options.isSet("failcomplete")
-? names.fromString(options.get("failcomplete"))
-: null;
 typevars = new Scope(syms.noSymbol);
 lintClassfile = Lint.instance(context).isEnabled(LintCategory.CLASSFILE);
 /************************************************************************
 * Error Diagnoses
 ***********************************************************************/
+public ClassFinder.BadClassFile badClassFile(String key, Object... args) {
-public class BadClassFile extends CompletionFailure {
+return new ClassFinder.BadClassFile (
-private static final long serialVersionUID = 0;
-public BadClassFile(TypeSymbol sym, JavaFileObject file, JCDiagnostic diag) {
-super(sym, createBadClassFileDiagnostic(file, diag));
-}
-}
-// where
-private JCDiagnostic createBadClassFileDiagnostic(JavaFileObject file, JCDiagnostic diag) {
-String key = (file.getKind() == JavaFileObject.Kind.SOURCE
-? "bad.source.file.header" : "bad.class.file.header");
-return diagFactory.fragment(key, file, diag);
-}
-public BadClassFile badClassFile(String key, Object... args) {
-return new BadClassFile (
 currentOwner.enclClass(),
 currentClassFile,
-diagFactory.fragment(key, args));
+diagFactory.fragment(key, args),
+diagFactory);
 }
 /************************************************************************
 * Buffer Access
 ***********************************************************************/
 TypeAnnotationPosition readPosition() {
 int tag = nextByte(); // TargetType tag is a byte
 if (!TargetType.isValidTargetTypeValue(tag))
-throw this.badClassFile("bad.type.annotation.value", String.format("0x%02X", tag));
+throw badClassFile("bad.type.annotation.value", String.format("0x%02X", tag));
 TargetType type = TargetType.fromTargetTypeValue(tag);
 switch (type) {
 // instanceof
 }
 }
 }
 }
-/** Read a class file.
+/** Read a class definition from the bytes in buf.
 */
-private void readClassFile(ClassSymbol c) throws IOException {
+private void readClassBuffer(ClassSymbol c) throws IOException {
 int magic = nextInt();
 if (magic != JAVA_MAGIC)
 throw badClassFile("illegal.start.of.class.file");
 minorVersion = nextChar();
 signatureBuffer = new byte[ns];
 }
 readClass(c);
 }
-/************************************************************************
+public void readClassFile(ClassSymbol c) {
-* Adjusting flags
-***********************************************************************/
-long adjustFieldFlags(long flags) {
-return flags;
-}
-long adjustMethodFlags(long flags) {
-if ((flags & ACC_BRIDGE) != 0) {
-flags &= ~ACC_BRIDGE;
-flags |= BRIDGE;
-if (!allowGenerics)
-flags &= ~SYNTHETIC;
-}
-if ((flags & ACC_VARARGS) != 0) {
-flags &= ~ACC_VARARGS;
-flags |= VARARGS;
-}
-return flags;
-}
-long adjustClassFlags(long flags) {
-return flags & ~ACC_SUPER; // SUPER and SYNCHRONIZED bits overloaded
-}
-/************************************************************************
-* Loading Classes
-***********************************************************************/
-/** Completion for classes to be loaded. Before a class is loaded
-*  we make sure its enclosing class (if any) is loaded.
-*/
-private void complete(Symbol sym) throws CompletionFailure {
-if (sym.kind == TYP) {
-ClassSymbol c = (ClassSymbol)sym;
-c.members_field = new Scope.ErrorScope(c); // make sure it's always defined
-annotate.enterStart();
-try {
-completeOwners(c.owner);
-completeEnclosing(c);
-} finally {
-// The flush needs to happen only after annotations
-// are filled in.
-annotate.enterDoneWithoutFlush();
-}
-fillIn(c);
-} else if (sym.kind == PCK) {
-PackageSymbol p = (PackageSymbol)sym;
-try {
-fillIn(p);
-} catch (IOException ex) {
-throw new CompletionFailure(sym, ex.getLocalizedMessage()).initCause(ex);
-}
-}
-if (!filling)
-annotate.flush(); // finish attaching annotations
-}
-/** complete up through the enclosing package. */
-private void completeOwners(Symbol o) {
-if (o.kind != PCK) completeOwners(o.owner);
-o.complete();
-}
-/**
-* Tries to complete lexically enclosing classes if c looks like a
-* nested class.  This is similar to completeOwners but handles
-* the situation when a nested class is accessed directly as it is
-* possible with the Tree API or javax.lang.model.*.
-*/
-private void completeEnclosing(ClassSymbol c) {
-if (c.owner.kind == PCK) {
-Symbol owner = c.owner;
-for (Name name : Convert.enclosingCandidates(Convert.shortName(c.name))) {
-Symbol encl = owner.members().lookup(name).sym;
-if (encl == null)
-encl = syms.classes.get(TypeSymbol.formFlatName(name, owner));
-if (encl != null)
-encl.complete();
-}
-}
-}
-/** We can only read a single class file at a time; this
-*  flag keeps track of when we are currently reading a class
-*  file.
-*/
-private boolean filling = false;
-/** Fill in definition of class `c' from corresponding class or
-*  source file.
-*/
-private void fillIn(ClassSymbol c) {
-if (completionFailureName == c.fullname) {
-throw new CompletionFailure(c, "user-selected completion failure by class name");
-}
 currentOwner = c;
+currentClassFile = c.classfile;
 warnedAttrs.clear();
-JavaFileObject classfile = c.classfile;
+filling = true;
-if (classfile != null) {
+try {
-JavaFileObject previousClassFile = currentClassFile;
+bp = 0;
-try {
+buf = readInputStream(buf, c.classfile.openInputStream());
-if (filling) {
+readClassBuffer(c);
-Assert.error("Filling " + classfile.toUri() + " during " + previousClassFile);
+if (!missingTypeVariables.isEmpty() && !foundTypeVariables.isEmpty()) {
-}
+List<Type> missing = missingTypeVariables;
-currentClassFile = classfile;
+List<Type> found = foundTypeVariables;
-if (verbose) {
+missingTypeVariables = List.nil();
-log.printVerbose("loading", currentClassFile.toString());
+foundTypeVariables = List.nil();
-}
+filling = false;
-if (classfile.getKind() == JavaFileObject.Kind.CLASS) {
+ClassType ct = (ClassType)currentOwner.type;
-filling = true;
+ct.supertype_field =
-try {
+types.subst(ct.supertype_field, missing, found);
-bp = 0;
+ct.interfaces_field =
-buf = readInputStream(buf, classfile.openInputStream());
+types.subst(ct.interfaces_field, missing, found);
-readClassFile(c);
+} else if (missingTypeVariables.isEmpty() !=
-if (!missingTypeVariables.isEmpty() && !foundTypeVariables.isEmpty()) {
+foundTypeVariables.isEmpty()) {
-List<Type> missing = missingTypeVariables;
+Name name = missingTypeVariables.head.tsym.name;
-List<Type> found = foundTypeVariables;
+throw badClassFile("undecl.type.var", name);
-missingTypeVariables = List.nil();
+}
-foundTypeVariables = List.nil();
+} catch (IOException ex) {
-filling = false;
+throw badClassFile("unable.to.access.file", ex.getMessage());
-ClassType ct = (ClassType)currentOwner.type;
+} catch (ArrayIndexOutOfBoundsException ex) {
-ct.supertype_field =
+throw badClassFile("bad.class.file", c.flatname);
-types.subst(ct.supertype_field, missing, found);
+} finally {
-ct.interfaces_field =
+missingTypeVariables = List.nil();
-types.subst(ct.interfaces_field, missing, found);
+foundTypeVariables = List.nil();
-} else if (missingTypeVariables.isEmpty() !=
+filling = false;
-foundTypeVariables.isEmpty()) {
-Name name = missingTypeVariables.head.tsym.name;
-throw badClassFile("undecl.type.var", name);
-}
-} finally {
-missingTypeVariables = List.nil();
-foundTypeVariables = List.nil();
-filling = false;
-}
-} else {
-if (sourceCompleter != null) {
-sourceCompleter.complete(c);
-} else {
-throw new IllegalStateException("Source completer required to read "
-+ classfile.toUri());
-}
-}
-return;
-} catch (IOException ex) {
-throw badClassFile("unable.to.access.file", ex.getMessage());
-} catch (ArrayIndexOutOfBoundsException ex) {
-throw badClassFile("bad.class.file", c.flatname);
-} finally {
-currentClassFile = previousClassFile;
-}
-} else {
-JCDiagnostic diag =
-diagFactory.fragment("class.file.not.found", c.flatname);
-throw
-newCompletionFailure(c, diag);
 }
 }
 // where
 private static byte[] readInputStream(byte[] buf, InputStream s) throws IOException {
 try {
 buf = new byte[Integer.highestOneBit(needed) << 1];
 System.arraycopy(old, 0, buf, 0, old.length);
 }
 return buf;
 }
-/** Static factory for CompletionFailure objects.
-*  In practice, only one can be used at a time, so we share one
+/** We can only read a single class file at a time; this
-*  to reduce the expense of allocating new exception objects.
+*  flag keeps track of when we are currently reading a class
-*/
+*  file.
-private CompletionFailure newCompletionFailure(TypeSymbol c,
+*/
-JCDiagnostic diag) {
+public boolean filling = false;
-if (!cacheCompletionFailure) {
-// log.warning("proc.messager",
-//             Log.getLocalizedString("class.file.not.found", c.flatname));
-// c.debug.printStackTrace();
-return new CompletionFailure(c, diag);
-} else {
-CompletionFailure result = cachedCompletionFailure;
-result.sym = c;
-result.diag = diag;
-return result;
-}
-}
-private CompletionFailure cachedCompletionFailure =
-new CompletionFailure(null, (JCDiagnostic) null);
-{
-cachedCompletionFailure.setStackTrace(new StackTraceElement[0]);
-}
-/** Load a toplevel class with given fully qualified name
-*  The class is entered into `classes' only if load was successful.
-*/
-public ClassSymbol loadClass(Name flatname) throws CompletionFailure {
-boolean absent = syms.classes.get(flatname) == null;
-ClassSymbol c = syms.enterClass(flatname);
-if (c.members_field == null && c.completer != null) {
-try {
-c.complete();
-} catch (CompletionFailure ex) {
-if (absent) syms.classes.remove(flatname);
-throw ex;
-}
-}
-return c;
-}
 /************************************************************************
-* Loading Packages
+* Adjusting flags
 ***********************************************************************/
-/** Include class corresponding to given class file in package,
+long adjustFieldFlags(long flags) {
-*  unless (1) we already have one the same kind (.class or .java), or
+return flags;
-*         (2) we have one of the other kind, and the given class file
+}
-*             is older.
-*/
+long adjustMethodFlags(long flags) {
-protected void includeClassFile(PackageSymbol p, JavaFileObject file) {
+if ((flags & ACC_BRIDGE) != 0) {
-if ((p.flags_field & EXISTS) == 0)
+flags &= ~ACC_BRIDGE;
-for (Symbol q = p; q != null && q.kind == PCK; q = q.owner)
+flags |= BRIDGE;
-q.flags_field |= EXISTS;
+if (!allowGenerics)
-JavaFileObject.Kind kind = file.getKind();
+flags &= ~SYNTHETIC;
-int seen;
+}
-if (kind == JavaFileObject.Kind.CLASS)
+if ((flags & ACC_VARARGS) != 0) {
-seen = CLASS_SEEN;
+flags &= ~ACC_VARARGS;
-else
+flags |= VARARGS;
-seen = SOURCE_SEEN;
+}
-String binaryName = fileManager.inferBinaryName(currentLoc, file);
+return flags;
-int lastDot = binaryName.lastIndexOf(".");
+}
-Name classname = names.fromString(binaryName.substring(lastDot + 1));
-boolean isPkgInfo = classname == names.package_info;
+long adjustClassFlags(long flags) {
-ClassSymbol c = isPkgInfo
+return flags & ~ACC_SUPER; // SUPER and SYNCHRONIZED bits overloaded
-? p.package_info
+}
-: (ClassSymbol) p.members_field.lookup(classname).sym;
-if (c == null) {
-c = syms.enterClass(classname, p);
-if (c.classfile == null) // only update the file if's it's newly created
-c.classfile = file;
-if (isPkgInfo) {
-p.package_info = c;
-} else {
-if (c.owner == p)  // it might be an inner class
-p.members_field.enter(c);
-}
-} else if (!preferCurrent && c.classfile != null && (c.flags_field & seen) == 0) {
-// if c.classfile == null, we are currently compiling this class
-// and no further action is necessary.
-// if (c.flags_field & seen) != 0, we have already encountered
-// a file of the same kind; again no further action is necessary.
-if ((c.flags_field & (CLASS_SEEN | SOURCE_SEEN)) != 0)
-c.classfile = preferredFileObject(file, c.classfile);
-}
-c.flags_field |= seen;
-}
-/** Implement policy to choose to derive information from a source
-*  file or a class file when both are present.  May be overridden
-*  by subclasses.
-*/
-protected JavaFileObject preferredFileObject(JavaFileObject a,
-JavaFileObject b) {
-if (preferSource)
-return (a.getKind() == JavaFileObject.Kind.SOURCE) ? a : b;
-else {
-long adate = a.getLastModified();
-long bdate = b.getLastModified();
-// 6449326: policy for bad lastModifiedTime in ClassReader
-//assert adate >= 0 && bdate >= 0;
-return (adate > bdate) ? a : b;
-}
-}
-/**
-* specifies types of files to be read when filling in a package symbol
-*/
-protected EnumSet<JavaFileObject.Kind> getPackageFileKinds() {
-return EnumSet.of(JavaFileObject.Kind.CLASS, JavaFileObject.Kind.SOURCE);
-}
-/**
-* this is used to support javadoc
-*/
-protected void extraFileActions(PackageSymbol pack, JavaFileObject fe) {
-}
-protected Location currentLoc; // FIXME
-private boolean verbosePath = true;
-// Set to true when the currently selected file should be kept
-private boolean preferCurrent;
-/** Load directory of package into members scope.
-*/
-private void fillIn(PackageSymbol p) throws IOException {
-if (p.members_field == null)
-p.members_field = new Scope(p);
-preferCurrent = false;
-if (userPathsFirst) {
-scanUserPaths(p);
-preferCurrent = true;
-scanPlatformPath(p);
-} else {
-scanPlatformPath(p);
-scanUserPaths(p);
-}
-verbosePath = false;
-}
-/**
-* Scans class path and source path for files in given package.
-*/
-private void scanUserPaths(PackageSymbol p) throws IOException {
-Set<JavaFileObject.Kind> kinds = getPackageFileKinds();
-Set<JavaFileObject.Kind> classKinds = EnumSet.copyOf(kinds);
-classKinds.remove(JavaFileObject.Kind.SOURCE);
-boolean wantClassFiles = !classKinds.isEmpty();
-Set<JavaFileObject.Kind> sourceKinds = EnumSet.copyOf(kinds);
-sourceKinds.remove(JavaFileObject.Kind.CLASS);
-boolean wantSourceFiles = !sourceKinds.isEmpty();
-boolean haveSourcePath = fileManager.hasLocation(SOURCE_PATH);
-if (verbose && verbosePath) {
-if (fileManager instanceof StandardJavaFileManager) {
-StandardJavaFileManager fm = (StandardJavaFileManager)fileManager;
-if (haveSourcePath && wantSourceFiles) {
-List<File> path = List.nil();
-for (File file : fm.getLocation(SOURCE_PATH)) {
-path = path.prepend(file);
-}
-log.printVerbose("sourcepath", path.reverse().toString());
-} else if (wantSourceFiles) {
-List<File> path = List.nil();
-for (File file : fm.getLocation(CLASS_PATH)) {
-path = path.prepend(file);
-}
-log.printVerbose("sourcepath", path.reverse().toString());
-}
-if (wantClassFiles) {
-List<File> path = List.nil();
-for (File file : fm.getLocation(PLATFORM_CLASS_PATH)) {
-path = path.prepend(file);
-}
-for (File file : fm.getLocation(CLASS_PATH)) {
-path = path.prepend(file);
-}
-log.printVerbose("classpath",  path.reverse().toString());
-}
-}
-}
-String packageName = p.fullname.toString();
-if (wantSourceFiles && !haveSourcePath) {
-fillIn(p, CLASS_PATH,
-fileManager.list(CLASS_PATH,
-packageName,
-kinds,
-false));
-} else {
-if (wantClassFiles)
-fillIn(p, CLASS_PATH,
-fileManager.list(CLASS_PATH,
-packageName,
-classKinds,
-false));
-if (wantSourceFiles)
-fillIn(p, SOURCE_PATH,
-fileManager.list(SOURCE_PATH,
-packageName,
-sourceKinds,
-false));
-}
-}
-/**
-* Scans platform class path for files in given package.
-*/
-private void scanPlatformPath(PackageSymbol p) throws IOException {
-fillIn(p, PLATFORM_CLASS_PATH,
-fileManager.list(PLATFORM_CLASS_PATH,
-p.fullname.toString(),
-EnumSet.of(JavaFileObject.Kind.CLASS),
-false));
-}
-// where
-private void fillIn(PackageSymbol p,
-Location location,
-Iterable<JavaFileObject> files)
-{
-currentLoc = location;
-for (JavaFileObject fo : files) {
-switch (fo.getKind()) {
-case CLASS:
-case SOURCE: {
-// TODO pass binaryName to includeClassFile
-String binaryName = fileManager.inferBinaryName(currentLoc, fo);
-String simpleName = binaryName.substring(binaryName.lastIndexOf(".") + 1);
-if (SourceVersion.isIdentifier(simpleName) ||
-simpleName.equals("package-info"))
-includeClassFile(p, fo);
-break;
-}
-default:
-extraFileActions(p, fo);
-}
-}
-}
 /** Output for "-checkclassfile" option.
 *  @param key The key to look up the correct internationalized string.
 *  @param arg An argument for substitution into the output string.
 */
 private void printCCF(String key, Object arg) {
 log.printLines(key, arg);
-}
-public interface SourceCompleter {
-void complete(ClassSymbol sym)
-throws CompletionFailure;
 }
 /**
 * A subclass of JavaFileObject for the sourcefile attribute found in a classfile.
 * The attribute is only the last component of the original filename, so is unlikely

changeset 24604	7f68545b5128
parent 24403	f2ce14657001
child 24606	12c0ca21f8dc