--- a/graal/com.oracle.graal.api.meta.test/src/com/oracle/graal/api/meta/test/ResolvedJavaTypeResolveMethodTest.java	Fri Jul 11 16:48:59 2014 +0200
+++ b/graal/com.oracle.graal.api.meta.test/src/com/oracle/graal/api/meta/test/ResolvedJavaTypeResolveMethodTest.java	Fri Jul 11 17:54:57 2014 +0200
@@ -156,7 +156,7 @@
 
     }
 
-    private static ResolvedJavaMethod getMethod(ResolvedJavaType type, String methodName) {
+    static ResolvedJavaMethod getMethod(ResolvedJavaType type, String methodName) {
         for (ResolvedJavaMethod method : type.getDeclaredMethods()) {
             if (method.getName().equals(methodName)) {
                 return method;

--- a/graal/com.oracle.graal.api.meta.test/src/com/oracle/graal/api/meta/test/TestJavaType.java	Fri Jul 11 16:48:59 2014 +0200
+++ b/graal/com.oracle.graal.api.meta.test/src/com/oracle/graal/api/meta/test/TestJavaType.java	Fri Jul 11 17:54:57 2014 +0200
@@ -24,6 +24,11 @@
 
 import static org.junit.Assert.*;
 
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.util.stream.*;
+
 import org.junit.*;
 
 import com.oracle.graal.api.meta.*;
@@ -45,4 +50,91 @@
             assertEquals(expected, actual);
         }
     }
+
+    static class A {
+        A or(A other) {
+            return other;
+        }
+    }
+
+    @Test
+    public void testResolve() throws ClassNotFoundException {
+        String classPath = System.getProperty("java.class.path");
+        String[] parts = classPath.split(File.pathSeparator);
+        URL[] urls = Arrays.asList(parts).stream().map(e -> asURL(e)).collect(Collectors.toList()).toArray(new URL[parts.length]);
+        URLClassLoader clOne = newClassLoader(urls);
+        URLClassLoader clTwo = newClassLoader(urls);
+
+        String className = getClass().getName() + "$A";
+        Class<?> aClassOne = Class.forName(className, true, clOne);
+        Class<?> aClassTwo = Class.forName(getClass().getName() + "$A", true, clTwo);
+
+        assertNotEquals(aClassOne, aClassTwo);
+        assertNotEquals(aClassOne.getClassLoader(), aClassTwo.getClassLoader());
+
+        ResolvedJavaType aTypeOne = metaAccess.lookupJavaType(aClassOne);
+        ResolvedJavaType aTypeTwo = metaAccess.lookupJavaType(aClassTwo);
+
+        assertNotEquals(aTypeOne, aTypeTwo);
+
+        checkResolveWithoutAccessingClass(aTypeOne);
+        checkResolveWithoutAccessingClass(aTypeTwo);
+
+        assertEquals(aTypeOne.resolve(aTypeOne), aTypeOne);
+        assertNotEquals(aTypeOne.resolve(aTypeTwo), aTypeOne);
+        assertEquals(aTypeOne.resolve(aTypeTwo), aTypeTwo);
+
+        assertEquals(aTypeTwo.resolve(aTypeTwo), aTypeTwo);
+        assertNotEquals(aTypeTwo.resolve(aTypeOne), aTypeTwo);
+        assertEquals(aTypeTwo.resolve(aTypeOne), aTypeOne);
+
+        ResolvedJavaMethod m = ResolvedJavaTypeResolveMethodTest.getMethod(aTypeOne, "or");
+        JavaType resolvedTypeOne = m.getSignature().getParameterType(0, aTypeOne);
+        JavaType resolvedTypeTwo = m.getSignature().getReturnType(aTypeOne);
+        JavaType unresolvedTypeOne = m.getSignature().getParameterType(0, null);
+        JavaType unresolvedTypeTwo = m.getSignature().getReturnType(null);
+
+        assertTrue(resolvedTypeOne instanceof ResolvedJavaType);
+        assertTrue(resolvedTypeTwo instanceof ResolvedJavaType);
+        assertFalse(unresolvedTypeOne instanceof ResolvedJavaType);
+        assertFalse(unresolvedTypeTwo instanceof ResolvedJavaType);
+
+        assertEquals(resolvedTypeOne.resolve(aTypeOne), aTypeOne);
+        assertEquals(resolvedTypeOne.resolve(aTypeTwo), aTypeTwo);
+        assertEquals(resolvedTypeTwo.resolve(aTypeOne), aTypeOne);
+        assertEquals(resolvedTypeTwo.resolve(aTypeTwo), aTypeTwo);
+
+        checkResolveWithoutAccessingClass(unresolvedTypeOne);
+        checkResolveWithoutAccessingClass(unresolvedTypeTwo);
+
+        assertEquals(unresolvedTypeOne.resolve(aTypeOne), aTypeOne);
+        assertEquals(unresolvedTypeOne.resolve(aTypeTwo), aTypeTwo);
+    }
+
+    private static void checkResolveWithoutAccessingClass(JavaType type) {
+        try {
+            type.resolve(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+    }
+
+    private static URLClassLoader newClassLoader(URL[] urls) {
+        URLClassLoader cl = new URLClassLoader(urls) {
+            @Override
+            protected java.lang.Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+                boolean callSuper = name.startsWith("java/") || name.startsWith("java.");
+                return callSuper ? super.loadClass(name, resolve) : super.findClass(name);
+            }
+        };
+        return cl;
+    }
+
+    private static URL asURL(String e) {
+        try {
+            return new File(e).toURI().toURL();
+        } catch (MalformedURLException e1) {
+            throw new RuntimeException(e1);
+        }
+    }
 }

--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotGraalRuntime.java	Fri Jul 11 16:48:59 2014 +0200
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotGraalRuntime.java	Fri Jul 11 17:54:57 2014 +0200
@@ -380,11 +380,10 @@
      * @return a Java type for {@code name} which is guaranteed to be of type
      *         {@link ResolvedJavaType} if {@code resolve == true}
      * @throws LinkageError if {@code resolve == true} and the resolution failed
+     * @throws NullPointerException if {@code accessingClass} is {@code null}
      */
     public JavaType lookupType(String name, HotSpotResolvedObjectType accessingType, boolean resolve) {
-        if (accessingType == null) {
-            throw new GraalInternalError("cannot resolve " + name + " without an accessing class");
-        }
+        Objects.requireNonNull(accessingType, "cannot resolve type without an accessing class");
         // If the name represents a primitive type we can short-circuit the lookup.
         if (name.length() == 1) {
             Kind kind = Kind.fromPrimitiveOrVoidTypeChar(name.charAt(0));
@@ -392,7 +391,7 @@
         }
 
         // Resolve non-primitive types in the VM.
-        final long metaspaceKlass = compilerToVm.lookupType(name, accessingType != null ? accessingType.mirror() : null, resolve);
+        final long metaspaceKlass = compilerToVm.lookupType(name, accessingType.mirror(), resolve);
 
         if (metaspaceKlass == 0L) {
             assert resolve == false;