tools/java/Environment.java

8  * particular file as subject to the "Classpath" exception as provided
18  * 2 along with this work; if not, write to the Free Software Foundation,
37  * It is used to load classes, resolve class names and
45  * Environments can be nested to change the source object.<p>
49  * they are subject to change or removal without notice.
56      * The actual environment to which everything is forwarded.
83      * Tells whether an Identifier refers to a package which should be
101      * of a call to 'resolveName' or a synthetic class name.
117                 // to do the lookup in this case.  This is part of a fix for bugid
120                 // 'ClassName.N'.  Note that the '.' qualifications get converted to
199      * Resolve a type. Make sure that all the classes referred to by
206      * handling of the non-inner portion of the name to this method.
211      * general to set the error location to the exact position of a component
212      * that is in error, so an error message must refer to the entire qualified
213      * name.  An attempt to keep track of the string length of the components of
214      * the name and to offset the location accordingly fails because the initial
215      * prefix of the name may have been rewritten by an earlier call to
253                 // is going to fail anyway.
287      * Used to check components of qualified names in contexts where a class is expected.
318             // is going to fail anyway.
337      * to 'getClassDefinition(env)' are appropriate now.
381                             // The JLS 6.6.2 restrictions on access to protected members
387                             // resolves the inheritance structure, required to implement the
391                             // of qualified access to inner classes.  Some qualified names are
418      * Adjust class names to reflect scoping.
421      * NOTE: It would be convenient to check for errors here, such as
427      * to the package scope.  (Fix for 4097882)
479         // This logic is pretty exactly parallel to that of
482             // Try to resolve the first identifier component,
488                 // The first identifier component refers to an
522             // last chance to make something halfway sensible
536      * This routine is used after a class name fails to
539      * since import names must be exactly qualified to start with.
570      * Get the imports used to resolve class names.
608      * Returns true if the given method is applicable to the given arguments
640      * Returns true if "from" is a more specific type than "to"
643     public boolean isMoreSpecific(Type from, Type to) throws ClassNotFound {
644         return implicitCast(from, to);
648      * Return true if an implicit cast from this type to
652     public boolean implicitCast(Type from, Type to) throws ClassNotFound {
653         if (from == to)
656         int toTypeCode = to.getTypeCode();
676             return to.inMask(TM_REFERENCE);
679             if (!to.isType(TC_ARRAY)) {
680                 return (to == Type.tObject || to == Type.tCloneable
681                            || to == Type.tSerializable);
686                     to = to.getElementType();
687                 } while (from.isType(TC_ARRAY) && to.isType(TC_ARRAY));
689                       && to.inMask(TM_ARRAY|TM_CLASS)) {
690                     return isMoreSpecific(from, to);
692                     return (from.getTypeCode() == to.getTypeCode());
699                 ClassDefinition toDef = getClassDefinition(to);
710      * Return true if an explicit cast from this type to
713     public boolean explicitCast(Type from, Type to) throws ClassNotFound {
714         if (implicitCast(from, to)) {
718             return to.inMask(TM_NUMBER);
720         if (from.isType(TC_CLASS) && to.isType(TC_CLASS)) {
722             ClassDefinition toClass = getClassDefinition(to);
732             // The code here used to omit this case.  If both types
745         if (to.isType(TC_ARRAY)) {
748                 Type t2 = to.getElementType();
773      * Debugging flags.  There used to be a method debug()
789      * Optimization flags.  There used to be a method optimize()
791      * javac to be replaced with -O and -O:interclass.
829      * Print Dependencies to stdout
871      *  arg1     - an optional argument to the error (null if not applicable)
872      *  arg2     - a second optional argument to the error (null if not applicable)
873      *  arg3     - a third optional argument to the error (null if not applicable)
921      * Return major version to use in generated class files.
929      * Return minor version to use in generated class files.
965      * but we need to give more thought to the issue of classifying debugging
966      * messages and allowing those only those of interest to be enabled.
968      * Calls to these methods are generally conditioned on the final variable
969      * 'Constants.tracing', which allows the calls to be completely omitted
970      * in a production release to avoid space and time overhead.
990      * in InnerClasses attributes, as they are written to the classfile.