Changes in / [20:30]

Location:

/trunk/gj/src/gjc/v6

Files:

• code/CJByteCodes.java (added)
• code/CJClassReader.java (added)
• code/CJClassWriter.java (added)
• code/CompleteClassReader.java (modified) (1 diff)
• code/Scope.java (modified) (1 diff)
• code/Symbol.java (modified) (6 diffs)
• code/Type.java (modified) (23 diffs)
• comp/Attr.java (modified) (16 diffs)
• comp/AttrContext.java (added)
• comp/Check.java (modified) (9 diffs)
• comp/ConstFold.java (added)
• comp/Enter.java (added)
• comp/Env.java (added)
• comp/Flow.java (added)
• comp/Gen.java (added)
• comp/Infer.java (added)
• comp/Items.java (added)

/trunk/gj/src/gjc/v6/code/CompleteClassReader.java

@@ -25 +25 @@
 
     public CompleteClassReader(Hashtable<String,String> options) {
-        super(options,
-            // JavaParty:
-            false
-        );
+        super(options);
     }
 

/trunk/gj/src/gjc/v6/code/Scope.java

@@ -60 +60 @@
      *  given table. table's length must be an exponent of 2.
      */
-    private Scope(Scope next, Symbol owner, Entry[] table) {
+    Scope(Scope next, Symbol owner, Entry[] table) {
         this.next = next;
         this.owner = owner;

/trunk/gj/src/gjc/v6/code/Symbol.java

@@ -121 +121 @@
     public Type externalType() {
         Type t = erasure();
-        if (name == Names.init && owner.isNested()) {
+        if (name == Names.init && owner.hasOuterInstance()) {
             Type this0type = owner.type.outer().erasure();
             return new MethodType(
@@ -176 +176 @@
      */
     public boolean isNested() {
-        return type.outer().tag == CLASS && (flags() & INTERFACE) == 0;
+        return (flags_field & INTERFACE) == 0 && type.outer().tag == CLASS;
+    }
+
+    /** An inner class has an outer instance it is nested and NOTHIS0 is not set
+     */
+    public boolean hasOuterInstance() {
+        return isNested() && (flags() & NOTHIS0) == 0;
     }
 
@@ -216 +222 @@
     }
 
+    public Scope members() {
+        return null;
+    }
+
     /** A class for type symbols. Type variables are represented by instances
      *  of this class, classes and packages by instances of subclasses.
@@ -227 +237 @@
         public String toString() {
             return "type variable " + name;
-        }
-
-        public Scope members() {
-            return null;
         }
 
@@ -418 +424 @@
                 return true;
             } else if ((base.flags() & INTERFACE) != 0) {
-                for (List<Type> is = type.interfaces();
-                     is.nonEmpty();
-                     is = is.tail)
-                    if (is.head.tsym.subclass(base)) return true;
-                return false;
+                for (Type t = type; t.tag == CLASS; t = t.supertype())
+                    for (List<Type> is = t.interfaces();
+                         is.nonEmpty();
+                         is = is.tail)
+                        if (is.head.tsym.subclass(base)) return true;
             } else {
-                Type t = type.supertype();
-                while (t.tag == CLASS && t.tsym != base) t = t.supertype();
-                return t.tag == CLASS;
+                for (Type t = type; t.tag == CLASS; t = t.supertype())
+                    if (t.tsym == base) return true;
             }
+            return false;
         }
 
@@ -587 +593 @@
                      e.scope != null;
                      e = e.next()) {
-                    if (overrides(e.sym, origin))
-//                      && e.sym.flags() & SYNTHETIC) == 0)
-                        return (MethodSymbol)e.sym;
+                    if (e.sym.kind == MTH) {
+                        MethodSymbol m = (MethodSymbol) e.sym;
+                        if (m.overrides(this, origin) &&
+                            (m.flags() & SYNTHETIC) == 0) return m;
+                    }
                 }
             }

/trunk/gj/src/gjc/v6/code/Type.java

@@ -54 +54 @@
         return t;
     }
+
+    /** If this is a constant type, return its underlying type.
+     *  Otherwise, return the type itself.
+     */
+    public Type baseType() {
+        if (constValue == null) return this;
+        else return tsym.type;
+    }
          
+    /** Return the base types of a list of types.
+     */
+    public static List<Type> baseTypes(List<Type> types) {
+        if (types.nonEmpty()) {
+            Type t = types.head.baseType();
+            List<Type> ts = baseTypes(types.tail);
+            if (t != types.head || ts != types.tail)
+                return new List<Type>(t, ts);
+        }
+        return types;
+    }
+
    /** convert to string
      */
@@ -320 +340 @@
             return this.bound().castableTo(that);
         case ALL:
-            return true;
+            return this.subType(that);
         default:
             throw new InternalError();
         }
+    }
+
+    /** Return the member class of this type with given name, 
+     *  or null if none exists.
+     */
+    public TypeSymbol memberClass(Name name) { 
+        return null;
     }
 
@@ -395 +422 @@
     public static final Type errType = new ErrorType(null);
 
-    static void initType(Type type, String name) {
-        ClassSymbol c = new ClassSymbol(
-            PUBLIC, Name.fromString(name), type, Symbol.emptyPackage);
+    static void initType(Type type, ClassSymbol c) {
         type.tsym = c;
         typeOfTag[type.tag] = type;
+    }
+
+    static void initType(Type type, String name) {
+        initType(
+            type, 
+            new ClassSymbol(
+                PUBLIC, Name.fromString(name), type, Symbol.emptyPackage));
     }
 
@@ -417 +449 @@
         initType(booleanType, "boolean", "Boolean");
         initType(voidType, "void", "Void");
-        initType(allType, "<null>");
-        errType.tsym = Symbol.errSymbol;
+        initType(allType, "*");
+        initType(errType, Symbol.errSymbol);
     }
 
@@ -435 +467 @@
         public List<Type> typarams_field;
 
+        /** A cache variable for the type parameters of this type,
+         *  appended to all parameters of its enclosing class.
+         */
+        public List<Type> allparams_field;
+
         /** The supertype of this class (to be set once class is loaded)
          */
@@ -447 +484 @@
             this.outer_field = outer;
             this.typarams_field = typarams;
+            this.allparams_field = null;
             this.supertype_field = null;
             this.interfaces_field = null;
@@ -457 +495 @@
         }
 
+        public Type baseType() {
+            if (constValue == null) return this;
+            else return tsym.type;
+        }
+
         public String toString() {
             StringBuffer buf = new StringBuffer();
-            if (outer().tag == CLASS) {
+            if (outer().tag != NONE) {
                 buf.append(outer().toString());
                 buf.append(".");
@@ -513 +556 @@
                 } else if (this == tsym.type) {
                     supertype_field = st;
-                } else if (typarams_field.isEmpty()) {
-                    // in this case, `this' is an erasure of a parameterized type
-                    supertype_field = st.erasure();
                 } else {
-                    supertype_field =
-                        st.subst(tsym.type.typarams(), typarams_field);
+                    List<Type> ownparams = allParams();
+                    List<Type> symparams = tsym.type.allParams();
+                    if (ownparams.isEmpty()) supertype_field = st.erasure();
+                    else supertype_field = st.subst(symparams, ownparams);
                 }
             }
@@ -532 +574 @@
                 } else if (this == tsym.type) {
                     interfaces_field = is;
-                } else if (typarams_field.isEmpty()) {
-                    // in this case, `this' is an erasure of a parameterized type
-                    interfaces_field = erasure(is);
                 } else {
-                    interfaces_field =
-                        subst(is, tsym.type.typarams(), typarams_field);
+                    List<Type> ownparams = allParams();
+                    List<Type> symparams = tsym.type.allParams();
+                    if (ownparams.isEmpty()) interfaces_field = erasure(is);
+                    else interfaces_field = subst(is, symparams, ownparams);
                 }
             }
@@ -544 +585 @@
 
         public List<Type> allParams() {
-            return typarams().prepend(outer().typarams());
+            if (allparams_field == null) {
+                allparams_field = typarams().prepend(outer().allParams());
+            }
+            return allparams_field;
         }
 
@@ -567 +611 @@
 
         public Type asOuterSuper(Symbol sym) {
-            Type s = this.asSuper(sym);
-            Type t = this.outer();
-            while (s == null && t.tag == CLASS) {
-                s = t.asSuper(sym);
+            Type t = this;
+            do {
+                Type s = t.asSuper(sym);
+                if (s != null) return s;
                 t = t.outer();
-            }
-            return s;
+            } while (t.tag == CLASS);
+            return null;
         }
 
@@ -592 +636 @@
 
         public Type memberType(Symbol sym) {
+//          System.out.print(this + ".memberType " + sym + " = ");//DEBUG
             Symbol owner = sym.owner;
-            if ((sym.flags() & STATIC) == 0 && owner.type.isParameterized()) {
-                Type base = this.asSuper(owner);
+            int flags = sym.flags();
+            if (((flags & STATIC) == 0 || (flags & INTERFACE) != 0) &&
+                owner.type.isParameterized()) {
+                Type base = this.asOuterSuper(owner);
                 if (base != null) {
+//                  System.out.print("[base = " + base + "]");//DEBUG
                     List<Type> ownerParams = owner.type.allParams();
                     List<Type> baseParams = base.allParams();
@@ -601 +649 @@
                         if (baseParams.isEmpty()) {
                             // then base is a raw type
+//                          System.out.println(sym.type.erasure());//DEBUG
                             return sym.type.erasure();
                         } else {
+//                          System.out.println(sym.type.subst(ownerParams, baseParams));//DEBUG
+                            while (ownerParams.length() > baseParams.length())
+                                ownerParams = ownerParams.tail;
                             return sym.type.subst(ownerParams, baseParams);
                         }
@@ -608 +660 @@
                 }
             }
+//          System.out.println(sym.type);//DEBUG
             return sym.type;
         }
@@ -616 +669 @@
             List<Type> typarams1 = subst(typarams, from, to);
             Type outer1 = outer.subst(from, to);
-            if (typarams1 == typarams && outer1 == outer) return this;
-            else return new ClassType(outer1, typarams1, tsym);
+            if (typarams1 == typarams && outer1 == outer) {
+                return this;
+            } else {
+                TypeSymbol tsym1 = tsym;
+                if (outer.tsym != outer1.tsym && tsym.isNested()) {
+                    TypeSymbol tsym2 = outer1.memberClass(tsym.name);
+                    if (tsym2 != null) {
+                        tsym1 = tsym2;
+                        if (outer1.tag == CLASS) {
+                            outer1 = outer1.asSuper(tsym1.type.outer().tsym);
+                        }
+                    }
+                }
+                return new ClassType(outer1, typarams1, tsym1);
+            }
         }
 
         public boolean isErroneous() {
             return outer().isErroneous() || isErroneous(typarams());
+        }
+
+        public boolean isParameterized() {
+            return allParams().tail != null;
+            // optimization, was: allParams().nonEmpty();
         }
 
@@ -630 +701 @@
         public boolean isRaw() {
             return
-                tsym.type.isParameterized() &&
-                (typarams().isEmpty() &&
-                 tsym.type.typarams().nonEmpty()
-                 ||
-                 outer().isRaw());
-        }
-
-        public boolean isParameterized() {
-            if (tsym.completer != null) tsym.complete();
-            return
-                typarams_field.tail != null
-                  /*inlined: typarams_field.nonEmpty()*/ ||
-                outer_field.tag == CLASS && outer_field.isParameterized();
+                this != tsym.type && // fast special case
+                tsym.type.allParams().nonEmpty() &&
+                allParams().isEmpty() && // fast special case
+                (tsym.type.typarams().nonEmpty() && typarams().isEmpty() ||
+                 outer().isRaw()); // precise condition, slow to check;
         }
 
@@ -675 +738 @@
                 return true;
             } else if (this.tsym == that.tsym) {
-                return !that.isParameterized() || this.genType(that);
+                return 
+                    (!that.isParameterized() || 
+                     genTypes(this.typarams(), that.typarams())) &&
+                    this.outer().subType(that.outer());
             } else {
                 Type st = supertype();
@@ -688 +754 @@
         }
 
