Ensure inferPreciseType returns a local StorageType.

Add a temporary makeLocalStorage method until JavaProblems is rewritten.

Author: jdunkerley

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/In_Memory_Column_Implementation.enso

@@ -632,7 +632,7 @@ type In_Memory_Column_Implementation
         Vector.from_polyglot_array column_as_list . map java_to_enso
 
     value_type (this_column : Column & In_Memory_Column) =
-        storage_type = this_column.java_column.getType
+        storage_type = CastOperation.makeLocalType this_column.java_column.getType
         Storage.to_value_type storage_type
 
     inferred_precise_value_type (this_column : Column & In_Memory_Column) =

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Java_Problems.enso

@@ -11,6 +11,7 @@ from project.Internal.Storage import java_to_enso
 
 polyglot java import org.enso.table.data.column.builder.LossOfBigDecimalPrecision
 polyglot java import org.enso.table.data.column.builder.LossOfIntegerPrecision
+polyglot java import org.enso.table.data.column.operation.cast.CastOperation
 polyglot java import org.enso.table.data.column.operation.cast.ConversionFailure
 polyglot java import org.enso.table.data.column.operation.cast.ConversionFailureType
 polyglot java import org.enso.table.data.table.problems.ArithmeticError
@@ -56,14 +57,16 @@ translate_problem p = case p.problemType of
     "LossOfBigDecimalPrecision" ->
         Loss_Of_Decimal_Precision.Warning p.getAffectedRowsCount (java_to_enso p.getExampleValue) p.getExampleValueConverted
     "ArithmeticOverflow" ->
-        target_type = Storage.to_value_type p.targetType
+        storage_type = CastOperation.makeLocalType p.target_type
+        target_type = Storage.to_value_type storage_type
         example_operands = case p.exampleOperands of
             Nothing -> Nothing
             array -> Vector.from_polyglot_array array
         Arithmetic_Overflow.Warning target_type p.affectedRowCount example_operands
     "ConversionFailure" ->
         examples = Vector.from_polyglot_array p.examples
-        target_type = Storage.to_value_type p.targetType
+        storage_type = CastOperation.makeLocalType p.target_type
+        target_type = Storage.to_value_type storage_type
         related_column = p.relatedColumn
         affected_rows_count = p.affectedRowCount
         constructor = if p.errorType == ConversionFailureType.NUMBER_OUT_OF_RANGE then Conversion_Failure.Out_Of_Range else

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Storage.enso

@@ -30,7 +30,7 @@ polyglot java import org.enso.table.problems.ProblemAggregator
    ---
    Gets the value type represented by this Java Storage.
 to_value_type : StorageType -> Value_Type
-to_value_type storage_type = case (StorageType.makeLocal storage_type) of
+to_value_type storage_type = case storage_type of
     i : IntegerType -> case i.size of
         8 -> Value_Type.Byte
         b -> Value_Type.Integer (Bits.from_integer b)

std-bits/table/src/main/java/org/enso/table/data/column/operation/cast/CastOperation.java

