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 13:23:34 2015 +0100
@@ -40,6 +40,7 @@
 import com.sun.tools.javac.code.Attribute.RetentionPolicy;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
+import com.sun.tools.javac.code.Types.MembersClosureCache.MembersScope;
 import com.sun.tools.javac.comp.AttrContext;
 import com.sun.tools.javac.comp.Check;
 import com.sun.tools.javac.comp.Enter;
@@ -2693,34 +2694,56 @@
     // </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) {
+    class MembersClosureCache extends SimpleVisitor<Scope.CompoundScope, Void> {
+
+        private WeakHashMap<TypeSymbol, CompoundScope> _map = new WeakHashMap<>();
+
+        List<TypeSymbol> seenTypes = List.nil();
+
+        /** members closure visitor methods **/
+
+        class MembersScope extends CompoundScope {
+
+            CompoundScope scope;
+            boolean skipInterfaces;
+
+            public MembersScope(CompoundScope scope, boolean skipInterfaces) {
+                super(scope.owner);
+                this.scope = scope;
                 this.skipInterfaces = skipInterfaces;
-                this.compoundScope = compoundScope;
-            }
-
-            boolean matches(boolean skipInterfaces) {
-                return this.skipInterfaces == skipInterfaces;
+            }
+
+            Filter<Symbol> combine(Filter<Symbol> sf) {
+                return s -> (!skipInterfaces || !s.owner.isInterface()) && sf.accepts(s);
+            }
+
+            @Override
+            public Iterable<Symbol> getSymbols(Filter<Symbol> sf, LookupKind lookupKind) {
+                return scope.getSymbols(combine(sf), lookupKind);
+            }
+
+            @Override
+            public Iterable<Symbol> getSymbolsByName(Name name, Filter<Symbol> sf, LookupKind lookupKind) {
+                return scope.getSymbolsByName(name, combine(sf), lookupKind);
+            }
+
+            @Override
+            public int getMark() {
+                return scope.getMark();
             }
         }
 
-        List<TypeSymbol> seenTypes = List.nil();
-
-        /** members closure visitor methods **/
-
-        public CompoundScope visitType(Type t, Boolean skipInterface) {
-            return null;
+        CompoundScope nilScope;
+
+        public CompoundScope visitType(Type t, Void _unused) {
+            if (nilScope == null) {
+                nilScope = new CompoundScope(syms.noSymbol);
+            }
+            return nilScope;
         }
 
         @Override
-        public CompoundScope visitClassType(ClassType t, Boolean skipInterface) {
+        public 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
@@ -2730,20 +2753,17 @@
             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));
-                        }
+                CompoundScope membersClosure = _map.get(csym);
+                if (membersClosure == null) {
+                    membersClosure = new CompoundScope(csym);
+                    for (Type i : interfaces(t)) {
+                        membersClosure.prependSubScope(visit(i, null));
                     }
-                    membersClosure.prependSubScope(visit(supertype(t), skipInterface));
+                    membersClosure.prependSubScope(visit(supertype(t), null));
                     membersClosure.prependSubScope(csym.members());
-                    e = new Entry(skipInterface, membersClosure);
-                    _map.put(csym, e);
+                    _map.put(csym, membersClosure);
                 }
-                return e.compoundScope;
+                return membersClosure;
             }
             finally {
                 seenTypes = seenTypes.tail;
@@ -2751,15 +2771,19 @@
         }
 
         @Override
-        public CompoundScope visitTypeVar(TypeVar t, Boolean skipInterface) {
-            return visit(t.getUpperBound(), skipInterface);
+        public 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);
+        CompoundScope cs = membersCache.visit(site, null);
+        if (cs == null) {
+            throw new AssertionError("type " + site);
+        }
+        return membersCache.new MembersScope(cs, skipInterface);
     }
     // </editor-fold>