noticket: Extract TypeToken.of(...).getRawType() into an utility method to reduce direct Guava TypeToken usage

Author: nvamelichev

databind/src/main/java/tech/ydb/yoj/databind/CustomValueTypes.java

@@ -1,7 +1,6 @@
 package tech.ydb.yoj.databind;
 
 import com.google.common.base.Preconditions;
-import com.google.common.reflect.TypeToken;
 import lombok.NonNull;
 import tech.ydb.yoj.ExperimentalApi;
 import tech.ydb.yoj.InternalApi;
@@ -11,6 +10,7 @@
 import tech.ydb.yoj.databind.schema.CustomValueTypeInfo;
 import tech.ydb.yoj.databind.schema.Schema.JavaField;
 import tech.ydb.yoj.util.lang.Annotations;
+import tech.ydb.yoj.util.lang.Types;
 
 import javax.annotation.Nullable;
 import java.lang.reflect.InvocationTargetException;
@@ -75,7 +75,7 @@ private static <J, C extends Comparable<? super C>> ValueConverter<J, C> createC
     public static <J, C extends Comparable<? super C>> CustomValueTypeInfo<J, C> getCustomValueTypeInfo(
             @NonNull Type type, @Nullable Column columnAnnotation
     ) {
-        Class<?> rawType = type instanceof Class<?> ? (Class<?>) type : TypeToken.of(type).getRawType();
+        Class<?> rawType = Types.getRawType(type);
         CustomValueType cvt = getCustomValueType(rawType, columnAnnotation);
         if (cvt == null) {
             return null;

databind/src/main/java/tech/ydb/yoj/databind/expression/values/StringFieldValue.java

@@ -1,11 +1,11 @@
 package tech.ydb.yoj.databind.expression.values;
 
-import com.google.common.reflect.TypeToken;
 import lombok.NonNull;
 import tech.ydb.yoj.databind.FieldValueType;
 import tech.ydb.yoj.databind.expression.IllegalExpressionException.FieldTypeError.StringFieldExpected;
 import tech.ydb.yoj.databind.expression.IllegalExpressionException.FieldTypeError.UnknownEnumConstant;
 import tech.ydb.yoj.databind.expression.IllegalExpressionException.FieldTypeError.UuidFieldExpected;
+import tech.ydb.yoj.util.lang.Types;
 
 import java.lang.reflect.Type;
 import java.util.Optional;
@@ -23,7 +23,7 @@ public Optional<Comparable<?>> getComparableByType(Type fieldType, FieldValueTyp
         return switch (valueType) {
             case STRING -> Optional.of(str);
             case ENUM -> {
-                @SuppressWarnings({"rawtypes", "unchecked"}) var enumType = (Class<Enum>) TypeToken.of(fieldType).getRawType();
+                @SuppressWarnings({"rawtypes", "unchecked"}) var enumType = (Class<Enum>) Types.getRawType(fieldType);
                 @SuppressWarnings("unchecked") var enumValue = (Comparable<?>) Enum.valueOf(enumType, str);
                 yield Optional.of(enumValue);
             }
@@ -45,7 +45,7 @@ public Optional<Comparable<?>> getComparableByType(Type fieldType, FieldValueTyp
     public ValidationResult isValidValueOfType(Type fieldType, FieldValueType valueType) {
         return switch (valueType) {
             case STRING -> validFieldValue();
-            case ENUM -> enumHasConstant(TypeToken.of(fieldType).getRawType(), str)
+            case ENUM -> enumHasConstant(Types.getRawType(fieldType), str)
                     ? validFieldValue()
                     : invalidFieldValue(p -> new UnknownEnumConstant(p, str), p -> format("Unknown enum constant for field \"%s\": \"%s\"", p, str));
             case UUID -> isValidUuid()

databind/src/main/java/tech/ydb/yoj/databind/schema/reflect/KotlinDataClassComponent.java

@@ -1,7 +1,6 @@
 package tech.ydb.yoj.databind.schema.reflect;
 
 import com.google.common.base.Preconditions;
-import com.google.common.reflect.TypeToken;
 import kotlin.jvm.JvmClassMappingKt;
 import kotlin.reflect.KClass;
 import kotlin.reflect.KClassifier;
@@ -10,6 +9,7 @@
 import kotlin.reflect.jvm.KCallablesJvm;
 import kotlin.reflect.jvm.ReflectJvmMapping;
 import tech.ydb.yoj.databind.schema.FieldValueException;
+import tech.ydb.yoj.util.lang.Types;
 
 import javax.annotation.Nullable;
 import java.lang.reflect.Field;
@@ -22,26 +22,26 @@
     private final KProperty1.Getter<?, ?> getter;
 
     public KotlinDataClassComponent(Reflector reflector, String name, KProperty1<?, ?> property) {
-        super(reflector, name, genericType(property), rawType(property), field(property));
+        super(reflector, name, genericJavaType(property), rawJavaType(property), field(property));
 
         this.getter = property.getGetter();
         KCallablesJvm.setAccessible(this.getter, true);
     }
 
-    private static Type genericType(KProperty1<?, ?> property) {
+    private static Type genericJavaType(KProperty1<?, ?> property) {
         return ReflectJvmMapping.getJavaType(property.getReturnType());
     }
 
-    private static Class<?> rawType(KProperty1<?, ?> property) {
-        Type genericType = genericType(property);
+    private static Class<?> rawJavaType(KProperty1<?, ?> property) {
+        Type genericJavaType = genericJavaType(property);
 
         KType kPropertyType = property.getReturnType();
         KClassifier kClassifier = kPropertyType.getClassifier();
         if (kClassifier instanceof KClass<?> kClass) {
             return JvmClassMappingKt.getJavaClass(kClass);
         } else {
-            // fallback to Guava's TypeToken if kotlin-reflect returns unpredictable results ;-)
-            return TypeToken.of(genericType).getRawType();
+            // Fallback to java.lang.reflect if kotlin-reflect returns unpredictable results ;-)
+            return Types.getRawType(genericJavaType);
         }
     }
 

databind/src/main/java/tech/ydb/yoj/databind/schema/reflect/StdReflector.java

@@ -1,9 +1,9 @@
 package tech.ydb.yoj.databind.schema.reflect;
 
-import com.google.common.reflect.TypeToken;
 import lombok.NonNull;
 import tech.ydb.yoj.databind.FieldValueType;
 import tech.ydb.yoj.databind.schema.configuration.SchemaRegistry;
+import tech.ydb.yoj.util.lang.Types;
 
 import java.lang.reflect.Type;
 import java.util.List;
@@ -49,7 +49,7 @@ public ReflectType<?> reflectFieldType(Type genericType, FieldValueType bindingT
     }
 
     private ReflectType<?> reflectFor(Type type, FieldValueType fvt) {
-        Class<?> rawType = type instanceof Class<?> clazz ? clazz : TypeToken.of(type).getRawType();
+        Class<?> rawType = Types.getRawType(type);
         for (TypeFactory m : matchers) {
             if (m.matches(rawType, fvt)) {
                 return m.create(this, rawType, fvt);

util/src/main/java/tech/ydb/yoj/util/lang/Types.java

@@ -0,0 +1,16 @@
+package tech.ydb.yoj.util.lang;
+
+import com.google.common.reflect.TypeToken;
+import lombok.NonNull;
+
+import java.lang.reflect.Type;
+
+public final class Types {
+    private Types() {
+    }
+
+    @NonNull
+    public static Class<?> getRawType(@NonNull Type genericType) {
+        return genericType instanceof Class<?> clazz ? clazz : TypeToken.of(genericType).getRawType();
+    }
+}