diff -r 21685ef33d2b -r 27a3026256cd src/share/classes/com/sun/tools/javac/code/Symbol.java
--- a/src/share/classes/com/sun/tools/javac/code/Symbol.java	Wed Mar 12 21:44:46 2014 +0000
+++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java	Wed Mar 19 16:44:49 2014 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -467,11 +467,24 @@
 
     private boolean hiddenIn(ClassSymbol clazz, Types types) {
         Symbol sym = hiddenInInternal(clazz, types);
-        return sym != null && sym != this;
+        Assert.check(sym != null, "the result of hiddenInInternal() can't be null");
+        /* If we find the current symbol then there is no symbol hiding it
+         */
+        return sym != this;
     }
 
-    private Symbol hiddenInInternal(ClassSymbol c, Types types) {
-        Scope.Entry e = c.members().lookup(name);
+    /** This method looks in the supertypes graph that has the current class as the
+     * initial node, till it finds the current symbol or another symbol that hides it.
+     * If the current class has more than one supertype (extends one class and
+     * implements one or more interfaces) then null can be returned, meaning that
+     * a wrong path in the supertypes graph was selected. Null can only be returned
+     * as a temporary value, as a result of the recursive call.
+     */
+    private Symbol hiddenInInternal(ClassSymbol currentClass, Types types) {
+        if (currentClass == owner) {
+            return this;
+        }
+        Scope.Entry e = currentClass.members().lookup(name);
         while (e.scope != null) {
             if (e.sym.kind == kind &&
                     (kind != MTH ||
@@ -481,18 +494,19 @@
             }
             e = e.next();
         }
-        List<Symbol> hiddenSyms = List.nil();
-        for (Type st : types.interfaces(c.type).prepend(types.supertype(c.type))) {
+        Symbol hiddenSym = null;
+        for (Type st : types.interfaces(currentClass.type)
+                .prepend(types.supertype(currentClass.type))) {
             if (st != null && (st.hasTag(CLASS))) {
                 Symbol sym = hiddenInInternal((ClassSymbol)st.tsym, types);
-                if (sym != null) {
-                    hiddenSyms = hiddenSyms.prepend(hiddenInInternal((ClassSymbol)st.tsym, types));
+                if (sym == this) {
+                    return this;
+                } else if (sym != null) {
+                    hiddenSym = sym;
                 }
             }
         }
-        return hiddenSyms.contains(this) ?
-                this :
-                (hiddenSyms.isEmpty() ? null : hiddenSyms.head);
+        return hiddenSym;
     }
 
     /** Is this symbol inherited into a given class?