ojluni/src/main/java/sun/tools/java/Imports.java - platform/libcore.git - Git at Google

 /*
  * Copyright (c) 1994, 2003, 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 sun.tools.java;

 import java.util.Hashtable;
 import java.util.Vector;
 import java.util.Enumeration;
 import java.util.List;
 import java.util.Collections;
 import java.io.IOException;

 /**
  * This class describes the classes and packages imported
  * from a source file. A Hashtable called bindings is maintained
  * to quickly map symbol names to classes. This table is flushed
  * everytime a new import is added.
  *
  * A class name is resolved as follows:
  *  - if it is a qualified name then return the corresponding class
  *  - if the name corresponds to an individually imported class then return that class
  *  - check if the class is defined in any of the imported packages,
  *    if it is then return it, make sure it is defined in only one package
  *  - assume that the class is defined in the current package
  *
  * WARNING: The contents of this source file are not part of any
  * supported API.  Code that depends on them does so at its own risk:
  * they are subject to change or removal without notice.
  */

 public
 class Imports implements Constants {
     /**
      * The current package, which is implicitly imported,
      * and has precedence over other imported packages.
      */
     Identifier currentPackage = idNull;

     /**
      * A location for the current package declaration.  Used to
      * report errors against the current package.
      */
     long currentPackageWhere = 0;

     /**
      * The imported classes, including memoized imports from packages.
      */
     Hashtable classes = new Hashtable();

     /**
      * The imported package identifiers.  This will not contain duplicate
      * imports for the same package.  It will also not contain the
      * current package.
      */
     Vector packages = new Vector();

     /**
      * The (originally) imported classes.
      * A vector of IdentifierToken.
      */
     Vector singles = new Vector();

     /**
      * Are the import names checked yet?
      */
     protected int checked;

     /**
      * Constructor, always import java.lang.
      */
     public Imports(Environment env) {
         addPackage(idJavaLang);
     }

     /**
      * Check the names of the imports.
      */
     public synchronized void resolve(Environment env) {
         if (checked != 0) {
             return;
         }
         checked = -1;

         // After all class information has been read, now we can
         // safely inspect import information for errors.
         // If we did this before all parsing was finished,
         // we could get vicious circularities, since files can
         // import each others' classes.

         // A note: the resolution of the package java.lang takes place
         // in the sun.tools.javac.BatchEnvironment#setExemptPackages().

         // Make sure that the current package's name does not collide
         // with the name of an existing class. (bug 4101529)
         //
         // This change has been backed out because, on WIN32, it
         // failed to distinguish between java.awt.event and
         // java.awt.Event when looking for a directory.  We will
         // add this back in later.
         //
         // if (currentPackage != idNull) {
         //    Identifier resolvedName =
         //      env.resolvePackageQualifiedName(currentPackage);
         //
         //   Identifier className = resolvedName.getTopName();
         //
         //   if (importable(className, env)) {
         //      // The name of the current package is also the name
         //      // of a class.
         //      env.error(currentPackageWhere, "package.class.conflict",
         //                currentPackage, className);
         //     }
         // }

         Vector resolvedPackages = new Vector();
         for (Enumeration e = packages.elements() ; e.hasMoreElements() ;) {
             IdentifierToken t = (IdentifierToken)e.nextElement();
             Identifier nm = t.getName();
             long where = t.getWhere();

             // Check to see if this package is exempt from the "exists"
             // check.  See the note in
             // sun.tools.javac.BatchEnvironment#setExemptPackages()
             // for more information.
             if (env.isExemptPackage(nm)) {
                 resolvedPackages.addElement(t);
                 continue;
             }

             // (Note: This code is moved from BatchParser.importPackage().)
             try {
                 Identifier rnm = env.resolvePackageQualifiedName(nm);
                 if (importable(rnm, env)) {
                     // This name is a real class; better not be a package too.
                     if (env.getPackage(rnm.getTopName()).exists()) {
                         env.error(where, "class.and.package",
                                   rnm.getTopName());
                     }
                     // Pass an "inner" name to the imports.
                     if (!rnm.isInner())
                         rnm = Identifier.lookupInner(rnm, idNull);
                     nm = rnm;
                 } else if (!env.getPackage(nm).exists()) {
                     env.error(where, "package.not.found", nm, "import");
                 } else if (rnm.isInner()) {
                     // nm exists, and rnm.getTopName() is a parent package
                     env.error(where, "class.and.package", rnm.getTopName());
                 }
                 resolvedPackages.addElement(new IdentifierToken(where, nm));
             } catch (IOException ee) {
                 env.error(where, "io.exception", "import");
             }
         }
         packages = resolvedPackages;

         for (Enumeration e = singles.elements() ; e.hasMoreElements() ;) {
             IdentifierToken t = (IdentifierToken)e.nextElement();
             Identifier nm = t.getName();
             long where = t.getWhere();
             Identifier pkg = nm.getQualifier();

             // (Note: This code is moved from BatchParser.importClass().)
             nm = env.resolvePackageQualifiedName(nm);
             if (!env.classExists(nm.getTopName())) {
                 env.error(where, "class.not.found", nm, "import");
             }

             // (Note: This code is moved from Imports.addClass().)
             Identifier snm = nm.getFlatName().getName();

             // make sure it isn't already imported explicitly
             Identifier className = (Identifier)classes.get(snm);
             if (className != null) {
                 Identifier f1 = Identifier.lookup(className.getQualifier(),
                                                   className.getFlatName());
                 Identifier f2 = Identifier.lookup(nm.getQualifier(),
                                                   nm.getFlatName());
                 if (!f1.equals(f2)) {
                     env.error(where, "ambig.class", nm, className);
                 }
             }
             classes.put(snm, nm);


             // The code here needs to check to see, if we
             // are importing an inner class, that all of its
             // enclosing classes are visible to us.  To check this,
             // we need to construct a definition for the class.
             // The code here used to call...
             //
             //     ClassDefinition def = env.getClassDefinition(nm);
             //
             // ...but that interfered with the basicCheck()'ing of
             // interfaces in certain cases (bug no. 4086139).  Never
             // fear.  Instead we load the class with a call to the
             // new getClassDefinitionNoCheck() which does no basicCheck() and
             // lets us answer the questions we are interested in w/o
             // interfering with the demand-driven nature of basicCheck().

             try {
                 // Get a declaration
                 ClassDeclaration decl = env.getClassDeclaration(nm);

                 // Get the definition (no env argument)
                 ClassDefinition def = decl.getClassDefinitionNoCheck(env);

                 // Get the true name of the package containing this class.
                 // `pkg' from above is insufficient.  It includes the
                 // names of our enclosing classes.  Fix for 4086815.
                 Identifier importedPackage = def.getName().getQualifier();

                 // Walk out the outerClass chain, ensuring that each level
                 // is visible from our perspective.
                 for (; def != null; def = def.getOuterClass()) {
                     if (def.isPrivate()
                         || !(def.isPublic()
                              || importedPackage.equals(currentPackage))) {
                         env.error(where, "cant.access.class", def);
                         break;
                     }
                 }
             } catch (AmbiguousClass ee) {
                 env.error(where, "ambig.class", ee.name1, ee.name2);
             } catch (ClassNotFound ee) {
                 env.error(where, "class.not.found", ee.name, "import");
             }
         }
         checked = 1;
     }

     /**
      * Lookup a class, given the current set of imports,
      * AmbiguousClass exception is thrown if the name can be
      * resolved in more than one way. A ClassNotFound exception
      * is thrown if the class is not found in the imported classes
      * and packages.
      */
     public synchronized Identifier resolve(Environment env, Identifier nm) throws ClassNotFound {
         if (tracing) env.dtEnter("Imports.resolve: " + nm);

         // If the class has the special ambiguous prefix, then we will
         // get the original AmbiguousClass exception by removing the
         // prefix and proceeding in the normal fashion.
         // (part of solution for 4059855)
         if (nm.hasAmbigPrefix()) {
             nm = nm.removeAmbigPrefix();
         }

         if (nm.isQualified()) {
             // Don't bother it is already qualified
             if (tracing) env.dtExit("Imports.resolve: QUALIFIED " + nm);
             return nm;
         }

         if (checked <= 0) {
             checked = 0;
             resolve(env);
         }

         // Check if it was imported before
         Identifier className = (Identifier)classes.get(nm);
         if (className != null) {
             if (tracing) env.dtExit("Imports.resolve: PREVIOUSLY IMPORTED " + nm);
             return className;
         }

         // Note: the section below has changed a bit during the fix
         // for bug 4093217.  The current package is no longer grouped
         // with the rest of the import-on-demands; it is now checked
         // separately.  Also, the list of import-on-demands is now
         // guarranteed to be duplicate-free, so the code below can afford
         // to be a bit simpler.

         // First we look in the current package.  The current package
         // is given precedence over the rest of the import-on-demands,
         // which means, among other things, that a class in the current
         // package cannot be ambiguous.
         Identifier id = Identifier.lookup(currentPackage, nm);
         if (importable(id, env)) {
             className = id;
         } else {
             // If it isn't in the current package, try to find it in
             // our import-on-demands.
             Enumeration e = packages.elements();
             while (e.hasMoreElements()) {
                 IdentifierToken t = (IdentifierToken)e.nextElement();
                 id = Identifier.lookup(t.getName(), nm);

                 if (importable(id, env)) {
                     if (className == null) {
                         // We haven't found any other matching classes yet.
                         // Set className to what we've found and continue
                         // looking for an ambiguity.
                         className = id;
                     } else {
                         if (tracing)
                             env.dtExit("Imports.resolve: AMBIGUOUS " + nm);

                         // We've found an ambiguity.
                         throw new AmbiguousClass(className, id);
                     }
                 }
             }
         }

         // Make sure a class was found
         if (className == null) {
             if (tracing) env.dtExit("Imports.resolve: NOT FOUND " + nm);
             throw new ClassNotFound(nm);
         }

         // Remember the binding
         classes.put(nm, className);
         if (tracing) env.dtExit("Imports.resolve: FIRST IMPORT " + nm);
         return className;
     }

     /**
      * Check to see if 'id' names an importable class in `env'.
      * This method was made public and static for utility.
      */
     static public boolean importable(Identifier id, Environment env) {
         if (!id.isInner()) {
             return env.classExists(id);
         } else if (!env.classExists(id.getTopName())) {
             return false;
         } else {
             // load the top class and look inside it
             try {
                 // There used to be a call to...
                 //    env.getClassDeclaration(id.getTopName());
                 // ...here.  It has been replaced with the
                 // two statements below.  These should be functionally
                 // the same except for the fact that
                 // getClassDefinitionNoCheck() does not call
                 // basicCheck().  This allows us to avoid a circular
                 // need to do basicChecking that can arise with
                 // certain patterns of importing and inheritance.
                 // This is a fix for a variant of bug 4086139.
                 //
                 // Note: the special case code in env.getClassDefinition()
                 // which handles inner class names is not replicated below.
                 // This should be okay, as we are looking up id.getTopName(),
                 // not id.
                 ClassDeclaration decl =
                     env.getClassDeclaration(id.getTopName());
                 ClassDefinition c =
                     decl.getClassDefinitionNoCheck(env);

                 return c.innerClassExists(id.getFlatName().getTail());
             } catch (ClassNotFound ee) {
                 return false;
             }
         }
     }

     /**
      * Suppose a resolve() call has failed.
      * This routine can be used silently to give a reasonable
      * default qualification (the current package) to the identifier.
      * This decision is recorded for future reference.
      */
     public synchronized Identifier forceResolve(Environment env, Identifier nm) {
         if (nm.isQualified())
             return nm;

         Identifier className = (Identifier)classes.get(nm);
         if (className != null) {
             return className;
         }

         className = Identifier.lookup(currentPackage, nm);

         classes.put(nm, className);
         return className;
     }

     /**
      * Add a class import
      */
     public synchronized void addClass(IdentifierToken t) {
         singles.addElement(t);
     }
     // for compatibility
     public void addClass(Identifier nm) throws AmbiguousClass {
         addClass(new IdentifierToken(nm));
     }

     /**
      * Add a package import, or perhaps an inner class scope.
      * Ignore any duplicate imports.
      */
     public synchronized void addPackage(IdentifierToken t) {
         final Identifier name = t.getName();

         // If this is a duplicate import for the current package,
         // ignore it.
         if (name == currentPackage) {
             return;
         }

         // If this is a duplicate of a package which has already been
         // added to the list, ignore it.
         final int size = packages.size();
         for (int i = 0; i < size; i++) {
             if (name == ((IdentifierToken)packages.elementAt(i)).getName()) {
                 return;
             }
         }

         // Add the package to the list.
         packages.addElement(t);
     }
     // for compatibility
     public void addPackage(Identifier id) {
         addPackage(new IdentifierToken(id));
     }

     /**
      * Specify the current package with an IdentifierToken.
      */
     public synchronized void setCurrentPackage(IdentifierToken t) {
         currentPackage = t.getName();
         currentPackageWhere = t.getWhere();
     }

     /**
      * Specify the current package
      */
     public synchronized void setCurrentPackage(Identifier id) {
         currentPackage = id;
     }

     /**
      * Report the current package
      */
     public Identifier getCurrentPackage() {
         return currentPackage;
     }

     /**
      * Return an unmodifiable list of IdentifierToken representing
      * packages specified as imports.
      */
     public List getImportedPackages() {
         return Collections.unmodifiableList(packages);
     }

     /**
      * Return an unmodifiable list of IdentifierToken representing
      * classes specified as imports.
      */
     public List getImportedClasses() {
         return Collections.unmodifiableList(singles);
     }

     /**
      * Extend an environment with my resolve() method.
      */
     public Environment newEnvironment(Environment env) {
         return new ImportEnvironment(env, this);
     }
 }

 final
 class ImportEnvironment extends Environment {
     Imports imports;

     ImportEnvironment(Environment env, Imports imports) {
         super(env, env.getSource());
         this.imports = imports;
     }

     public Identifier resolve(Identifier nm) throws ClassNotFound {
         return imports.resolve(this, nm);
     }

     public Imports getImports() {
         return imports;
     }
 }
	/*
	* Copyright (c) 1994, 2003, 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 sun.tools.java;

	import java.util.Hashtable;
	import java.util.Vector;
	import java.util.Enumeration;
	import java.util.List;
	import java.util.Collections;
	import java.io.IOException;

	/**
	* This class describes the classes and packages imported
	* from a source file. A Hashtable called bindings is maintained
	* to quickly map symbol names to classes. This table is flushed
	* everytime a new import is added.
	*
	* A class name is resolved as follows:
	* - if it is a qualified name then return the corresponding class
	* - if the name corresponds to an individually imported class then return that class
	* - check if the class is defined in any of the imported packages,
	* if it is then return it, make sure it is defined in only one package
	* - assume that the class is defined in the current package
	*
	* WARNING: The contents of this source file are not part of any
	* supported API. Code that depends on them does so at its own risk:
	* they are subject to change or removal without notice.
	*/

	public
	class Imports implements Constants {
	/**
	* The current package, which is implicitly imported,
	* and has precedence over other imported packages.
	*/
	Identifier currentPackage = idNull;

	/**
	* A location for the current package declaration. Used to
	* report errors against the current package.
	*/
	long currentPackageWhere = 0;

	/**
	* The imported classes, including memoized imports from packages.
	*/
	Hashtable classes = new Hashtable();

	/**
	* The imported package identifiers. This will not contain duplicate
	* imports for the same package. It will also not contain the
	* current package.
	*/
	Vector packages = new Vector();

	/**
	* The (originally) imported classes.
	* A vector of IdentifierToken.
	*/
	Vector singles = new Vector();

	/**
	* Are the import names checked yet?
	*/
	protected int checked;

	/**
	* Constructor, always import java.lang.
	*/
	public Imports(Environment env) {
	addPackage(idJavaLang);
	}

	/**
	* Check the names of the imports.
	*/
	public synchronized void resolve(Environment env) {
	if (checked != 0) {
	return;
	}
	checked = -1;

	// After all class information has been read, now we can
	// safely inspect import information for errors.
	// If we did this before all parsing was finished,
	// we could get vicious circularities, since files can
	// import each others' classes.

	// A note: the resolution of the package java.lang takes place
	// in the sun.tools.javac.BatchEnvironment#setExemptPackages().

	// Make sure that the current package's name does not collide
	// with the name of an existing class. (bug 4101529)
	//
	// This change has been backed out because, on WIN32, it
	// failed to distinguish between java.awt.event and
	// java.awt.Event when looking for a directory. We will
	// add this back in later.
	//
	// if (currentPackage != idNull) {
	// Identifier resolvedName =
	// env.resolvePackageQualifiedName(currentPackage);
	//
	// Identifier className = resolvedName.getTopName();
	//
	// if (importable(className, env)) {
	// // The name of the current package is also the name
	// // of a class.
	// env.error(currentPackageWhere, "package.class.conflict",
	// currentPackage, className);
	// }
	// }

	Vector resolvedPackages = new Vector();
	for (Enumeration e = packages.elements() ; e.hasMoreElements() ;) {
	IdentifierToken t = (IdentifierToken)e.nextElement();
	Identifier nm = t.getName();
	long where = t.getWhere();

	// Check to see if this package is exempt from the "exists"
	// check. See the note in
	// sun.tools.javac.BatchEnvironment#setExemptPackages()
	// for more information.
	if (env.isExemptPackage(nm)) {
	resolvedPackages.addElement(t);
	continue;
	}

	// (Note: This code is moved from BatchParser.importPackage().)
	try {
	Identifier rnm = env.resolvePackageQualifiedName(nm);
	if (importable(rnm, env)) {
	// This name is a real class; better not be a package too.
	if (env.getPackage(rnm.getTopName()).exists()) {
	env.error(where, "class.and.package",
	rnm.getTopName());
	}
	// Pass an "inner" name to the imports.
	if (!rnm.isInner())
	rnm = Identifier.lookupInner(rnm, idNull);
	nm = rnm;
	} else if (!env.getPackage(nm).exists()) {
	env.error(where, "package.not.found", nm, "import");
	} else if (rnm.isInner()) {
	// nm exists, and rnm.getTopName() is a parent package
	env.error(where, "class.and.package", rnm.getTopName());
	}
	resolvedPackages.addElement(new IdentifierToken(where, nm));
	} catch (IOException ee) {
	env.error(where, "io.exception", "import");
	}
	}
	packages = resolvedPackages;

	for (Enumeration e = singles.elements() ; e.hasMoreElements() ;) {
	IdentifierToken t = (IdentifierToken)e.nextElement();
	Identifier nm = t.getName();
	long where = t.getWhere();
	Identifier pkg = nm.getQualifier();

	// (Note: This code is moved from BatchParser.importClass().)
	nm = env.resolvePackageQualifiedName(nm);
	if (!env.classExists(nm.getTopName())) {
	env.error(where, "class.not.found", nm, "import");
	}

	// (Note: This code is moved from Imports.addClass().)
	Identifier snm = nm.getFlatName().getName();

	// make sure it isn't already imported explicitly
	Identifier className = (Identifier)classes.get(snm);
	if (className != null) {
	Identifier f1 = Identifier.lookup(className.getQualifier(),
	className.getFlatName());
	Identifier f2 = Identifier.lookup(nm.getQualifier(),
	nm.getFlatName());
	if (!f1.equals(f2)) {
	env.error(where, "ambig.class", nm, className);
	}
	}
	classes.put(snm, nm);


	// The code here needs to check to see, if we
	// are importing an inner class, that all of its
	// enclosing classes are visible to us. To check this,
	// we need to construct a definition for the class.
	// The code here used to call...
	//
	// ClassDefinition def = env.getClassDefinition(nm);
	//
	// ...but that interfered with the basicCheck()'ing of
	// interfaces in certain cases (bug no. 4086139). Never
	// fear. Instead we load the class with a call to the
	// new getClassDefinitionNoCheck() which does no basicCheck() and
	// lets us answer the questions we are interested in w/o
	// interfering with the demand-driven nature of basicCheck().

	try {
	// Get a declaration
	ClassDeclaration decl = env.getClassDeclaration(nm);

	// Get the definition (no env argument)
	ClassDefinition def = decl.getClassDefinitionNoCheck(env);

	// Get the true name of the package containing this class.
	// `pkg' from above is insufficient. It includes the
	// names of our enclosing classes. Fix for 4086815.
	Identifier importedPackage = def.getName().getQualifier();

	// Walk out the outerClass chain, ensuring that each level
	// is visible from our perspective.
	for (; def != null; def = def.getOuterClass()) {
	if (def.isPrivate()
	\|\| !(def.isPublic()
	\|\| importedPackage.equals(currentPackage))) {
	env.error(where, "cant.access.class", def);
	break;
	}
	}
	} catch (AmbiguousClass ee) {
	env.error(where, "ambig.class", ee.name1, ee.name2);
	} catch (ClassNotFound ee) {
	env.error(where, "class.not.found", ee.name, "import");
	}
	}
	checked = 1;
	}

	/**
	* Lookup a class, given the current set of imports,
	* AmbiguousClass exception is thrown if the name can be
	* resolved in more than one way. A ClassNotFound exception
	* is thrown if the class is not found in the imported classes
	* and packages.
	*/
	public synchronized Identifier resolve(Environment env, Identifier nm) throws ClassNotFound {
	if (tracing) env.dtEnter("Imports.resolve: " + nm);

	// If the class has the special ambiguous prefix, then we will
	// get the original AmbiguousClass exception by removing the
	// prefix and proceeding in the normal fashion.
	// (part of solution for 4059855)
	if (nm.hasAmbigPrefix()) {
	nm = nm.removeAmbigPrefix();
	}

	if (nm.isQualified()) {
	// Don't bother it is already qualified
	if (tracing) env.dtExit("Imports.resolve: QUALIFIED " + nm);
	return nm;
	}

	if (checked <= 0) {
	checked = 0;
	resolve(env);
	}

	// Check if it was imported before
	Identifier className = (Identifier)classes.get(nm);
	if (className != null) {
	if (tracing) env.dtExit("Imports.resolve: PREVIOUSLY IMPORTED " + nm);
	return className;
	}

	// Note: the section below has changed a bit during the fix
	// for bug 4093217. The current package is no longer grouped
	// with the rest of the import-on-demands; it is now checked
	// separately. Also, the list of import-on-demands is now
	// guarranteed to be duplicate-free, so the code below can afford
	// to be a bit simpler.

	// First we look in the current package. The current package
	// is given precedence over the rest of the import-on-demands,
	// which means, among other things, that a class in the current
	// package cannot be ambiguous.
	Identifier id = Identifier.lookup(currentPackage, nm);
	if (importable(id, env)) {
	className = id;
	} else {
	// If it isn't in the current package, try to find it in
	// our import-on-demands.
	Enumeration e = packages.elements();
	while (e.hasMoreElements()) {
	IdentifierToken t = (IdentifierToken)e.nextElement();
	id = Identifier.lookup(t.getName(), nm);

	if (importable(id, env)) {
	if (className == null) {
	// We haven't found any other matching classes yet.
	// Set className to what we've found and continue
	// looking for an ambiguity.
	className = id;
	} else {
	if (tracing)
	env.dtExit("Imports.resolve: AMBIGUOUS " + nm);

	// We've found an ambiguity.
	throw new AmbiguousClass(className, id);
	}
	}
	}
	}

	// Make sure a class was found
	if (className == null) {
	if (tracing) env.dtExit("Imports.resolve: NOT FOUND " + nm);
	throw new ClassNotFound(nm);
	}

	// Remember the binding
	classes.put(nm, className);
	if (tracing) env.dtExit("Imports.resolve: FIRST IMPORT " + nm);
	return className;
	}

	/**
	* Check to see if 'id' names an importable class in `env'.
	* This method was made public and static for utility.
	*/
	static public boolean importable(Identifier id, Environment env) {
	if (!id.isInner()) {
	return env.classExists(id);
	} else if (!env.classExists(id.getTopName())) {
	return false;
	} else {
	// load the top class and look inside it
	try {
	// There used to be a call to...
	// env.getClassDeclaration(id.getTopName());
	// ...here. It has been replaced with the
	// two statements below. These should be functionally
	// the same except for the fact that
	// getClassDefinitionNoCheck() does not call
	// basicCheck(). This allows us to avoid a circular
	// need to do basicChecking that can arise with
	// certain patterns of importing and inheritance.
	// This is a fix for a variant of bug 4086139.
	//
	// Note: the special case code in env.getClassDefinition()
	// which handles inner class names is not replicated below.
	// This should be okay, as we are looking up id.getTopName(),
	// not id.
	ClassDeclaration decl =
	env.getClassDeclaration(id.getTopName());
	ClassDefinition c =
	decl.getClassDefinitionNoCheck(env);

	return c.innerClassExists(id.getFlatName().getTail());
	} catch (ClassNotFound ee) {
	return false;
	}
	}
	}

	/**
	* Suppose a resolve() call has failed.
	* This routine can be used silently to give a reasonable
	* default qualification (the current package) to the identifier.
	* This decision is recorded for future reference.
	*/
	public synchronized Identifier forceResolve(Environment env, Identifier nm) {
	if (nm.isQualified())
	return nm;

	Identifier className = (Identifier)classes.get(nm);
	if (className != null) {
	return className;
	}

	className = Identifier.lookup(currentPackage, nm);

	classes.put(nm, className);
	return className;
	}

	/**
	* Add a class import
	*/
	public synchronized void addClass(IdentifierToken t) {
	singles.addElement(t);
	}
	// for compatibility
	public void addClass(Identifier nm) throws AmbiguousClass {
	addClass(new IdentifierToken(nm));
	}

	/**
	* Add a package import, or perhaps an inner class scope.
	* Ignore any duplicate imports.
	*/
	public synchronized void addPackage(IdentifierToken t) {
	final Identifier name = t.getName();

	// If this is a duplicate import for the current package,
	// ignore it.
	if (name == currentPackage) {
	return;
	}

	// If this is a duplicate of a package which has already been
	// added to the list, ignore it.
	final int size = packages.size();
	for (int i = 0; i < size; i++) {
	if (name == ((IdentifierToken)packages.elementAt(i)).getName()) {
	return;
	}
	}

	// Add the package to the list.
	packages.addElement(t);
	}
	// for compatibility
	public void addPackage(Identifier id) {
	addPackage(new IdentifierToken(id));
	}

	/**
	* Specify the current package with an IdentifierToken.
	*/
	public synchronized void setCurrentPackage(IdentifierToken t) {
	currentPackage = t.getName();
	currentPackageWhere = t.getWhere();
	}

	/**
	* Specify the current package
	*/
	public synchronized void setCurrentPackage(Identifier id) {
	currentPackage = id;
	}

	/**
	* Report the current package
	*/
	public Identifier getCurrentPackage() {
	return currentPackage;
	}

	/**
	* Return an unmodifiable list of IdentifierToken representing
	* packages specified as imports.
	*/
	public List getImportedPackages() {
	return Collections.unmodifiableList(packages);
	}

	/**
	* Return an unmodifiable list of IdentifierToken representing
	* classes specified as imports.
	*/
	public List getImportedClasses() {
	return Collections.unmodifiableList(singles);
	}

	/**
	* Extend an environment with my resolve() method.
	*/
	public Environment newEnvironment(Environment env) {
	return new ImportEnvironment(env, this);
	}
	}

	final
	class ImportEnvironment extends Environment {
	Imports imports;

	ImportEnvironment(Environment env, Imports imports) {
	super(env, env.getSource());
	this.imports = imports;
	}

	public Identifier resolve(Identifier nm) throws ClassNotFound {
	return imports.resolve(this, nm);
	}

	public Imports getImports() {
	return imports;
	}
	}