Remove locationForType(), it was only used in tests

Author: eregon

truffle/src/com.oracle.truffle.api.object.test/src/com/oracle/truffle/object/basic/test/DOTestAsserts.java

@@ -214,7 +214,7 @@ public static Assumption getTypeAssumption(Location location) {
         return invokeGetter("getAssumption", getTypeAssumptionRecord(location));
     }
 
-    public static Location locationForType(Shape shape, Class<?> valueType) {
-        return invokeMethod("locationForType", invokeGetter("allocator", shape), valueType);
+    public static Location locationForValue(Shape shape, Object value) {
+        return invokeMethod("locationForValue", invokeGetter("allocator", shape), value);
     }
 }

truffle/src/com.oracle.truffle.api.object.test/src/com/oracle/truffle/object/basic/test/LocationTest.java

@@ -217,8 +217,8 @@ public void testDelete() {
     @Test
     public void testLocationDecoratorEquals() {
         var allocator = invokeGetter("allocator", rootShape);
-        Location intLocation1 = invokeMethod("locationForType", allocator, int.class);
-        Location intLocation2 = invokeMethod("locationForType", allocator, int.class);
+        Location intLocation1 = invokeMethod("locationForValue", allocator, 42);
+        Location intLocation2 = invokeMethod("locationForValue", allocator, 43);
         assertEquals(intLocation1.getClass(), intLocation2.getClass());
         Assert.assertNotEquals(intLocation1, intLocation2);
     }
@@ -241,14 +241,14 @@ public void testDeleteDeclaredProperty() {
     public void testLocationIsPrimitive() {
         var allocator = invokeGetter("allocator", rootShape);
 
-        Location objectLocation = invokeMethod("locationForType", allocator, Object.class);
+        Location objectLocation = invokeMethod("locationForValue", allocator, new Object());
         assertFalse(objectLocation.isPrimitive());
 
-        Location intLocation = invokeMethod("locationForType", allocator, int.class);
+        Location intLocation = invokeMethod("locationForValue", allocator, 42);
         assertTrue(intLocation.isPrimitive());
-        Location doubleLocation = invokeMethod("locationForType", allocator, double.class);
+        Location doubleLocation = invokeMethod("locationForValue", allocator, 3.14);
         assertTrue(doubleLocation.isPrimitive());
-        Location longLocation = invokeMethod("locationForType", allocator, long.class);
+        Location longLocation = invokeMethod("locationForValue", allocator, 43L);
         assertTrue(longLocation.isPrimitive());
 
         Location constantLocation = invokeMethod("constantLocation", allocator, "constantValue");

truffle/src/com.oracle.truffle.api.object.test/src/com/oracle/truffle/object/basic/test/ShapeTest.java

@@ -41,7 +41,7 @@
 package com.oracle.truffle.object.basic.test;
 
 import static com.oracle.truffle.object.basic.test.DOTestAsserts.invokeMethod;
-import static com.oracle.truffle.object.basic.test.DOTestAsserts.locationForType;
+import static com.oracle.truffle.object.basic.test.DOTestAsserts.locationForValue;
 
 import java.lang.invoke.MethodHandles;
 import java.util.Arrays;
@@ -97,11 +97,11 @@ public void testToString() {
                         "\"b\":Object@1",
                         "\"a\":Object@0"}, aIntBObj);
 
-        Location boolLocation = locationForType(rootShape, boolean.class);
+        Location boolLocation = locationForValue(rootShape, true);
         Shape bool = invokeMethod("addProperty", rootShape, Property.create("bool", boolLocation, 0));
         DOTestAsserts.assertShape(new String[]{"\"bool\":Object@0"}, bool);
 
-        Location strLocation = locationForType(rootShape, String.class);
+        Location strLocation = locationForValue(rootShape, "");
         Shape str = invokeMethod("addProperty", rootShape, Property.create("str", strLocation, 0));
         DOTestAsserts.assertShape(new String[]{"\"str\":Object@0"}, str);
 

truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/BaseAllocator.java

@@ -96,15 +96,6 @@ public Location declaredLocation(Object value) {
 
     protected abstract Location locationForValueUpcast(Object value, Location oldLocation, int putFlags);
 
-    /**
-     * Creates a new location for a fixed type. It can only be assigned to values of this type.
-     * <p>
-     * Used by tests.
-     *
-     * @param type the Java type this location must be compatible with (may be primitive)
-     */
-    public abstract Location locationForType(Class<?> type);
-
     protected <T extends Location> T advance(T location0) {
         if (location0 instanceof LocationImpl location) {
             location.accept(this);

truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/ExtAllocator.java

@@ -111,10 +111,6 @@ protected Location moveLocation(Location oldLocation) {
         return advance(oldLocation);
     }
 
-    public Location newObjectLocation() {
-        return newObjectLocation(false, null, NO_VALUE);
-    }
-
     private Location newObjectLocation(boolean decorateFinal, Location oldLocation, Object value) {
         if (InObjectFields) {
             LayoutImpl l = getLayout();
@@ -138,33 +134,6 @@ private Location newObjectArrayLocation(boolean decorateFinal, Location oldLocat
         return advance(location);
     }
 
-    private Location newTypedObjectLocation(Class<?> type, boolean nonNull, boolean decorateFinal, Location oldLocation, Object value) {
-        if (InObjectFields) {
-            LayoutImpl l = getLayout();
-            int insertPos = objectFieldSize;
-            if (insertPos + OBJECT_SLOT_SIZE <= l.getObjectFieldCount()) {
-                FieldInfo fieldInfo = l.getObjectField(insertPos);
-                TypeAssumption initialTypeAssumption = getTypeAssumptionForTypeOrValue(type, nonNull, oldLocation, value);
-                Assumption initialFinalAssumption = getFinalAssumption(oldLocation, decorateFinal);
-                LocationImpl location = newObjectFieldLocationWithAssumption(insertPos, fieldInfo, initialTypeAssumption, initialFinalAssumption);
-                return advance(location);
-            }
-        }
-        return newTypedObjectArrayLocation(type, nonNull, decorateFinal, oldLocation, value);
-    }
-
-    private Location newTypedObjectArrayLocation(Class<?> type, boolean nonNull, boolean decorateFinal, Location oldLocation, Object value) {
-        if (type != Object.class) {
-            int index = objectArraySize;
-            TypeAssumption initialTypeAssumption = getTypeAssumptionForTypeOrValue(type, nonNull, oldLocation, value);
-            Assumption initialFinalAssumption = getFinalAssumption(oldLocation, decorateFinal);
-            LocationImpl location = newObjectArrayLocationWithAssumption(index, initialTypeAssumption, initialFinalAssumption);
-            return advance(location);
-        } else {
-            return newObjectArrayLocation(decorateFinal, oldLocation, value);
-        }
-    }
-
     private static ObjectFieldLocation newObjectFieldLocationWithAssumption(int index, FieldInfo fieldInfo,
                     TypeAssumption initialTypeAssumption, Assumption initialFinalAssumption) {
         return new ObjectFieldLocation(index, fieldInfo, initialFinalAssumption, initialTypeAssumption);
@@ -193,17 +162,6 @@ private static TypeAssumption getTypeAssumption(Location oldLocation, Object val
         return TypeAssumption.ANY;
     }
 
-    private static TypeAssumption getTypeAssumptionForTypeOrValue(Class<?> type, boolean nonNull, Location oldLocation, Object value) {
-        if (!NewTypeSpeculation && !NewFinalSpeculation && value == NO_VALUE) {
-            if (oldLocation instanceof AbstractObjectLocation) {
-                return ((AbstractObjectLocation) oldLocation).getTypeAssumption();
-            }
-            return AbstractObjectLocation.createTypeAssumption(type, nonNull);
-        } else {
-            return getTypeAssumption(oldLocation, value);
-        }
-    }
-
     private static Assumption getFinalAssumption(Location oldLocation, boolean allowFinalSpeculation) {
         if (NewFinalSpeculation && allowFinalSpeculation) {
             if (oldLocation == null) {
@@ -223,10 +181,6 @@ private static int tryAllocatePrimitiveSlot(LayoutImpl l, int startIndex, final
         return startIndex < l.getPrimitiveFieldCount() ? startIndex : -1;
     }
 
-    private Location newIntLocation() {
-        return newIntLocation(false, null, NO_VALUE);
-    }
-
     private Location newIntLocation(boolean decorateFinal, Location oldLocation, Object value) {
         if (PrimitiveLocations && IntegerLocations) {
             LayoutImpl l = getLayout();
@@ -249,10 +203,6 @@ private Location newIntLocation(boolean decorateFinal, Location oldLocation, Obj
         return newObjectLocation(decorateFinal, oldLocation, value);
     }
 
-    private Location newDoubleLocation() {
-        return newDoubleLocation(false, getLayout().isAllowedIntToDouble(), null, NO_VALUE);
-    }
-
     private Location newDoubleLocation(boolean decorateFinal, boolean allowIntToDouble, Location oldLocation, Object value) {
         if (PrimitiveLocations && DoubleLocations) {
             LayoutImpl l = getLayout();
@@ -293,10 +243,6 @@ private static int alignArrayIndex(int index, int slotSize) {
         }
     }
 
-    private Location newLongLocation() {
-        return newLongLocation(false, getLayout().isAllowedIntToLong(), null, NO_VALUE);
-    }
-
     private Location newLongLocation(boolean decorateFinal, boolean allowIntToLong, Location oldLocation, Object value) {
         if (PrimitiveLocations && LongLocations) {
             LayoutImpl l = getLayout();
@@ -371,23 +317,6 @@ Location locationForValue(Object value, int putFlags) {
         return newObjectLocation(decorateFinal, null, value);
     }
 
-    @Override
-    public Location locationForType(Class<?> type) {
-        if (type == int.class) {
-            return newIntLocation();
-        } else if (type == double.class) {
-            return newDoubleLocation();
-        } else if (type == long.class) {
-            return newLongLocation();
-        } else if (type == boolean.class) {
-            return locationForValue(true);
-        } else if (type != null && type != Object.class) {
-            assert !type.isPrimitive() : "unsupported primitive type";
-            return newTypedObjectLocation(type, false, false, null, NO_VALUE);
-        }
-        return newObjectLocation();
-    }
-
     static Class<?> getCommonSuperclass(Class<?> a, Class<?> b) {
         Class<?> type = a;
         while (type != Object.class) {