+        public TypeSymbol memberClass(Name name) {
+            Type t = this;
+            while (t.tag == CLASS) {
+                Scope.Entry e = t.tsym.members().lookup(name);
+                while (e.scope != null && e.sym.kind != TYP)
+                    e = e.next();
+                if (e.scope != null) return (TypeSymbol) e.sym;
+                t = t.supertype();
+            }
+            return null;
+        }
+
         public boolean castableTo(Type that) {
             List<Type> thatParams = that.allParams();
@@ -697 +775 @@
                  ||
                  (that.subType(this) &&
-                  thatParams.subset(this.allParams()))
+                  (that.tag == ARRAY ||
+                   that.tsym.type == that /*fast special case*/ ||
+                   that.sameType(this.asSub(that.tsym))))
                  ||
                  that.tag == CLASS && thatParams.isEmpty() &&
@@ -740 +820 @@
         }
 
+        public boolean isParameterized() {
+            return elemtype.isParameterized();
+        }
+
         public boolean isRaw() {
             return elemtype.isRaw();
-        }
-
-        public boolean isParameterized() {
-            return elemtype.isParameterized();
         }
 
@@ -945 +1025 @@
         }
 
-        public boolean isErroneous() {
-            return bound != null && bound.isErroneous();
-        }
-
         public Type erasure() {
             return bound.erasure();
+        }
+
+        public TypeSymbol memberClass(Name name) {
+            return bound().memberClass(name);
         }
     }
