--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/Assumptions.java	Sat May 17 14:56:13 2014 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/Assumptions.java	Sat May 17 14:58:33 2014 +0200
@@ -96,7 +96,8 @@
         public ConcreteSubtype(ResolvedJavaType context, ResolvedJavaType subtype) {
             this.context = context;
             this.subtype = subtype;
-            assert !subtype.isInterface() : subtype.toString() + " : " + context.toString();
+            assert !subtype.isAbstract() : subtype.toString() + " : " + context.toString();
+            assert !subtype.isArray() || getElementalType(subtype).isFinal() : subtype.toString() + " : " + context.toString();
         }
 
         @Override
@@ -264,7 +265,7 @@
 
     /**
      * Returns whether any assumptions have been registered.
-     * 
+     *
      * @return {@code true} if at least one assumption has been registered, {@code false} otherwise.
      */
     public boolean isEmpty() {
@@ -303,7 +304,7 @@
 
     /**
      * Records an assumption that the specified type has no finalizable subclasses.
-     * 
+     *
      * @param receiverType the type that is assumed to have no finalizable subclasses
      */
     public void recordNoFinalizableSubclassAssumption(ResolvedJavaType receiverType) {
@@ -314,7 +315,7 @@
     /**
      * Records that {@code subtype} is the only concrete subtype in the class hierarchy below
      * {@code context}.
-     * 
+     *
      * @param context the root of the subtree of the class hierarchy that this assumptions is about
      * @param subtype the one concrete subtype
      */
@@ -326,7 +327,7 @@
     /**
      * Records that {@code impl} is the only possible concrete target for a virtual call to
      * {@code method} with a receiver of type {@code context}.
-     * 
+     *
      * @param method a method that is the target of a virtual call
      * @param context the receiver type of a call to {@code method}
      * @param impl the concrete method that is the only possible target for the virtual call
@@ -338,7 +339,7 @@
 
     /**
      * Records that {@code method} was used during the compilation.
-     * 
+     *
      * @param method a method whose contents were used
      */
     public void recordMethodContents(ResolvedJavaMethod method) {

--- a/graal/com.oracle.graal.api.meta.test/src/com/oracle/graal/api/meta/test/TestResolvedJavaType.java	Sat May 17 14:56:13 2014 +0200
+++ b/graal/com.oracle.graal.api.meta.test/src/com/oracle/graal/api/meta/test/TestResolvedJavaType.java	Sat May 17 14:58:33 2014 +0200
@@ -265,10 +265,13 @@
     static class Concrete3 extends Concrete2 {
     }
 
+    static final class Final1 extends Abstract1 {
+    }
+
     abstract static class Abstract4 extends Concrete3 {
     }
 
-    void checkConcreteSubtype(ResolvedJavaType type, Class<?> expected) {
+    void checkConcreteSubtype(ResolvedJavaType type, ResolvedJavaType expected) {
         ResolvedJavaType subtype = type.findUniqueConcreteSubtype();
         if (subtype == null) {
             // findUniqueConcreteSubtype() is conservative
@@ -276,7 +279,7 @@
             if (expected == null) {
                 assertNull(subtype);
             } else {
-                assertTrue(subtype.equals(metaAccess.lookupJavaType(expected)));
+                assertTrue(subtype.equals(expected));
             }
         }
 
@@ -294,31 +297,44 @@
     @Test
     public void findUniqueConcreteSubtypeTest() {
         ResolvedJavaType base = metaAccess.lookupJavaType(Base.class);
-        checkConcreteSubtype(base, Base.class);
+        checkConcreteSubtype(base, base);
 
         ResolvedJavaType a1 = metaAccess.lookupJavaType(Abstract1.class);
         ResolvedJavaType c1 = metaAccess.lookupJavaType(Concrete1.class);
 
         checkConcreteSubtype(base, null);
-        checkConcreteSubtype(a1, Concrete1.class);
-        checkConcreteSubtype(c1, Concrete1.class);
+        checkConcreteSubtype(a1, c1);
+        checkConcreteSubtype(c1, c1);
 
         ResolvedJavaType i1 = metaAccess.lookupJavaType(Interface1.class);
         ResolvedJavaType c2 = metaAccess.lookupJavaType(Concrete2.class);
 
         checkConcreteSubtype(base, null);
         checkConcreteSubtype(a1, null);
-        checkConcreteSubtype(c1, Concrete1.class);
-        checkConcreteSubtype(i1, Concrete2.class);
-        checkConcreteSubtype(c2, Concrete2.class);
+        checkConcreteSubtype(c1, c1);
+        checkConcreteSubtype(i1, c2);
+        checkConcreteSubtype(c2, c2);
 
         ResolvedJavaType c3 = metaAccess.lookupJavaType(Concrete3.class);
         checkConcreteSubtype(c2, null);
-        checkConcreteSubtype(c3, Concrete3.class);
+        checkConcreteSubtype(c3, c3);
 
         ResolvedJavaType a4 = metaAccess.lookupJavaType(Abstract4.class);
         checkConcreteSubtype(c3, null);
         checkConcreteSubtype(a4, null);
+
+        ResolvedJavaType a1a = metaAccess.lookupJavaType(Abstract1[].class);
+        checkConcreteSubtype(a1a, null);
+        ResolvedJavaType c1a = metaAccess.lookupJavaType(Concrete1[].class);
+        checkConcreteSubtype(c1a, null);
+        ResolvedJavaType f1a = metaAccess.lookupJavaType(Final1[].class);
+        checkConcreteSubtype(f1a, f1a);
+
+        ResolvedJavaType obja = metaAccess.lookupJavaType(Object[].class);
+        checkConcreteSubtype(obja, null);
+
+        ResolvedJavaType inta = metaAccess.lookupJavaType(int[].class);
+        checkConcreteSubtype(inta, inta);
     }
 
     @Test