@@ -40,23 +40,28 @@ public static Column apply(
   /** Construct a StorageConverter for the given target type. */
   private static StorageConverter<?> fromStorageType(StorageType<?> storageType) {
     return switch (StorageType.makeLocal(storageType)) {
-      case AnyObjectType anyObjectType -> new ToMixedStorageConverter();
-      case BooleanType booleanType -> new ToBooleanStorageConverter();
-      case DateType dateType -> new ToDateStorageConverter();
-      case DateTimeType dateTimeType -> new ToDateTimeStorageConverter();
+      case AnyObjectType _ -> new ToMixedStorageConverter();
+      case BooleanType _ -> new ToBooleanStorageConverter();
+      case DateType _ -> new ToDateStorageConverter();
+      case DateTimeType _ -> new ToDateTimeStorageConverter();
       case FloatType floatType -> new ToFloatStorageConverter(floatType);
       case IntegerType integerType -> new ToIntegerStorageConverter(integerType);
       case TextType textType -> new ToTextStorageConverter(textType);
-      case TimeOfDayType timeOfDayType -> new ToTimeOfDayStorageConverter();
-      case BigIntegerType bigIntegerType -> new ToBigIntegerConverter();
-      case BigDecimalType bigDecimalType -> new ToBigDecimalConverter();
-      case NullType nullType -> throw new IllegalArgumentException("Cannot cast to Null type.");
+      case TimeOfDayType _ -> new ToTimeOfDayStorageConverter();
+      case BigIntegerType _ -> new ToBigIntegerConverter();
+      case BigDecimalType _ -> new ToBigDecimalConverter();
+      case NullType _ -> throw new IllegalArgumentException("Cannot cast to Null type.");
       default ->
           throw new IllegalStateException(
               "Unsupported type: " + storageType + " - this is a bug in the Table library.");
     };
   }
 
+  /** Helper method until Java Problems code in Enso is re-visited. */
+  public static StorageType<?> makeLocalType(StorageType<?> type) {
+    return StorageType.makeLocal(type);
+  }
+
   public static StorageType<?> inferPreciseType(Column column) {
     return inferPreciseType(column, PreciseTypeOptions.DEFAULT);
   }
@@ -65,13 +70,14 @@ public static StorageType<?> inferPreciseType(Column column, PreciseTypeOptions
     var columnStorage = column.getStorage();
     var storage = ColumnStorageWithInferredStorage.resolveStorage(columnStorage);
 
-    return switch (storage.getType()) {
-      case TextType textType -> inferTextType(storage, options);
-      case IntegerType integerType -> inferIntegerType(storage, options);
-      case FloatType floatType -> inferFloatType(storage, options);
-      case BigIntegerType bigIntegerType -> inferBigIntegerType(storage, options);
-      case BigDecimalType bigDecimalType -> inferBigDecimalType(storage, options);
-      default -> storage.getType();
+    var storageType = StorageType.makeLocal(storage.getType());
+    return switch (storageType) {
+      case TextType textType -> inferTextType(storage, textType, options);
+      case IntegerType integerType -> inferIntegerType(storage, integerType, options);
+      case FloatType floatType -> inferFloatType(storage, floatType, options);
+      case BigIntegerType bigIntegerType -> inferBigIntegerType(storage, bigIntegerType, options);
+      case BigDecimalType bigDecimalType -> inferBigDecimalType(storage, bigDecimalType, options);
+      default -> storageType;
     };
   }
 
@@ -104,17 +110,8 @@ public long getMinLength() {
   }
 
   private static StorageType<?> inferTextType(
-      ColumnStorage<?> columnStorage, PreciseTypeOptions options) {
-    if (!options.shrinkText()) {
-      return columnStorage.getType();
-    }
-
-    if (!(columnStorage.getType() instanceof TextType textType)) {
-      throw new IllegalArgumentException(
-          "Cannot infer text type from non-text storage: " + columnStorage.getType());
-    }
-
-    if (textType.fixedLength()) {
+      ColumnStorage<?> columnStorage, TextType textType, PreciseTypeOptions options) {
+    if (!options.shrinkText() || textType.fixedLength()) {
       return textType;
     }
 
@@ -180,14 +177,9 @@ public IntegerType resolveType() {
   }
 
   private static StorageType<?> inferIntegerType(
-      ColumnStorage<?> columnStorage, PreciseTypeOptions options) {
+      ColumnStorage<?> columnStorage, IntegerType integerType, PreciseTypeOptions options) {
     if (!options.shrinkIntegers()) {
-      return columnStorage.getType();
-    }
-
-    if (!(columnStorage.getType() instanceof IntegerType integerType)) {
-      throw new IllegalArgumentException(
-          "Cannot infer integer type from non-integer storage: " + columnStorage.getType());
+      return integerType;
     }
 
     if (integerType.size() <= 16) {
@@ -206,12 +198,7 @@ private static StorageType<?> inferIntegerType(
   }
 
   private static StorageType<?> inferBigIntegerType(
-      ColumnStorage<?> columnStorage, PreciseTypeOptions options) {
-    if (!(columnStorage.getType() instanceof BigIntegerType bigIntegerType)) {
-      throw new IllegalArgumentException(
-          "Cannot infer integer type from non-integer storage: " + columnStorage.getType());
-    }
-
+      ColumnStorage<?> columnStorage, BigIntegerType bigIntegerType, PreciseTypeOptions options) {
     // Build the min and max of values in the column.
     var accumulator = new LongAccumulator();
     var endedEarly =
@@ -239,14 +226,9 @@ private static StorageType<?> inferBigIntegerType(
   }
 
   private static StorageType<?> inferFloatType(
-      ColumnStorage<?> columnStorage, PreciseTypeOptions options) {
+      ColumnStorage<?> columnStorage, FloatType floatType, PreciseTypeOptions options) {
     if (!options.wholeFloatsBecomeIntegers()) {
-      return columnStorage.getType();
-    }
-
-    if (!(columnStorage.getType() instanceof FloatType floatType)) {
-      throw new IllegalArgumentException(
-          "Cannot infer float type from non-integer storage: " + columnStorage.getType());
+      return floatType;
     }
 
     // Build the min and max of values in the column.
@@ -301,14 +283,9 @@ public boolean getOverflowed() {
   }
 
   private static StorageType<?> inferBigDecimalType(
-      ColumnStorage<?> columnStorage, PreciseTypeOptions options) {
+      ColumnStorage<?> columnStorage, BigDecimalType bigDecimalType, PreciseTypeOptions options) {
     if (!options.wholeFloatsBecomeIntegers()) {
-      return columnStorage.getType();
-    }
-
-    if (!(columnStorage.getType() instanceof BigDecimalType bigDecimalType)) {
-      throw new IllegalArgumentException(
-          "Cannot infer decimal type from non-decimal storage: " + columnStorage.getType());
+      return bigDecimalType;
     }
 
     // Build the min and max of values in the column.