@@ -986 +1066 @@
 
         public boolean isErroneous()  {
-            return isErroneous(tvars) || qtype.isErroneous();
+            return qtype.isErroneous();
         }
 
@@ -1000 +1080 @@
             return
                 that.tag == FORALL &&
+                sameTypes(
+                    bounds(),
+                    subst(((ForAll)that).bounds(), ((ForAll)that).tvars, tvars)) &&
                 qtype.sameArgs(
                     ((ForAll)that).qtype.subst(((ForAll)that).tvars, tvars));
+        }
+
+        private List<Type> bounds() {
+            ListBuffer<Type> b = new ListBuffer<Type>();
+            for (List<Type> l = tvars; l.nonEmpty(); l = l.tail)
+                b.append(l.head.bound());
+            return b.toList();
         }
 

/trunk/gj/src/gjc/v6/comp/Attr.java

@@ -107 +107 @@
      */
     void warnDeprecated(int pos, Symbol sym) {
-        if (!enter.compiled.contains(sym.enclClass().fullname))
+        if (!chk.compiled.contains(sym.enclClass().fullname))
             log.warning(pos, sym + sym.location() + " has been deprecated");
     }
@@ -115 +115 @@
     Symbol thisSym(Env<AttrContext> env) {
         return rs.resolveSelf(
-            Position.NOPOS, env, env.enclClass.sym, Names._this);
+            Position.NOPOS, env, env.enclClass.sym, Names._this, true);
     }
 
