--- a/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java	Wed Jun 27 16:57:21 2018 -0700
+++ b/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java	Wed Jun 27 17:02:41 2018 -0700
@@ -51,6 +51,8 @@
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.meta.UnresolvedJavaField;
+import jdk.vm.ci.meta.UnresolvedJavaType;
 
 /**
  * Implementation of {@link JavaType} for resolved non-primitive HotSpot classes.
@@ -296,6 +298,7 @@
         return compilerToVM().getImplementor(this);
     }
 
+    @Override
     public HotSpotResolvedObjectTypeImpl getSupertype() {
         if (isArray()) {
             ResolvedJavaType componentType = getComponentType();
@@ -355,6 +358,11 @@
     }
 
     @Override
+    public boolean isEnum() {
+        return mirror().isEnum();
+    }
+
+    @Override
     public boolean isInitialized() {
         return isArray() ? true : getInitState() == config().instanceKlassStateFullyInitialized;
     }
@@ -447,6 +455,7 @@
         return compilerToVM().resolveMethod(this, hotSpotMethod, hotSpotCallerType);
     }
 
+    @Override
     public HotSpotConstantPool getConstantPool() {
         if (constantPool == null || !isArray() && UNSAFE.getAddress(getMetaspaceKlass() + config().instanceKlassConstantsOffset) != constantPool.getMetaspaceConstantPool()) {
             /*
@@ -465,6 +474,7 @@
      * allocated, then the returned value is negative (its absolute value gives the size). Must not
      * be called if this is an array or interface type.
      */
+    @Override
     public int instanceSize() {
         assert !isArray();
         assert !isInterface();
@@ -482,6 +492,7 @@
         return needsSlowPath ? -size : size;
     }
 
+    @Override
     public int layoutHelper() {
         HotSpotVMConfig config = config();
         return UNSAFE.getInt(getMetaspaceKlass() + config.klassLayoutHelperOffset);
@@ -527,6 +538,7 @@
         }
     }
 
+    @Override
     public int getVtableLength() {
         HotSpotVMConfig config = config();
         if (isInterface() || isArray()) {
@@ -752,7 +764,7 @@
 
                 // Make sure the result is sorted by offset.
                 int j;
-                for (j = resultIndex - 1; j >= prependLength && result[j].offset() > offset; j--) {
+                for (j = resultIndex - 1; j >= prependLength && result[j].getOffset() > offset; j--) {
                     result[j + 1] = result[j];
                 }
                 result[j + 1] = resolvedJavaField;
@@ -800,6 +812,7 @@
      * {@linkplain HotSpotJVMCIRuntime#lookupType(String, HotSpotResolvedObjectType, boolean)
      * re-resolving} the type.
      */
+    @Override
     public boolean isDefinitelyResolvedWithRespectTo(ResolvedJavaType accessingClass) {
         assert accessingClass != null;
         ResolvedJavaType elementType = getElementalType();
@@ -829,19 +842,23 @@
     /**
      * Gets the metaspace Klass boxed in a {@link JavaConstant}.
      */
+    @Override
     public Constant klass() {
         return HotSpotMetaspaceConstantImpl.forMetaspaceObject(this, false);
     }
 
+    @Override
     public boolean isPrimaryType() {
         return config().secondarySuperCacheOffset != superCheckOffset();
     }
 
+    @Override
     public int superCheckOffset() {
         HotSpotVMConfig config = config();
         return UNSAFE.getInt(getMetaspaceKlass() + config.superCheckOffsetOffset);
     }
 
+    @Override
     public long prototypeMarkWord() {
         HotSpotVMConfig config = config();
         if (isArray()) {
@@ -865,7 +882,7 @@
     private static ResolvedJavaField findFieldWithOffset(long offset, JavaKind expectedEntryKind, ResolvedJavaField[] declaredFields) {
         for (ResolvedJavaField field : declaredFields) {
             HotSpotResolvedJavaField resolvedField = (HotSpotResolvedJavaField) field;
-            long resolvedFieldOffset = resolvedField.offset();
+            long resolvedFieldOffset = resolvedField.getOffset();
             // @formatter:off
             if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN  &&
                             expectedEntryKind.isPrimitive() &&
@@ -921,6 +938,7 @@
         return result;
     }
 
+    @Override
     public ResolvedJavaMethod getClassInitializer() {
         if (!isArray()) {
             return compilerToVM().getClassInitializer(this);
@@ -934,6 +952,30 @@
     }
 
     @Override
+    public ResolvedJavaType lookupType(UnresolvedJavaType unresolvedJavaType, boolean resolve) {
+        JavaType javaType = HotSpotJVMCIRuntime.runtime().lookupType(unresolvedJavaType.getName(), this, resolve);
+        if (javaType instanceof ResolvedJavaType) {
+            return (ResolvedJavaType) javaType;
+        }
+        return null;
+    }
+
+    @Override
+    public ResolvedJavaField resolveField(UnresolvedJavaField unresolvedJavaField, ResolvedJavaType accessingClass) {
+        for (ResolvedJavaField field : getInstanceFields(false)) {
+            if (field.getName().equals(unresolvedJavaField.getName())) {
+                return field;
+            }
+        }
+        for (ResolvedJavaField field : getStaticFields()) {
+            if (field.getName().equals(unresolvedJavaField.getName())) {
+                return field;
+            }
+        }
+        throw new InternalError(unresolvedJavaField.toString());
+    }
+
+    @Override
     public boolean isCloneableWithAllocation() {
         return (getAccessFlags() & config().jvmAccIsCloneableFast) != 0;
     }