diff -r ec977a00cecb src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java	Wed Apr 01 12:30:13 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java	Thu Apr 30 12:44:48 2015 +0100
@@ -2693,57 +2693,48 @@
     // </editor-fold>
 
     // <editor-fold defaultstate="collapsed" desc="compute transitive closure of all members in given site">
-    class MembersClosureCache extends SimpleVisitor<CompoundScope, Boolean> {
-
-        private WeakHashMap<TypeSymbol, Entry> _map = new WeakHashMap<>();
-
-        class Entry {
-            final boolean skipInterfaces;
-            final CompoundScope compoundScope;
-
-            public Entry(boolean skipInterfaces, CompoundScope compoundScope) {
-                this.skipInterfaces = skipInterfaces;
-                this.compoundScope = compoundScope;
-            }
-
-            boolean matches(boolean skipInterfaces) {
-                return this.skipInterfaces == skipInterfaces;
-            }
+    class MembersClosureCache extends SimpleVisitor<Pair<CompoundScope, CompoundScope>, Void> {
+
+        private WeakHashMap<TypeSymbol, Pair<CompoundScope, CompoundScope>> _map = new WeakHashMap<>();
+
+        List<TypeSymbol> seenTypes = List.nil();
+
+        /** members closure visitor methods **/
+
+        private final Pair<CompoundScope, CompoundScope> nullEntry = new Pair<>(null, null);
+
+        public Pair<CompoundScope, CompoundScope> visitType(Type t, Void _unused) {
+            return nullEntry;
         }
 
-        List<TypeSymbol> seenTypes = List.nil();
-
-        /** members closure visitor methods **/
-
-        public CompoundScope visitType(Type t, Boolean skipInterface) {
-            return null;
-        }
-
         @Override
-        public CompoundScope visitClassType(ClassType t, Boolean skipInterface) {
+        public Pair<CompoundScope, CompoundScope> visitClassType(ClassType t, Void _unused) {
             if (seenTypes.contains(t.tsym)) {
                 //this is possible when an interface is implemented in multiple
                 //superclasses, or when a classs hierarchy is circular - in such
                 //cases we don't need to recurse (empty scope is returned)
-                return new CompoundScope(t.tsym);
+                return new Pair<>(new CompoundScope(t.tsym), new CompoundScope(t.tsym));
             }
             try {
                 seenTypes = seenTypes.prepend(t.tsym);
                 ClassSymbol csym = (ClassSymbol)t.tsym;
-                Entry e = _map.get(csym);
-                if (e == null || !e.matches(skipInterface)) {
-                    CompoundScope membersClosure = new CompoundScope(csym);
-                    if (!skipInterface) {
-                        for (Type i : interfaces(t)) {
-                            membersClosure.prependSubScope(visit(i, skipInterface));
-                        }
+                Pair<CompoundScope, CompoundScope> e = _map.get(csym);
+                if (e == null) {
+                    CompoundScope membersClosureAll = new CompoundScope(csym);
+                    CompoundScope membersClosureNoInterfaces = new CompoundScope(csym);
+                    for (Type i : interfaces(t)) {
+                        membersClosureAll.prependSubScope(visit(i, null).fst);
                     }
-                    membersClosure.prependSubScope(visit(supertype(t), skipInterface));
-                    membersClosure.prependSubScope(csym.members());
-                    e = new Entry(skipInterface, membersClosure);
+                    Pair<CompoundScope, CompoundScope> superCompoundScope =
+                            visit(supertype(t), null);
+                    membersClosureAll.prependSubScope(superCompoundScope.fst);
+                    membersClosureNoInterfaces.prependSubScope(superCompoundScope.snd);
+                    membersClosureAll.prependSubScope(csym.members());
+                    membersClosureNoInterfaces.prependSubScope(csym.members());
+                    e = new Pair<>(membersClosureAll, membersClosureNoInterfaces);
                     _map.put(csym, e);
                 }
-                return e.compoundScope;
+                return e;
             }
             finally {
                 seenTypes = seenTypes.tail;
@@ -2751,15 +2742,16 @@
         }
 
         @Override
-        public CompoundScope visitTypeVar(TypeVar t, Boolean skipInterface) {
-            return visit(t.getUpperBound(), skipInterface);
+        public Pair<CompoundScope, CompoundScope> visitTypeVar(TypeVar t, Void _unused) {
+            return visit(t.getUpperBound(), null);
         }
     }
 
     private MembersClosureCache membersCache = new MembersClosureCache();
 
     public CompoundScope membersClosure(Type site, boolean skipInterface) {
-        return membersCache.visit(site, skipInterface);
+        Pair<CompoundScope, CompoundScope> csPair = membersCache.visit(site, null);
+        return skipInterface ? csPair.snd : csPair.fst;
     }
     // </editor-fold>