@@ -185 +185 @@
      *  for a method `m' defined in an interface
      */
-    private void addAbstractMethod(ClassDef cd,
+    void addAbstractMethod(ClassDef cd,
                                    MethodSymbol m,
                                    Env<AttrContext> env) {
@@ -433 +433 @@
             else if (thentype.tag < INT && elsetype.tag == INT &&
                 elsetype.assignable(thentype))
-                return thentype;
+                return thentype.baseType();
             else if (elsetype.tag < INT && thentype.tag == INT &&
                      thentype.assignable(elsetype))
-                return elsetype;
+                return elsetype.baseType();
             else if (thentype.tag <= DOUBLE && elsetype.tag <= DOUBLE) {
                 for (int i = BYTE; i <= DOUBLE; i++) {
@@ -448 +448 @@
                 return syms.stringType;
             } else if (thentype.subType(elsetype)) {
-                return elsetype;
+                return elsetype.baseType();
             } else {
                 chk.checkType(pos, elsetype, thentype);
-                return thentype;
-            }
-        }
+                return thentype.baseType();
+            }
+        }
+        
 
     public Type _case(Exec tree, Env<AttrContext> env) {
@@ -653 +654 @@
             TreeInfo.setSymbol(clazzid, TreeInfo.symbol(clazzid1));
             clazzid.type = ((Ident)clazzid).sym.type;
+        } else if ((clazztype.tsym.flags() & INTERFACE) == 0 && 
+                   clazztype.outer().tag == CLASS) {
+            rs.resolveSelf(
+                tree.pos, env, clazztype.outer().tsym, Names._this, false);
         }
 
@@ -659 +664 @@
 
         if (clazztype.tag == CLASS) {
-//          Type site = clazztype.tsym.type;
-//          List<Type> typarams = clazztype.typarams();
-//
-//          if (site.typarams().nonEmpty() && typarams.isEmpty())
-//              site = site.erasure();
-
             // resolve constructor, if not abstract
             if (cdef == null &&
@@ -705 +704 @@
                 attribStat(cdef, env.dup(tree));
 //              new Pretty().printStat(cdef);//DEBUG
+
+                // don't pass a this0 to anonymous classes in super calls
+                if (tree.encl == null && env.info.isSelfCall) 
+                    cdef.sym.flags_field |= NOTHIS0;
 
                 // if enclosing class is given,
@@ -931 +934 @@
         }
 
+        if ((sym.flags() & DEPRECATED) != 0) 
+            warnDeprecated(tree.pos, sym);
         return checkId(tree, env.enclClass.sym.type, sym, pkind, pt);
     }
@@ -983 +988 @@
             env.info.selectSuper = selectSuperPrev;
         }
+
+        if ((sym.flags() & DEPRECATED) != 0) 
+            warnDeprecated(tree.pos, sym);
         return checkId(tree, site, sym, pkind, pt);
     }
@@ -994 +1002 @@
          *  @param pkind  the expected kind(s) of the Select expression
          */
-        private Symbol selectSym(Select tree, Type site,
-                                 Env<AttrContext> env, Type pt, int pkind) {
+        Symbol selectSym(Select tree, Type site,
+                         Env<AttrContext> env, Type pt, int pkind) {
             int pos = tree.pos;
             Name name = tree.name;
@@ -1009 +1017 @@
                         pos, env, site, name, Type.emptyList, pt.argtypes());
                 } else if (name == Names._this) {
-                    return rs.resolveSelf(pos, env, site.tsym, name);
+                    return rs.resolveSelf(pos, env, site.tsym, name, true);
                 } else if (name == Names._class) {
                     return new VarSymbol(
@@ -1060 +1068 @@
          */
         Type checkId(Tree tree, Type site, Symbol sym, int pkind, Type pt) {
-            if ((sym.flags() & DEPRECATED) != 0) warnDeprecated(tree.pos, sym);
             Type owntype;
             switch (sym.kind) {
@@ -1070 +1077 @@
                         site != owntype.outer()) 
                     {
-                        owntype = new ClassType(
-                            site, Type.emptyList, owntype.tsym);
-                    } else if (owntype.typarams().nonEmpty()) {
+                        Type normSite = site;
+                        if (normSite.tag == CLASS) 
+                            normSite = site.asOuterSuper(owntype.outer().tsym);
+                        if (normSite != owntype.outer())
+                            owntype = new ClassType(
+                                normSite, Type.emptyList, owntype.tsym);
+                    } 
+                    if (owntype.typarams().nonEmpty()) {
                         owntype = new ClassType(
                             owntype.outer(), Type.emptyList, owntype.tsym);
@@ -1106 +1118 @@
                     (sym.flags() & STATIC) == 0 &&
                     site.tag == CLASS) {
-                    Type s= site.asOuterSuper(sym.owner);
+                    Type s = site.asOuterSuper(sym.owner);
                     if (s != null &&
                         s.isRaw() &&
@@ -1246 +1258 @@
             if (actuals.length() == formals.length()) {
                 owntype = new ClassType(
-                    clazztype.tsym.type.outer(), actuals, clazztype.tsym);
+                    clazztype.outer(), actuals, clazztype.tsym);
             } else {
                 log.error(

/trunk/gj/src/gjc/v6/comp/Check.java

@@ -32 +32 @@
     }
 
-    /** switch: unchecked option set?
+    /** the set of all compiled classes in this run; maintained from outside
+     */
+    public Set<Name> compiled = new Set<Name>();
+
+    /** switch: -unchecked option set?
      */
     boolean unchecked;
@@ -109 +113 @@
             return t.tag == TYPEVAR || t.tag == ARRAY && isTypeVar(t.elemtype());
         }
+
+    /** Check that type `a' deeply extends type `b'.
+     *  That is, check that `a' is a subtype of `b', 
+     *  and that all inner classes of `a' deeply extend
+     *  corresponding inner classes in `b'.
+     */
+    public boolean checkDeeplyExtends(int pos, boolean reportErrors, 
+                                      Type a, Type b) {
+        if (!a.subType(b)) {
+            log.error(pos,
+                "type parameter " + a + " is not within its bound " + b);
+            return false;
+        } else {
+            return checkDeeplyExtends(pos, reportErrors, a, b, a, b);
+        }
+    }
+
+    /** Inner class extension rule: given a bounding declaration 
+     *
+     *   d extends T
+     *
+     * and an instance S bound to d, it must hold that 
+     *
+     *   S   deeply extends  T[S/d]  .
+     *
+     *
+     * DEFINITION: A type S *deeply extends* a type T, if 
+     *
+     *   S extends T
+     *
+     * and, for all (non-static) class members A of T, 
+     *
+     *   S.A  deeply extends  T.A,
+     *   S.A  has at least the same access priviliges as T.A, and
+     *   S.A  is not static.
+     *
+     * The class members of a type variable are taken to be the class members
+     * of its bound.
+     *
+     * Note that given declarations
+     *
+     *   class G<g extends T>
+     *   class F<f extends S> extends G<f>
+     *
+     * we must check that f deeply extends T
+     * (by checking that S deeply extends T).
+     *
+     */
+    public boolean checkDeeplyExtends(int pos, boolean reportErrors,
+                                      Type aroot, Type broot, 
+                                      Type a, Type b) {
+        if (a == b) { // fast special case
+            return true;
+        } else if (!a.subType(b)) {
+            if (reportErrors) 
+                log.error(pos,
+                    "type parameter " + aroot + 
+                    " is not within its bound " + broot + 
+                    " since " + a + " is not a subtype of " + b);
+            return false;
+        } else {
+            Scope s = b.tsym.members();
+            if (s != null) {
+                for (Scope.Entry e = s.elems; e != null; e = e.sibling) {
+                    if (e.sym.kind == TYP && 
+                        (e.sym.flags_field & (STATIC | PRIVATE)) == 0) 
+                    {
+                        Type b1 = b.memberType(e.sym);
+                        Type a1 = a.memberType(a.memberClass(e.sym.name));
+                        if ((a1.tsym.flags_field & STATIC) != 0) {
+                            if (reportErrors) 
+                                log.error(pos,
+                                    "type parameter " + aroot + 
+                                    " is not within its bound " + broot + 
+                                    " since " + a + " is static");
+                            return false;  
+                        }
+                        if (protection(a.tsym.flags_field) > 
+                            protection(b.tsym.flags_field)) {
+                            if (reportErrors) 
+                                log.error(pos,
+                                    "type parameter " + aroot + 
+                                    " is not within its bound " + broot + 
+                                    " since " + a + 
+                                    " has weaker access priviliges than " + b);
+                            return false;
+                        }
+                        if (!checkDeeplyExtends(
+                            pos, reportErrors, aroot, broot, a1, b1))
+                        {
+                            return false;
+                        } 
+                    }
+                }
+            }
+            return true;
+        }
+    }
 
    /** check that type t is different from 'void'.
@@ -193 +295 @@
                 if (sym.owner.owner.kind == PCK ||
                     (sym.owner.flags_field & STATIC) != 0) mask |= STATIC;
+                if ((flags & INTERFACE) != 0) implicit = STATIC;
             } else {
                 mask = ClassFlags;
@@ -212 +315 @@
 //should it be deleted here?
                  &&
+
+          // JavaParty [
                  checkDisjoint(pos, flags,
-                               ABSTRACT | INTERFACE,
+                               ABSTRACT,
                                FINAL | NATIVE | SYNCHRONIZED)
+                 &&
+                 checkDisjoint(pos, flags,
+                               INTERFACE,
+                               FINAL | NATIVE | SYNCHRONIZED | REMOTE)
+          // ] JavaParty
+
                  &&
                  checkDisjoint(pos, flags,
@@ -284 +395 @@
                     Type bound = forms.head.bound().subst(formals, actuals);
                     validate(a);
-                    if (!a.type.subType(bound))
-                        log.error(a.pos,
-                                  "type parameter " + a.type +
-                                  " is not within bound " + bound);
+                    checkDeeplyExtends(tree.pos, true, a.type, bound);
                     args = args.tail;
                     forms = forms.tail;
@@ -303 +411 @@
         public Void _case(Select tree, Void arg) {
             if (tree.type.tag == CLASS) {
-                if (tree.type.outer().tag == CLASS) validate(tree.selected);
+                if (tree.type.outer().tag == CLASS) 
+                    validate(tree.selected);
+                else if (tree.selected.type.isParameterized())
+                    log.error(
+                        tree.pos,
+                        "cannot select a static class from a parameterized type");
+                    
                 if (tree.type.isRaw() && tree.type.allParams().nonEmpty())
                     log.error(
@@ -495 +609 @@
             List<Type> mtvars = mt.typarams();
             List<Type> otvars = ot.typarams();
-            if (!(mt.restype().subType(ot.restype().subst(otvars, mtvars)))) {
-                typeError(pos,
-                    cannotOverride(m, other) + " with incompatible return type",
-                    mt.restype(), ot.restype().subst(otvars, mtvars));
+            Type otres = ot.restype().subst(otvars, mtvars);
+            if (!(mt.restype().subType(otres))) {
+                if ((m.flags() & IPROXY) != 0 && otres.subType(mt.restype())) {
+                    ((MethodType)mt).restype = otres;
+                } else {
+                    typeError(pos,
+                        cannotOverride(m, other) + " with incompatible return type",
+                        mt.restype(), ot.restype().subst(otvars, mtvars));
+                }
             } else if ((origin.flags() & INTERFACE) == 0) {
                 List<ClassSymbol> unhandled = unHandled(mt.thrown(), ot.thrown());
@@ -513 +632 @@
         }
     }
-
+                                                                             
     /** check that this method conforms with any class member method
      *  it overrides.
@@ -549 +668 @@
          *  null if there is none.
          */
-        private MethodSymbol firstUndef(ClassSymbol impl, ClassSymbol c) {
+        MethodSymbol firstUndef(ClassSymbol impl, ClassSymbol c) {
             MethodSymbol undef = null;
             if (c == impl || (c.flags() & (ABSTRACT | INTERFACE)) != 0) {