diff --git a/src/main/java/de/thetaphi/forbiddenapis/Checker.java b/src/main/java/de/thetaphi/forbiddenapis/Checker.java
index a2633d1..3992c3b 100644
--- a/src/main/java/de/thetaphi/forbiddenapis/Checker.java
+++ b/src/main/java/de/thetaphi/forbiddenapis/Checker.java
@@ -70,9 +70,9 @@ public static enum Option {
   final EnumSet<Option> options;
   
   /** Classes to check: key is the binary name (dotted) */
-  final Map<String,ClassSignature> classesToCheck = new HashMap<>();
+  final Map<String,ClassMetadata> classesToCheck = new HashMap<>();
   /** Cache of loaded classes: key is the binary name (dotted) */
-  final Map<String,ClassSignature> classpathClassCache = new HashMap<>();
+  final Map<String,ClassMetadata> classpathClassCache = new HashMap<>();
   
   final Signatures forbiddenSignatures;
   
@@ -185,7 +185,7 @@ public Checker(Logger logger, ClassLoader loader, EnumSet<Option> options) {
   }
   
   /** Loads the class from Java9's module system and uses reflection to get methods and fields. */
-  private ClassSignature loadClassFromJigsaw(String classname) throws IOException {
+  private ClassMetadata loadClassFromJigsaw(String classname) throws IOException {
     if (method_Class_getModule == null || method_Module_getName == null) {
       return null; // not Jigsaw Module System
     }
@@ -200,7 +200,7 @@ private ClassSignature loadClassFromJigsaw(String classname) throws IOException
       return null; // not found
     }
     
-    return new ClassSignature(clazz, AsmUtils.isRuntimeModule(moduleName));
+    return new ClassMetadata(clazz, AsmUtils.isRuntimeModule(moduleName));
   }
   
   private boolean isRuntimePath(URL url) throws IOException {
@@ -233,9 +233,9 @@ private boolean isRuntimeClass(URLConnection conn) throws IOException {
   
   /** Reads a class (binary name) from the given {@link ClassLoader}. If not found there, falls back to the list of classes to be checked. */
   @Override
-  public ClassSignature getClassFromClassLoader(final String clazz) throws ClassNotFoundException,IOException {
+  public ClassMetadata getClassFromClassLoader(final String clazz) throws ClassNotFoundException,IOException {
     if (classpathClassCache.containsKey(clazz)) {
-      final ClassSignature c = classpathClassCache.get(clazz);
+      final ClassMetadata c = classpathClassCache.get(clazz);
       if (c == null) {
         throw new ClassNotFoundException(clazz);
       }
@@ -255,7 +255,7 @@ public ClassSignature getClassFromClassLoader(final String clazz) throws ClassNo
           // if class is too new for this JVM, we try to load it as Class<?> via Jigsaw
           // (only if it's a runtime class):
           if (isRuntimeClass) {
-            final ClassSignature c = loadClassFromJigsaw(clazz);
+            final ClassMetadata c = loadClassFromJigsaw(clazz);
             if (c != null) {
               classpathClassCache.put(clazz, c);
               return c;
@@ -265,18 +265,18 @@ public ClassSignature getClassFromClassLoader(final String clazz) throws ClassNo
               "The class file format of '%s' (loaded from location '%s') is too recent to be parsed by ASM.",
               clazz, url.toExternalForm()));
         }
-        final ClassSignature c = new ClassSignature(cr, isRuntimeClass, false);
+        final ClassMetadata c = new ClassMetadata(cr, isRuntimeClass, false);
         classpathClassCache.put(clazz, c);
         return c;
       } else {
-        final ClassSignature c = loadClassFromJigsaw(clazz);
+        final ClassMetadata c = loadClassFromJigsaw(clazz);
         if (c != null) {
           classpathClassCache.put(clazz, c);
           return c;
         }
       }
       // try to get class from our list of classes we are checking:
-      final ClassSignature c = classesToCheck.get(clazz);
+      final ClassMetadata c = classesToCheck.get(clazz);
       if (c != null) {
         classpathClassCache.put(clazz, c);
         return c;
@@ -288,7 +288,7 @@ public ClassSignature getClassFromClassLoader(final String clazz) throws ClassNo
   }
   
   @Override
-  public ClassSignature lookupRelatedClass(String internalName, String internalNameOrig) {
+  public ClassMetadata lookupRelatedClass(String internalName, String internalNameOrig) {
     final Type type = Type.getObjectType(internalName);
     if (type.getSort() != Type.OBJECT) {
       return null;
@@ -361,8 +361,8 @@ public void addClassToCheck(final InputStream in, String name) throws IOExceptio
       throw new IllegalArgumentException(String.format(Locale.ENGLISH,
           "The class file format of '%s' is too recent to be parsed by ASM.", name));
     }
-    final String binaryName = Type.getObjectType(reader.getClassName()).getClassName();
-    classesToCheck.put(binaryName, new ClassSignature(reader, false, true));
+    final ClassMetadata metadata = new ClassMetadata(reader, false, true);
+    classesToCheck.put(metadata.getBinaryClassName(), metadata);
   }
   
   /** Parses and adds a class from the given file to the list of classes to check. Does not log anything. */
@@ -407,11 +407,11 @@ public void addSuppressAnnotation(String annoName) {
   }
   
   /** Parses a class and checks for valid method invocations */
-  private int checkClass(final ClassReader reader, Pattern suppressAnnotationsPattern) throws ForbiddenApiException {
-    final String className = Type.getObjectType(reader.getClassName()).getClassName();
-    final ClassScanner scanner = new ClassScanner(this, forbiddenSignatures, suppressAnnotationsPattern); 
+  private int checkClass(ClassMetadata c, Pattern suppressAnnotationsPattern) throws ForbiddenApiException {
+    final String className = c.getBinaryClassName();
+    final ClassScanner scanner = new ClassScanner(c, this, forbiddenSignatures, suppressAnnotationsPattern); 
     try {
-      reader.accept(scanner, ClassReader.SKIP_FRAMES);
+      c.getReader().accept(scanner, ClassReader.SKIP_FRAMES);
     } catch (RelatedClassLoadingException rcle) {
       final Exception cause = rcle.getException();
       final StringBuilder msg = new StringBuilder()
@@ -456,8 +456,8 @@ public void run() throws ForbiddenApiException {
     logger.info("Scanning classes for violations...");
     int errors = 0;
     final Pattern suppressAnnotationsPattern = AsmUtils.glob2Pattern(suppressAnnotations.toArray(new String[suppressAnnotations.size()]));
-    for (final ClassSignature c : classesToCheck.values()) {
-      errors += checkClass(c.getReader(), suppressAnnotationsPattern);
+    for (final ClassMetadata c : classesToCheck.values()) {
+      errors += checkClass(c, suppressAnnotationsPattern);
     }
     
     final String message = String.format(Locale.ENGLISH, 
diff --git a/src/main/java/de/thetaphi/forbiddenapis/ClassSignature.java b/src/main/java/de/thetaphi/forbiddenapis/ClassMetadata.java
similarity index 93%
rename from src/main/java/de/thetaphi/forbiddenapis/ClassSignature.java
rename to src/main/java/de/thetaphi/forbiddenapis/ClassMetadata.java
index 7fabcde..1fbcb45 100644
--- a/src/main/java/de/thetaphi/forbiddenapis/ClassSignature.java
+++ b/src/main/java/de/thetaphi/forbiddenapis/ClassMetadata.java
@@ -33,22 +33,23 @@
 
 /** Utility class that is used to get an overview of all fields and implemented
  * methods of a class. It make the signatures available as Sets. */
-final class ClassSignature implements Constants {
+final class ClassMetadata implements Constants {
   private ClassReader reader;
   
-  public final boolean isRuntimeClass, isNonPortableRuntime;
+  public final boolean isRuntimeClass, isNonPortableRuntime, isInterface;
   public final Set<Method> methods;
   public final Set<String> fields, signaturePolymorphicMethods;
   public final String className, superName;
   public final String[] interfaces;
   
   /** Builds the information from an ASM ClassReader */
-  public ClassSignature(final ClassReader classReader, boolean isRuntimeClass, boolean withReader) {
+  public ClassMetadata(final ClassReader classReader, boolean isRuntimeClass, boolean withReader) {
     this.reader = withReader ? classReader : null;
     this.isRuntimeClass = isRuntimeClass;
     this.className = classReader.getClassName();
     this.superName = classReader.getSuperName();
     this.interfaces = classReader.getInterfaces();
+    this.isInterface = (classReader.getAccess() & Opcodes.ACC_INTERFACE) != 0;
     final Set<Method> methods = new HashSet<>();
     final Set<String> fields = new HashSet<>();
     final Set<String> signaturePolymorphicMethods = new HashSet<>();
@@ -80,7 +81,7 @@ public FieldVisitor visitField(int access, String name, String desc, String sign
   }
 
   /** Alternative ctor that can be used to build the information via reflection from an already loaded class. Useful for Java 9 Jigsaw. */
-  public ClassSignature(final Class<?> clazz, boolean isRuntimeClass) {
+  public ClassMetadata(final Class<?> clazz, boolean isRuntimeClass) {
     this.reader = null; // no reader available!
     this.isRuntimeClass = isRuntimeClass;
     this.className = Type.getType(clazz).getInternalName();
@@ -91,6 +92,7 @@ public ClassSignature(final Class<?> clazz, boolean isRuntimeClass) {
     for (int i = 0; i < interfClasses.length; i++) {
       this.interfaces[i] = Type.getType(interfClasses[i]).getInternalName();
     }
+    this.isInterface = clazz.isInterface();
     final Set<Method> methods = new HashSet<>();
     final Set<String> fields = new HashSet<>();
     final Set<String> signaturePolymorphicMethods = new HashSet<>();
diff --git a/src/main/java/de/thetaphi/forbiddenapis/ClassScanner.java b/src/main/java/de/thetaphi/forbiddenapis/ClassScanner.java
index 9cc5b78..065c432 100644
--- a/src/main/java/de/thetaphi/forbiddenapis/ClassScanner.java
+++ b/src/main/java/de/thetaphi/forbiddenapis/ClassScanner.java
@@ -26,6 +26,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.regex.Pattern;
 
 import org.objectweb.asm.AnnotationVisitor;
@@ -42,6 +43,7 @@
 
 public final class ClassScanner extends ClassVisitor implements Constants {
   private final boolean forbidNonPortableRuntime;
+  final ClassMetadata metadata;
   final RelatedClassLookup lookup;
   final List<ForbiddenViolation> violations = new ArrayList<>();
   
@@ -53,7 +55,6 @@ public final class ClassScanner extends ClassVisitor implements Constants {
   private String source = null;
   private boolean isDeprecated = false;
   private boolean done = false;
-  String internalMainClassName = null;
   int currentGroupId = 0;
   
   // Mapping from a (possible) lambda Method to groupId of declaring method
@@ -63,8 +64,9 @@ public final class ClassScanner extends ClassVisitor implements Constants {
   final BitSet suppressedGroups = new BitSet();
   boolean classSuppressed = false;
   
-  public ClassScanner(RelatedClassLookup lookup, Signatures forbiddenSignatures, final Pattern suppressAnnotations) {
+  public ClassScanner(ClassMetadata metadata, RelatedClassLookup lookup, Signatures forbiddenSignatures, final Pattern suppressAnnotations) {
     super(Opcodes.ASM9);
+    this.metadata = metadata;
     this.lookup = lookup;
     this.forbiddenSignatures = forbiddenSignatures;
     this.suppressAnnotations = suppressAnnotations;
@@ -92,13 +94,13 @@ String checkClassUse(Type type, String what, boolean deep, String origInternalNa
     if (type.getSort() != Type.OBJECT) {
       return null; // we don't know this type, just pass!
     }
-    final String printout = forbiddenSignatures.checkType(type);
-    if (printout != null) {
-      return String.format(Locale.ENGLISH, "Forbidden %s use: %s", what, printout);
+    final String violation = forbiddenSignatures.checkType(type, what);
+    if (violation != null) {
+      return violation;
     }
     if (deep && forbidNonPortableRuntime) {
       final String binaryClassName = type.getClassName();
-      final ClassSignature c = lookup.lookupRelatedClass(type.getInternalName(), origInternalName);
+      final ClassMetadata c = lookup.lookupRelatedClass(type.getInternalName(), origInternalName);
       if (c != null && c.isNonPortableRuntime) {
         return String.format(Locale.ENGLISH,
           "Forbidden %s use: %s [non-portable or internal runtime class]",
@@ -113,32 +115,94 @@ String checkClassUse(String internalName, String what, String origInternalName)
     return checkClassUse(Type.getObjectType(internalName), what, true, origInternalName);
   }
   
-  private String checkClassDefinition(String origName, String superName, String[] interfaces) {
-    if (superName != null) {
-      String violation = checkClassUse(superName, "class", origName);
-      if (violation != null) {
-        return violation;
-      }
-      final ClassSignature c = lookup.lookupRelatedClass(superName, origName);
-      if (c != null && (violation = checkClassDefinition(origName, c.superName, c.interfaces)) != null) {
-        return violation;
+  // TODO: @FunctionalInterface from Java 8 on
+  static interface AncestorVisitor {
+    final String STOP = new String("STOP");
+    
+    String visit(ClassMetadata c, String origName, boolean isInterfaceOfAncestor, boolean previousInRuntime);
+  }
+  
+  String visitAncestors(ClassMetadata cls, AncestorVisitor visitor, boolean visitSelf, boolean visitInterfacesFirst) {
+    if (visitSelf) {
+      final String result = visitor.visit(cls, cls.className, cls.isInterface, cls.isRuntimeClass);
+      if (result != null && result != AncestorVisitor.STOP) {
+        return result;
       }
     }
-    if (interfaces != null) {
-      for (String intf : interfaces) {
-        String violation = checkClassUse(intf, "interface", origName);
-        if (violation != null) {
-          return violation;
+    return visitAncestorsRecursive(cls, cls.className, visitor, cls.isRuntimeClass, visitInterfacesFirst);
+  }
+  
+  private String visitSuperclassRecursive(ClassMetadata cls, String origName, AncestorVisitor visitor, boolean previousInRuntime, boolean visitInterfacesFirst) {
+    if (cls.superName != null) {
+      final ClassMetadata c = lookup.lookupRelatedClass(cls.superName, origName);
+      if (c != null) {
+        String result = visitor.visit(c, origName, false, previousInRuntime);
+        if (result != AncestorVisitor.STOP) {
+          if (result != null) {
+            return result;
+          }
+          result = visitAncestorsRecursive(c, origName, visitor, cls.isRuntimeClass, visitInterfacesFirst);
+          if (result != null) {
+            return result;
+          }
         }
-        final ClassSignature c = lookup.lookupRelatedClass(intf, origName);
-        if (c != null && (violation = checkClassDefinition(origName, c.superName, c.interfaces)) != null) {
-          return violation;
+      }
+    }
+    return null;
+  }
+  
+  private String visitInterfacesRecursive(ClassMetadata cls, String origName, AncestorVisitor visitor, boolean previousInRuntime, boolean visitInterfacesFirst) {
+    if (cls.interfaces != null) {
+      for (String intf : cls.interfaces) {
+        final ClassMetadata c = lookup.lookupRelatedClass(intf, origName);
+        if (c == null) continue;
+        String result = visitor.visit(c, origName, true, previousInRuntime);
+        if (result != AncestorVisitor.STOP) {
+          if (result != null) {
+            return result;
+          }
+          result = visitAncestorsRecursive(c, origName, visitor, cls.isRuntimeClass, visitInterfacesFirst);
+          if (result != null) {
+            return result;
+          }
         }
       }
     }
     return null;
   }
   
+  private String visitAncestorsRecursive(ClassMetadata cls, String origName, AncestorVisitor visitor, boolean previousInRuntime, boolean visitInterfacesFirst) {
+    String result;
+    if (visitInterfacesFirst) {
+      result = visitInterfacesRecursive(cls, origName, visitor, previousInRuntime, visitInterfacesFirst);
+      if (result != null) {
+        return result;
+      }
+    }
+    result = visitSuperclassRecursive(cls, origName, visitor, previousInRuntime, visitInterfacesFirst);
+    if (result != null) {
+      return result;
+    }
+    if (!visitInterfacesFirst) {
+      result = visitInterfacesRecursive(cls, origName, visitor, previousInRuntime, visitInterfacesFirst);
+      if (result != null) {
+        return result;
+      }
+    }
+    return null;
+  }
+  
+  // TODO: convert to lambda method with method reference
+  private final AncestorVisitor classRelationAncestorVisitor = new AncestorVisitor() {
+    @Override
+    public String visit(ClassMetadata c, String origName, boolean isInterfaceOfAncestor, boolean previousInRuntime) {
+      if (previousInRuntime && c.isNonPortableRuntime) {
+        return null; // something inside the JVM is extending internal class/interface
+      }
+      return checkClassUse(c.className, isInterfaceOfAncestor ? "interface" : "class", origName);
+    }
+  };
+  
   String checkType(Type type) {
     while (type != null) {
       String violation;
@@ -149,9 +213,8 @@ String checkType(Type type) {
           if (violation != null) {
             return violation;
           }
-          final ClassSignature c = lookup.lookupRelatedClass(internalName, internalName);
-          if (c == null) return null;
-          return checkClassDefinition(internalName, c.superName, c.interfaces);
+          final ClassMetadata c = lookup.lookupRelatedClass(internalName, internalName);
+          return (c == null) ? null : visitAncestors(c, classRelationAncestorVisitor, false, false);
         case Type.ARRAY:
           type = type.getElementType();
           break;
@@ -212,9 +275,11 @@ private void reportClassViolation(String violation, String where) {
   
   @Override
   public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
-    this.internalMainClassName = name;
+    if (!Objects.equals(name, metadata.className)) {
+      throw new AssertionError("Wrong class parsed: " + name);
+    }
     this.isDeprecated = (access & Opcodes.ACC_DEPRECATED) != 0;
-    reportClassViolation(checkClassDefinition(name, superName, interfaces), "class declaration");
+    reportClassViolation(visitAncestors(metadata, classRelationAncestorVisitor, false, false), "class declaration");
     if (this.isDeprecated) {
       classSuppressed |= suppressAnnotations.matcher(DEPRECATED_TYPE.getClassName()).matches();
       reportClassViolation(checkType(DEPRECATED_TYPE), "deprecation on class declaration");
@@ -310,91 +375,101 @@ public MethodVisitor visitMethod(final int access, final String name, final Stri
           reportMethodViolation(checkType(DEPRECATED_TYPE), "deprecation on method declaration");
         }
       }
-      
-      private String checkMethodAccess(String owner, Method method) {
+            
+      private String checkMethodAccess(String owner, final Method method) {
+        if  (CLASS_CONSTRUCTOR_METHOD_NAME.equals(method.getName())) {
+          // we don't check for violations on class constructors
+          return null;
+        }
         String violation = checkClassUse(owner, "class/interface", owner);
         if (violation != null) {
           return violation;
         }
-        if  (CLASS_CONSTRUCTOR_METHOD_NAME.equals(method.getName())) {
-          // we don't check for violations on class constructors
-          return null;
+        // do a quick check that works without a ClassSignature (a more thorough check is done later):
+        violation = forbiddenSignatures.checkMethod(owner, method);
+        if (violation != null) {
+          return violation;
         }
-        return checkMethodAccessRecursion(owner, method, true, owner);
-      }
-      
-      private String checkMethodAccessRecursion(String owner, Method method, boolean checkClassUse, String origOwner) {
-        String printout = forbiddenSignatures.checkMethod(owner, method);
-        if (printout != null) {
-          return "Forbidden method invocation: " + printout;
+        if (CONSTRUCTOR_METHOD_NAME.equals(method.getName())) {
+          return null; // don't look into superclasses or interfaces to find constructors!
         }
-        final ClassSignature c = lookup.lookupRelatedClass(owner, origOwner);
-        if (c != null) {
-          if (c.signaturePolymorphicMethods.contains(method.getName())) {
-            // convert the invoked descriptor to a signature polymorphic one for the lookup
-            final Method lookupMethod = new Method(method.getName(), SIGNATURE_POLYMORPHIC_DESCRIPTOR);
-            printout = forbiddenSignatures.checkMethod(owner, lookupMethod);
-            if (printout != null) {
-              return "Forbidden method invocation: " + printout;
+        final ClassMetadata c = lookup.lookupRelatedClass(owner, owner);
+        if (c == null) {
+          return null;
+        }
+        return visitAncestors(c, new AncestorVisitor() {
+          @Override
+          public String visit(ClassMetadata c, String origName, boolean isInterfaceOfAncestor, boolean previousInRuntime) {
+            final Method lookupMethod;
+            if (c.signaturePolymorphicMethods.contains(method.getName())) {
+              // convert the invoked descriptor to a signature polymorphic one for the lookup
+              lookupMethod = new Method(method.getName(), SIGNATURE_POLYMORPHIC_DESCRIPTOR);
+            } else {
+              lookupMethod = method;
             }
-          }
-          String violation;
-          if (checkClassUse && c.methods.contains(method)) {
-            violation = checkClassUse(owner, "class/interface", origOwner);
+            if (!c.methods.contains(lookupMethod)) {
+              return null;
+            }
+            if (previousInRuntime && c.isNonPortableRuntime) {
+              return null; // something inside the JVM is extending internal class/interface
+            }
+            String violation = forbiddenSignatures.checkMethod(c.className, lookupMethod);
             if (violation != null) {
               return violation;
             }
-          }
-          if (CONSTRUCTOR_METHOD_NAME.equals(method.getName())) {
-            return null; // don't look into superclasses or interfaces to find constructors!
-          }
-          if (c.superName != null && (violation = checkMethodAccessRecursion(c.superName, method, true, origOwner)) != null) {
-            return violation;
-          }
-          // JVM spec says: interfaces after superclasses
-          if (c.interfaces != null) {
-            for (String intf : c.interfaces) {
-              // for interfaces we don't check the class use (it is too strict, if just the interface is implemented, but nothing more!):
-              if (intf != null && (violation = checkMethodAccessRecursion(intf, method, false, origOwner)) != null) {
+            // for interfaces we don't check the class use (it is too strict, if just the interface is implemented, but nothing more!):
+            if (!isInterfaceOfAncestor) {
+              violation = checkClassUse(c.className, "class", origName);
+              if (violation != null) {
                 return violation;
               }
             }
+            return null;
           }
-        }
-        return null;
-      }
-      
-      private String checkFieldAccess(String owner, String field) {
-        return checkFieldAccessRecursion(owner, field, owner);
+        }, true, false /* JVM spec says: interfaces after superclasses */);
       }
-      
-      private String checkFieldAccessRecursion(String owner, String field, String origOwner) {
-        String violation = checkClassUse(owner, "class/interface", origOwner);
+
+      private String checkFieldAccess(String owner, final String field) {
+        String violation = checkClassUse(owner, "class/interface", owner);
         if (violation != null) {
           return violation;
         }
-        final String printout = forbiddenSignatures.checkField(owner, field);
-        if (printout != null) {
-          return "Forbidden field access: " + printout;
+        // do a quick check that works without a ClassSignature (a more thorough check is done later):
+        violation = forbiddenSignatures.checkField(owner, field);
+        if (violation != null) {
+          return violation;
         }
-        final ClassSignature c = lookup.lookupRelatedClass(owner, origOwner);
-        // if we have seen the field already, no need to look into superclasses (fields cannot override)
-        if (c != null && !c.fields.contains(field)) {
-          if (c.interfaces != null) {
-            for (String intf : c.interfaces) {
-              if (intf != null && (violation = checkFieldAccessRecursion(intf, field, origOwner)) != null) {
+        final ClassMetadata c = lookup.lookupRelatedClass(owner, owner);
+        if (c == null) {
+          return null;
+        }
+        return visitAncestors(c, new AncestorVisitor() {
+          @Override
+          public String visit(ClassMetadata c, String origName, boolean isInterfaceOfAncestor, boolean previousInRuntime) {
+            if (!c.fields.contains(field)) {
+              return null;
+            }
+            // we found the field: from now on we use STOP to exit, because fields are not virtual!
+            if (previousInRuntime && c.isNonPortableRuntime) {
+              return STOP; // something inside the JVM is extending internal class/interface
+            }
+            String violation = forbiddenSignatures.checkField(c.className, field);
+            if (violation != null) {
+              return violation;
+            }
+            // for interfaces we don't check the class use (it is too strict, if just the interface is implemented, but nothing more!):
+            if (!isInterfaceOfAncestor) {
+              violation = checkClassUse(c.className, "class", origName);
+              if (violation != null) {
                 return violation;
               }
             }
+            // we found the field and as those are not virtual, there is no need to go up in class hierarchy:
+            return STOP;
           }
-          // JVM spec says: superclasses after interfaces
-          if (c.superName != null && (violation = checkFieldAccessRecursion(c.superName, field, origOwner)) != null) {
-            return violation;
-          }
-        }
-        return null;
+        }, true, true /* JVM spec says: superclasses after interfaces */);
       }
-
+      
       private String checkHandle(Handle handle, boolean checkLambdaHandle) {
         switch (handle.getTag()) {
           case Opcodes.H_GETFIELD:
@@ -408,7 +483,7 @@ private String checkHandle(Handle handle, boolean checkLambdaHandle) {
           case Opcodes.H_NEWINVOKESPECIAL:
           case Opcodes.H_INVOKEINTERFACE:
             final Method m = new Method(handle.getName(), handle.getDesc());
-            if (checkLambdaHandle && handle.getOwner().equals(internalMainClassName) && handle.getName().startsWith(LAMBDA_METHOD_NAME_PREFIX)) {
+            if (checkLambdaHandle && handle.getOwner().equals(metadata.className) && handle.getName().startsWith(LAMBDA_METHOD_NAME_PREFIX)) {
               // as described in <http://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html>,
               // we will record this metafactory call as "lambda" invokedynamic,
               // so we can assign the called lambda with the same groupId like *this* method:
diff --git a/src/main/java/de/thetaphi/forbiddenapis/RelatedClassLookup.java b/src/main/java/de/thetaphi/forbiddenapis/RelatedClassLookup.java
index 75c159c..d167b05 100644
--- a/src/main/java/de/thetaphi/forbiddenapis/RelatedClassLookup.java
+++ b/src/main/java/de/thetaphi/forbiddenapis/RelatedClassLookup.java
@@ -19,6 +19,6 @@
 import java.io.IOException;
 
 public interface RelatedClassLookup {
-  ClassSignature lookupRelatedClass(String internalName, String internalNameOrig);
-  ClassSignature getClassFromClassLoader(String clazz) throws ClassNotFoundException,IOException;
+  ClassMetadata lookupRelatedClass(String internalName, String internalNameOrig);
+  ClassMetadata getClassFromClassLoader(String clazz) throws ClassNotFoundException,IOException;
 }
diff --git a/src/main/java/de/thetaphi/forbiddenapis/Signatures.java b/src/main/java/de/thetaphi/forbiddenapis/Signatures.java
index 5c5e7e2..a6147f8 100644
--- a/src/main/java/de/thetaphi/forbiddenapis/Signatures.java
+++ b/src/main/java/de/thetaphi/forbiddenapis/Signatures.java
@@ -173,7 +173,7 @@ private void addSignature(final String line, final String defaultMessage, final
       }
       classPatterns.add(new ClassPatternRule(clazz, message));
     } else {
-      final ClassSignature c;
+      final ClassMetadata c;
       try {
         c = lookup.getClassFromClassLoader(clazz);
       } catch (ClassNotFoundException cnfe) {
@@ -345,29 +345,35 @@ public boolean isNonPortableRuntimeForbidden() {
     return this.forbidNonPortableRuntime;
   }
   
-  public String checkType(Type type) {
+  private static String formatTypePrintout(String printout, String what) {
+    return String.format(Locale.ENGLISH, "Forbidden %s use: %s", what, printout);
+  }
+  
+  public String checkType(Type type, String what) {
     if (type.getSort() != Type.OBJECT) {
       return null; // we don't know this type, just pass!
     }
     final String printout = signatures.get(getKey(type.getInternalName()));
     if (printout != null) {
-      return printout;
+      return formatTypePrintout(printout, what);
     }
     final String binaryClassName = type.getClassName();
     for (final ClassPatternRule r : classPatterns) {
       if (r.matches(binaryClassName)) {
-        return r.getPrintout(binaryClassName);
+        return formatTypePrintout(r.getPrintout(binaryClassName), what);
       }
     }
     return null;
   }
   
   public String checkMethod(String internalClassName, Method method) {
-    return signatures.get(getKey(internalClassName, method));
+    final String printout = signatures.get(getKey(internalClassName, method));
+    return (printout == null) ? null : "Forbidden method invocation: ".concat(printout);
   }
   
   public String checkField(String internalClassName, String field) {
-    return signatures.get(getKey(internalClassName, field));
+    final String printout = signatures.get(getKey(internalClassName, field));
+    return (printout == null) ? null : "Forbidden field access: ".concat(printout);
   }
   
   public static String fixTargetVersion(String name) throws ParseException {
diff --git a/src/test/java/de/thetaphi/forbiddenapis/CheckerSetupTest.java b/src/test/java/de/thetaphi/forbiddenapis/CheckerSetupTest.java
index 1b0dbca..8719e81 100644
--- a/src/test/java/de/thetaphi/forbiddenapis/CheckerSetupTest.java
+++ b/src/test/java/de/thetaphi/forbiddenapis/CheckerSetupTest.java
@@ -97,7 +97,7 @@ public void testEmptyCtor() throws Exception {
   @Test
   public void testRuntimeClassSignatures() throws Exception {
     String internalName = "java/lang/String";
-    ClassSignature cs = checker.lookupRelatedClass(internalName, internalName);
+    ClassMetadata cs = checker.lookupRelatedClass(internalName, internalName);
     assertTrue(cs.isRuntimeClass);
     assertTrue(cs.signaturePolymorphicMethods.isEmpty());
   }
@@ -105,7 +105,7 @@ public void testRuntimeClassSignatures() throws Exception {
   @Test
   public void testSignaturePolymorphic() throws Exception {
     String internalName = "java/lang/invoke/MethodHandle";
-    ClassSignature cs = checker.lookupRelatedClass(internalName, internalName);
+    ClassMetadata cs = checker.lookupRelatedClass(internalName, internalName);
     assertTrue(cs.signaturePolymorphicMethods.contains("invoke"));
     assertTrue(cs.signaturePolymorphicMethods.contains("invokeExact"));
     // System.out.println(cs.signaturePolymorphicMethods);