jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Resolve.java

-:7de231613e4a
+:2068190f8ac2
 } catch (CompletionFailure ex) {
 return typeNotFound;
 }
 }
-/** Find qualified member type.
+/**
+* Find a type declared in a scope (not inherited).  Return null
+* if none is found.
 *  @param env       The current environment.
 *  @param site      The original type from where the selection takes
 *                   place.
 *  @param name      The type's name.
 *  @param c         The class to search for the member type. This is
 *                   always a superclass or implemented interface of
 *                   site's class.
 */
-Symbol findMemberType(Env<AttrContext> env,
+Symbol findImmediateMemberType(Env<AttrContext> env,
 Type site,
 Name name,
 TypeSymbol c) {
-Symbol bestSoFar = typeNotFound;
-Symbol sym;
 Scope.Entry e = c.members().lookup(name);
 while (e.scope != null) {
 if (e.sym.kind == TYP) {
 return isAccessible(env, site, e.sym)
 ? e.sym
 : new AccessError(env, site, e.sym);
 }
 e = e.next();
 }
+return typeNotFound;
+}
+/** Find a member type inherited from a superclass or interface.
+*  @param env       The current environment.
+*  @param site      The original type from where the selection takes
+*                   place.
+*  @param name      The type's name.
+*  @param c         The class to search for the member type. This is
+*                   always a superclass or implemented interface of
+*                   site's class.
+*/
+Symbol findInheritedMemberType(Env<AttrContext> env,
+Type site,
+Name name,
+TypeSymbol c) {
+Symbol bestSoFar = typeNotFound;
+Symbol sym;
 Type st = types.supertype(c.type);
 if (st != null && st.hasTag(CLASS)) {
 sym = findMemberType(env, site, name, st.tsym);
 if (sym.kind < bestSoFar.kind) bestSoFar = sym;
 }
 bestSoFar = sym;
 }
 return bestSoFar;
 }
+/** Find qualified member type.
+*  @param env       The current environment.
+*  @param site      The original type from where the selection takes
+*                   place.
+*  @param name      The type's name.
+*  @param c         The class to search for the member type. This is
+*                   always a superclass or implemented interface of
+*                   site's class.
+*/
+Symbol findMemberType(Env<AttrContext> env,
+Type site,
+Name name,
+TypeSymbol c) {
+Symbol sym = findImmediateMemberType(env, site, name, c);
+if (sym != typeNotFound)
+return sym;
+return findInheritedMemberType(env, site, name, c);
+}
 /** Find a global type in given scope and load corresponding class.
 *  @param env       The current environment.
 *  @param scope     The scope in which to look for the type.
 *  @param name      The type's name.
 */
 bestSoFar = sym;
 }
 return bestSoFar;
 }
+Symbol findTypeVar(Env<AttrContext> env, Name name, boolean staticOnly) {
+for (Scope.Entry e = env.info.scope.lookup(name);
+e.scope != null;
+e = e.next()) {
+if (e.sym.kind == TYP) {
+if (staticOnly &&
+e.sym.type.hasTag(TYPEVAR) &&
+e.sym.owner.kind == TYP)
+return new StaticError(e.sym);
+return e.sym;
+}
+}
+return typeNotFound;
+}
 /** Find an unqualified type symbol.
 *  @param env       The current environment.
 *  @param name      The type's name.
 */
 Symbol findType(Env<AttrContext> env, Name name) {
 Symbol bestSoFar = typeNotFound;
 Symbol sym;
 boolean staticOnly = false;
 for (Env<AttrContext> env1 = env; env1.outer != null; env1 = env1.outer) {
 if (isStatic(env1)) staticOnly = true;
-for (Scope.Entry e = env1.info.scope.lookup(name);
+// First, look for a type variable and the first member type
-e.scope != null;
+final Symbol tyvar = findTypeVar(env1, name, staticOnly);
-e = e.next()) {
+sym = findImmediateMemberType(env1, env1.enclClass.sym.type,
-if (e.sym.kind == TYP) {
+name, env1.enclClass.sym);
-if (staticOnly &&
-e.sym.type.hasTag(TYPEVAR) &&
+// Return the type variable if we have it, and have no
-e.sym.owner.kind == TYP) return new StaticError(e.sym);
+// immediate member, OR the type variable is for a method.
-return e.sym;
+if (tyvar != typeNotFound) {
-}
+if (sym == typeNotFound ||
-}
+(tyvar.kind == TYP && tyvar.exists() &&
+tyvar.owner.kind == MTH))
-sym = findMemberType(env1, env1.enclClass.sym.type, name,
+return tyvar;
-env1.enclClass.sym);
+}
+// If the environment is a class def, finish up,
+// otherwise, do the entire findMemberType
+if (sym == typeNotFound)
+sym = findInheritedMemberType(env1, env1.enclClass.sym.type,
+name, env1.enclClass.sym);
 if (staticOnly && sym.kind == TYP &&
 sym.type.hasTag(CLASS) &&
 sym.type.getEnclosingType().hasTag(CLASS) &&
 env1.enclClass.sym.type.isParameterized() &&
 sym.type.getEnclosingType().isParameterized())

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Resolve.java

src/share/classes/com/sun/tools/javac/comp/Resolve.java