Remove Painless Type From Painless Method/Field (#28466)

modules/lang-painless/src/main/java/org/elasticsearch/painless/Def.java

@@ -279,7 +279,7 @@ public final class Def {
                      captures[capture] = callSiteType.parameterType(i + 1 + capture);
                  }
                  MethodHandle filter;
-                 Definition.Type interfaceType = method.arguments.get(i - 1 - replaced);
+                 Definition.Type interfaceType = definition.ClassToType(method.arguments.get(i - 1 - replaced));
                  if (signature.charAt(0) == 'S') {
                      // the implementation is strongly typed, now that we know the interface type,
                      // we have everything.

modules/lang-painless/src/main/java/org/elasticsearch/painless/Definition.java

@@ -135,13 +135,13 @@ public final class Definition {
         public final String name;
         public final Struct owner;
         public final Class<?> augmentation;
-        public final Type rtn;
-        public final List<Type> arguments;
+        public final Class<?> rtn;
+        public final List<Class<?>> arguments;
         public final org.objectweb.asm.commons.Method method;
         public final int modifiers;
         public final MethodHandle handle;
 
-        public Method(String name, Struct owner, Class<?> augmentation, Type rtn, List<Type> arguments,
+        public Method(String name, Struct owner, Class<?> augmentation, Class<?> rtn, List<Class<?>> arguments,
                       org.objectweb.asm.commons.Method method, int modifiers, MethodHandle handle) {
             this.name = name;
             this.augmentation = augmentation;
@@ -172,21 +172,21 @@ public final class Definition {
                 params = new Class<?>[1 + arguments.size()];
                 params[0] = augmentation;
                 for (int i = 0; i < arguments.size(); i++) {
-                    params[i + 1] = arguments.get(i).clazz;
+                    params[i + 1] = defClassToObjectClass(arguments.get(i));
                 }
-                returnValue = rtn.clazz;
+                returnValue = defClassToObjectClass(rtn);
             } else if (Modifier.isStatic(modifiers)) {
                 // static method: straightforward copy
                 params = new Class<?>[arguments.size()];
                 for (int i = 0; i < arguments.size(); i++) {
-                    params[i] = arguments.get(i).clazz;
+                    params[i] = defClassToObjectClass(arguments.get(i));
                 }
-                returnValue = rtn.clazz;
+                returnValue = defClassToObjectClass(rtn);
             } else if ("<init>".equals(name)) {
                 // constructor: returns the owner class
                 params = new Class<?>[arguments.size()];
                 for (int i = 0; i < arguments.size(); i++) {
-                    params[i] = arguments.get(i).clazz;
+                    params[i] = defClassToObjectClass(arguments.get(i));
                 }
                 returnValue = owner.clazz;
             } else {
@@ -194,9 +194,9 @@ public final class Definition {
                 params = new Class<?>[1 + arguments.size()];
                 params[0] = owner.clazz;
                 for (int i = 0; i < arguments.size(); i++) {
-                    params[i + 1] = arguments.get(i).clazz;
+                    params[i + 1] = defClassToObjectClass(arguments.get(i));
                 }
-                returnValue = rtn.clazz;
+                returnValue = defClassToObjectClass(rtn);
             }
             return MethodType.methodType(returnValue, params);
         }
@@ -223,17 +223,17 @@ public final class Definition {
     public static final class Field {
         public final String name;
         public final Struct owner;
-        public final Type type;
+        public final Class<?> clazz;
         public final String javaName;
         public final int modifiers;
         private final MethodHandle getter;
         private final MethodHandle setter;
 
-        private Field(String name, String javaName, Struct owner, Type type, int modifiers, MethodHandle getter, MethodHandle setter) {
+        private Field(String name, String javaName, Struct owner, Class<?> clazz, int modifiers, MethodHandle getter, MethodHandle setter) {
             this.name = name;
             this.javaName = javaName;
             this.owner = owner;
-            this.type = type;
+            this.clazz = clazz;
             this.modifiers = modifiers;
             this.getter = getter;
             this.setter = setter;
@@ -641,13 +641,13 @@ public final class Definition {
         return simpleTypesMap.values();
     }
 
-    private static String buildMethodCacheKey(String structName, String methodName, List<Type> arguments) {
+    private static String buildMethodCacheKey(String structName, String methodName, List<Class<?>> arguments) {
         StringBuilder key = new StringBuilder();
         key.append(structName);
         key.append(methodName);
 
-        for (Type argument : arguments) {
-            key.append(argument.name);
+        for (Class<?> argument : arguments) {
+            key.append(argument.getName());
         }
 
         return key.toString();
@@ -916,17 +916,17 @@ public final class Definition {
                     "parameters " + whitelistConstructor.painlessParameterTypeNames);
         }
 
-        List<Type> painlessParametersTypes = new ArrayList<>(whitelistConstructor.painlessParameterTypeNames.size());
+        List<Class<?>> painlessParametersTypes = new ArrayList<>(whitelistConstructor.painlessParameterTypeNames.size());
         Class<?>[] javaClassParameters = new Class<?>[whitelistConstructor.painlessParameterTypeNames.size()];
 
         for (int parameterCount = 0; parameterCount < whitelistConstructor.painlessParameterTypeNames.size(); ++parameterCount) {
             String painlessParameterTypeName = whitelistConstructor.painlessParameterTypeNames.get(parameterCount);
 
             try {
-                Type painlessParameterType = getTypeInternal(painlessParameterTypeName);
+                Class<?> painlessParameterClass = TypeToClass(getTypeInternal(painlessParameterTypeName));
 
-                painlessParametersTypes.add(painlessParameterType);
-                javaClassParameters[parameterCount] = painlessParameterType.clazz;
+                painlessParametersTypes.add(painlessParameterClass);
+                javaClassParameters[parameterCount] = defClassToObjectClass(painlessParameterClass);
             } catch (IllegalArgumentException iae) {
                 throw new IllegalArgumentException("struct not defined for constructor parameter [" + painlessParameterTypeName + "] " +
                         "with owner struct [" + ownerStructName + "] and constructor parameters " +
@@ -958,9 +958,8 @@ public final class Definition {
             }
 
             painlessConstructor = methodCache.computeIfAbsent(buildMethodCacheKey(ownerStruct.name, "<init>", painlessParametersTypes),
-                    key -> new Method("<init>", ownerStruct, null, getTypeInternal("void"), painlessParametersTypes,
+                    key -> new Method("<init>", ownerStruct, null, void.class, painlessParametersTypes,
                             asmConstructor, javaConstructor.getModifiers(), javaHandle));
-
             ownerStruct.constructors.put(painlessMethodKey, painlessConstructor);
         } else if (painlessConstructor.arguments.equals(painlessParametersTypes) == false){
             throw new IllegalArgumentException(
@@ -998,7 +997,7 @@ public final class Definition {
 
         int augmentedOffset = javaAugmentedClass == null ? 0 : 1;
 
-        List<Type> painlessParametersTypes = new ArrayList<>(whitelistMethod.painlessParameterTypeNames.size());
+        List<Class<?>> painlessParametersTypes = new ArrayList<>(whitelistMethod.painlessParameterTypeNames.size());
         Class<?>[] javaClassParameters = new Class<?>[whitelistMethod.painlessParameterTypeNames.size() + augmentedOffset];
 
         if (javaAugmentedClass != null) {
@@ -1009,10 +1008,10 @@ public final class Definition {
             String painlessParameterTypeName = whitelistMethod.painlessParameterTypeNames.get(parameterCount);
 
             try {
-                Type painlessParameterType = getTypeInternal(painlessParameterTypeName);
+                Class<?> painlessParameterClass = TypeToClass(getTypeInternal(painlessParameterTypeName));
 
-                painlessParametersTypes.add(painlessParameterType);
-                javaClassParameters[parameterCount + augmentedOffset] = painlessParameterType.clazz;
+                painlessParametersTypes.add(painlessParameterClass);
+                javaClassParameters[parameterCount + augmentedOffset] = defClassToObjectClass(painlessParameterClass);
             } catch (IllegalArgumentException iae) {
                 throw new IllegalArgumentException("struct not defined for method parameter [" + painlessParameterTypeName + "] " +
                         "with owner struct [" + ownerStructName + "] and method with name [" + whitelistMethod.javaMethodName + "] " +
@@ -1031,18 +1030,18 @@ public final class Definition {
                     javaImplClass.getName() + "]", nsme);
         }
 
-        Type painlessReturnType;
+        Class<?> painlessReturnClass;
 
         try {
-            painlessReturnType = getTypeInternal(whitelistMethod.painlessReturnTypeName);
+            painlessReturnClass = TypeToClass(getTypeInternal(whitelistMethod.painlessReturnTypeName));
         } catch (IllegalArgumentException iae) {
             throw new IllegalArgumentException("struct not defined for return type [" + whitelistMethod.painlessReturnTypeName + "] " +
                     "with owner struct [" + ownerStructName + "] and method with name [" + whitelistMethod.javaMethodName + "] " +
                     "and parameters " + whitelistMethod.painlessParameterTypeNames, iae);
         }
 
-        if (javaMethod.getReturnType().equals(painlessReturnType.clazz) == false) {
-            throw new IllegalArgumentException("specified return type class [" + painlessReturnType.clazz + "] " +
+        if (javaMethod.getReturnType() != defClassToObjectClass(painlessReturnClass)) {
+            throw new IllegalArgumentException("specified return type class [" + painlessReturnClass + "] " +
                     "does not match the return type class [" + javaMethod.getReturnType() + "] for the " +
                     "method with name [" + whitelistMethod.javaMethodName + "] " +
                     "and parameters " + whitelistMethod.painlessParameterTypeNames);
@@ -1066,14 +1065,14 @@ public final class Definition {
 
                 painlessMethod = methodCache.computeIfAbsent(
                         buildMethodCacheKey(ownerStruct.name, whitelistMethod.javaMethodName, painlessParametersTypes),
-                        key -> new Method(whitelistMethod.javaMethodName, ownerStruct, null, painlessReturnType, painlessParametersTypes,
+                        key -> new Method(whitelistMethod.javaMethodName, ownerStruct, null, painlessReturnClass, painlessParametersTypes,
                                 asmMethod, javaMethod.getModifiers(), javaMethodHandle));
                 ownerStruct.staticMethods.put(painlessMethodKey, painlessMethod);
-            } else if ((painlessMethod.name.equals(whitelistMethod.javaMethodName) && painlessMethod.rtn.equals(painlessReturnType) &&
+            } else if ((painlessMethod.name.equals(whitelistMethod.javaMethodName) && painlessMethod.rtn == painlessReturnClass &&
                     painlessMethod.arguments.equals(painlessParametersTypes)) == false) {
                 throw new IllegalArgumentException("illegal duplicate static methods [" + painlessMethodKey + "] " +
                         "found within the struct [" + ownerStruct.name + "] with name [" + whitelistMethod.javaMethodName + "], " +
-                        "return types [" + painlessReturnType + "] and [" + painlessMethod.rtn.name + "], " +
+                        "return types [" + painlessReturnClass + "] and [" + painlessMethod.rtn + "], " +
                         "and parameters " + painlessParametersTypes + " and " + painlessMethod.arguments);
             }
         } else {
@@ -1092,14 +1091,14 @@ public final class Definition {
 
                 painlessMethod = methodCache.computeIfAbsent(
                         buildMethodCacheKey(ownerStruct.name, whitelistMethod.javaMethodName, painlessParametersTypes),
-                        key -> new Method(whitelistMethod.javaMethodName, ownerStruct, javaAugmentedClass, painlessReturnType,
+                        key -> new Method(whitelistMethod.javaMethodName, ownerStruct, javaAugmentedClass, painlessReturnClass,
                                 painlessParametersTypes, asmMethod, javaMethod.getModifiers(), javaMethodHandle));
                 ownerStruct.methods.put(painlessMethodKey, painlessMethod);
-            } else if ((painlessMethod.name.equals(whitelistMethod.javaMethodName) && painlessMethod.rtn.equals(painlessReturnType) &&
+            } else if ((painlessMethod.name.equals(whitelistMethod.javaMethodName) && painlessMethod.rtn.equals(painlessReturnClass) &&
                 painlessMethod.arguments.equals(painlessParametersTypes)) == false) {
                 throw new IllegalArgumentException("illegal duplicate member methods [" + painlessMethodKey + "] " +
                     "found within the struct [" + ownerStruct.name + "] with name [" + whitelistMethod.javaMethodName + "], " +
-                    "return types [" + painlessReturnType + "] and [" + painlessMethod.rtn.name + "], " +
+                    "return types [" + painlessReturnClass + "] and [" + painlessMethod.rtn + "], " +
                     "and parameters " + painlessParametersTypes + " and " + painlessMethod.arguments);
             }
         }
@@ -1127,10 +1126,10 @@ public final class Definition {
                     "not found for class [" + ownerStruct.clazz.getName() + "].");
         }
 
-        Type painlessFieldType;
+        Class<?> painlessFieldClass;
 
         try {
-            painlessFieldType = getTypeInternal(whitelistField.painlessFieldTypeName);
+            painlessFieldClass = TypeToClass(getTypeInternal(whitelistField.painlessFieldTypeName));
         } catch (IllegalArgumentException iae) {
             throw new IllegalArgumentException("struct not defined for return type [" + whitelistField.painlessFieldTypeName + "] " +
                 "with owner struct [" + ownerStructName + "] and field with name [" + whitelistField.javaFieldName + "]", iae);
@@ -1146,11 +1145,11 @@ public final class Definition {
 
             if (painlessField == null) {
                 painlessField = fieldCache.computeIfAbsent(
-                        buildFieldCacheKey(ownerStruct.name, whitelistField.javaFieldName, painlessFieldType.name),
+                        buildFieldCacheKey(ownerStruct.name, whitelistField.javaFieldName, painlessFieldClass.getName()),
                         key -> new Field(whitelistField.javaFieldName, javaField.getName(),
-                                ownerStruct, painlessFieldType, javaField.getModifiers(), null, null));
+                                ownerStruct, painlessFieldClass, javaField.getModifiers(), null, null));
                 ownerStruct.staticMembers.put(whitelistField.javaFieldName, painlessField);
-            } else if (painlessField.type.equals(painlessFieldType) == false) {
+            } else if (painlessField.clazz != painlessFieldClass) {
                 throw new IllegalArgumentException("illegal duplicate static fields [" + whitelistField.javaFieldName + "] " +
                     "found within the struct [" + ownerStruct.name + "] with type [" + whitelistField.painlessFieldTypeName + "]");
             }
@@ -1175,11 +1174,11 @@ public final class Definition {
 
             if (painlessField == null) {
                 painlessField = fieldCache.computeIfAbsent(
-                        buildFieldCacheKey(ownerStruct.name, whitelistField.javaFieldName, painlessFieldType.name),
+                        buildFieldCacheKey(ownerStruct.name, whitelistField.javaFieldName, painlessFieldClass.getName()),
                         key -> new Field(whitelistField.javaFieldName, javaField.getName(),
-                                ownerStruct, painlessFieldType, javaField.getModifiers(), javaMethodHandleGetter, javaMethodHandleSetter));
+                                ownerStruct, painlessFieldClass, javaField.getModifiers(), javaMethodHandleGetter, javaMethodHandleSetter));
                 ownerStruct.members.put(whitelistField.javaFieldName, painlessField);
-            } else if (painlessField.type.equals(painlessFieldType) == false) {
+            } else if (painlessField.clazz != painlessFieldClass) {
                 throw new IllegalArgumentException("illegal duplicate member fields [" + whitelistField.javaFieldName + "] " +
                     "found within the struct [" + ownerStruct.name + "] with type [" + whitelistField.painlessFieldTypeName + "]");
             }
@@ -1263,7 +1262,7 @@ public final class Definition {
             for (Field field : child.members.values()) {
                 if (owner.members.get(field.name) == null) {
                     owner.members.put(field.name,
-                        new Field(field.name, field.javaName, owner, field.type, field.modifiers, field.getter, field.setter));
+                        new Field(field.name, field.javaName, owner, field.clazz, field.modifiers, field.getter, field.setter));
                 }
             }
         }

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ECallLocal.java

@@ -69,14 +69,14 @@ public final class ECallLocal extends AExpression {
         for (int argument = 0; argument < arguments.size(); ++argument) {
             AExpression expression = arguments.get(argument);
 
-            expression.expected = Definition.TypeToClass(method.arguments.get(argument));
+            expression.expected = method.arguments.get(argument);
             expression.internal = true;
             expression.analyze(locals);
             arguments.set(argument, expression.cast(locals));
         }
 
         statement = true;
-        actual = Definition.TypeToClass(method.rtn);
+        actual = method.rtn;
     }
 
     @Override

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ECapturingFunctionRef.java

@@ -80,14 +80,13 @@ public final class ECapturingFunctionRef extends AExpression implements ILambda
 
                     // check casts between the interface method and the delegate method are legal
                     for (int i = 0; i < ref.interfaceMethod.arguments.size(); ++i) {
-                        Class<?> from = Definition.TypeToClass(ref.interfaceMethod.arguments.get(i));
-                        Class<?> to = Definition.TypeToClass(ref.delegateMethod.arguments.get(i));
+                        Class<?> from = ref.interfaceMethod.arguments.get(i);
+                        Class<?> to = ref.delegateMethod.arguments.get(i);
                         AnalyzerCaster.getLegalCast(location, from, to, false, true);
                     }
 
-                    if (ref.interfaceMethod.rtn.clazz != void.class) {
-                        AnalyzerCaster.getLegalCast(location,
-                            Definition.TypeToClass(ref.delegateMethod.rtn), Definition.TypeToClass(ref.interfaceMethod.rtn), false, true);
+                    if (ref.interfaceMethod.rtn != void.class) {
+                        AnalyzerCaster.getLegalCast(location, ref.delegateMethod.rtn, ref.interfaceMethod.rtn, false, true);
                     }
                 } catch (IllegalArgumentException e) {
                     throw createError(e);

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/EFunctionRef.java

@@ -80,14 +80,13 @@ public final class EFunctionRef extends AExpression implements ILambda {
 
                     // check casts between the interface method and the delegate method are legal
                     for (int i = 0; i < interfaceMethod.arguments.size(); ++i) {
-                        Class<?> from = Definition.TypeToClass(interfaceMethod.arguments.get(i));
-                        Class<?> to = Definition.TypeToClass(delegateMethod.arguments.get(i));
+                        Class<?> from = interfaceMethod.arguments.get(i);
+                        Class<?> to = delegateMethod.arguments.get(i);
                         AnalyzerCaster.getLegalCast(location, from, to, false, true);
                     }
 
-                    if (interfaceMethod.rtn.clazz != void.class) {
-                        AnalyzerCaster.getLegalCast(
-                            location, Definition.TypeToClass(delegateMethod.rtn), Definition.TypeToClass(interfaceMethod.rtn), false, true);
+                    if (interfaceMethod.rtn != void.class) {
+                        AnalyzerCaster.getLegalCast(location, delegateMethod.rtn, interfaceMethod.rtn, false, true);
                     }
                 } else {
                     // whitelist lookup

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ELambda.java

@@ -130,17 +130,17 @@ public final class ELambda extends AExpression implements ILambda {
                 throw new IllegalArgumentException("Incorrect number of parameters for [" + interfaceMethod.name +
                                                    "] in [" + Definition.ClassToName(expected) + "]");
             // for method invocation, its allowed to ignore the return value
-            if (interfaceMethod.rtn.equals(locals.getDefinition().voidType)) {
+            if (interfaceMethod.rtn == void.class) {
                 returnType = def.class;
             } else {
-                returnType = Definition.TypeToClass(interfaceMethod.rtn);
+                returnType = interfaceMethod.rtn;
             }
             // replace any null types with the actual type
             actualParamTypeStrs = new ArrayList<>(paramTypeStrs.size());
             for (int i = 0; i < paramTypeStrs.size(); i++) {
                 String paramType = paramTypeStrs.get(i);
                 if (paramType == null) {
-                    actualParamTypeStrs.add(interfaceMethod.arguments.get(i).name);
+                    actualParamTypeStrs.add(Definition.ClassToName(interfaceMethod.arguments.get(i)));
                 } else {
                     actualParamTypeStrs.add(paramType);
                 }
@@ -190,14 +190,13 @@ public final class ELambda extends AExpression implements ILambda {
 
             // check casts between the interface method and the delegate method are legal
             for (int i = 0; i < interfaceMethod.arguments.size(); ++i) {
-                Class<?> from = Definition.TypeToClass(interfaceMethod.arguments.get(i));
+                Class<?> from = interfaceMethod.arguments.get(i);
                 Class<?> to = Definition.TypeToClass(desugared.parameters.get(i + captures.size()).type);
                 AnalyzerCaster.getLegalCast(location, from, to, false, true);
             }
 
-            if (interfaceMethod.rtn.clazz != void.class) {
-                AnalyzerCaster.getLegalCast(
-                    location, Definition.TypeToClass(desugared.rtnType), Definition.TypeToClass(interfaceMethod.rtn), false, true);
+            if (interfaceMethod.rtn != void.class) {
+                AnalyzerCaster.getLegalCast(location, desugared.rtnType, interfaceMethod.rtn, false, true);
             }
 
             actual = expected;

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ENewObj.java

@@ -68,7 +68,7 @@ public final class ENewObj extends AExpression {
         constructor = struct.constructors.get(new Definition.MethodKey("<init>", arguments.size()));
 
         if (constructor != null) {
-            Type[] types = new Type[constructor.arguments.size()];
+            Class<?>[] types = new Class<?>[constructor.arguments.size()];
             constructor.arguments.toArray(types);
 
             if (constructor.arguments.size() != arguments.size()) {
@@ -79,7 +79,7 @@ public final class ENewObj extends AExpression {
             for (int argument = 0; argument < arguments.size(); ++argument) {
                 AExpression expression = arguments.get(argument);
 
-                expression.expected = Definition.TypeToClass(types[argument]);
+                expression.expected = types[argument];
                 expression.internal = true;
                 expression.analyze(locals);
                 arguments.set(argument, expression.cast(locals));

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubCallInvoke.java

@@ -57,14 +57,14 @@ final class PSubCallInvoke extends AExpression {
         for (int argument = 0; argument < arguments.size(); ++argument) {
             AExpression expression = arguments.get(argument);
 
-            expression.expected = Definition.TypeToClass(method.arguments.get(argument));
+            expression.expected = method.arguments.get(argument);
             expression.internal = true;
             expression.analyze(locals);
             arguments.set(argument, expression.cast(locals));
         }
 
         statement = true;
-        actual = Definition.TypeToClass(method.rtn);
+        actual = method.rtn;
     }
 
     @Override

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubField.java

@@ -52,10 +52,10 @@ final class PSubField extends AStoreable {
     void analyze(Locals locals) {
          if (write && Modifier.isFinal(field.modifiers)) {
              throw createError(new IllegalArgumentException(
-                 "Cannot write to read-only field [" + field.name + "] for type [" + field.type.name + "]."));
+                 "Cannot write to read-only field [" + field.name + "] for type [" + Definition.ClassToName(field.clazz) + "]."));
          }
 
-        actual = Definition.TypeToClass(field.type);
+        actual = field.clazz;
     }
 
     @Override
@@ -63,9 +63,9 @@ final class PSubField extends AStoreable {
         writer.writeDebugInfo(location);
 
         if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {
-            writer.getStatic(field.owner.type, field.javaName, field.type.type);
+            writer.getStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         } else {
-            writer.getField(field.owner.type, field.javaName, field.type.type);
+            writer.getField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         }
     }
 
@@ -94,9 +94,9 @@ final class PSubField extends AStoreable {
         writer.writeDebugInfo(location);
 
         if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {
-            writer.getStatic(field.owner.type, field.javaName, field.type.type);
+            writer.getStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         } else {
-            writer.getField(field.owner.type, field.javaName, field.type.type);
+            writer.getField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         }
     }
 
@@ -105,9 +105,9 @@ final class PSubField extends AStoreable {
         writer.writeDebugInfo(location);
 
         if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {
-            writer.putStatic(field.owner.type, field.javaName, field.type.type);
+            writer.putStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         } else {
-            writer.putField(field.owner.type, field.javaName, field.type.type);
+            writer.putField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         }
     }
 

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubListShortcut.java

@@ -59,12 +59,12 @@ final class PSubListShortcut extends AStoreable {
         getter = struct.methods.get(new Definition.MethodKey("get", 1));
         setter = struct.methods.get(new Definition.MethodKey("set", 2));
 
-        if (getter != null && (getter.rtn.clazz == void.class || getter.arguments.size() != 1 ||
-            getter.arguments.get(0).clazz != int.class)) {
+        if (getter != null && (getter.rtn == void.class || getter.arguments.size() != 1 ||
+            getter.arguments.get(0) != int.class)) {
             throw createError(new IllegalArgumentException("Illegal list get shortcut for type [" + struct.name + "]."));
         }
 
-        if (setter != null && (setter.arguments.size() != 2 || setter.arguments.get(0).clazz != int.class)) {
+        if (setter != null && (setter.arguments.size() != 2 || setter.arguments.get(0) != int.class)) {
             throw createError(new IllegalArgumentException("Illegal list set shortcut for type [" + struct.name + "]."));
         }
 
@@ -78,7 +78,7 @@ final class PSubListShortcut extends AStoreable {
             index.analyze(locals);
             index = index.cast(locals);
 
-            actual = setter != null ? Definition.TypeToClass(setter.arguments.get(1)) : Definition.TypeToClass(getter.rtn);
+            actual = setter != null ? setter.arguments.get(1) : getter.rtn;
         } else {
             throw createError(new IllegalArgumentException("Illegal list shortcut for type [" + struct.name + "]."));
         }
@@ -119,8 +119,8 @@ final class PSubListShortcut extends AStoreable {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (getter.rtn == getter.handle.type().returnType()) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -130,7 +130,7 @@ final class PSubListShortcut extends AStoreable {
 
         setter.write(writer);
 
-        writer.writePop(setter.rtn.type.getSize());
+        writer.writePop(MethodWriter.getType(setter.rtn).getSize());
     }
 
     @Override

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubMapShortcut.java

@@ -58,7 +58,7 @@ final class PSubMapShortcut extends AStoreable {
         getter = struct.methods.get(new Definition.MethodKey("get", 1));
         setter = struct.methods.get(new Definition.MethodKey("put", 2));
 
-        if (getter != null && (getter.rtn.clazz == void.class || getter.arguments.size() != 1)) {
+        if (getter != null && (getter.rtn == void.class || getter.arguments.size() != 1)) {
             throw createError(new IllegalArgumentException("Illegal map get shortcut for type [" + struct.name + "]."));
         }
 
@@ -72,12 +72,11 @@ final class PSubMapShortcut extends AStoreable {
         }
 
         if ((read || write) && (!read || getter != null) && (!write || setter != null)) {
-            index.expected = setter != null ?
-                    Definition.TypeToClass(setter.arguments.get(0)) : Definition.TypeToClass(getter.arguments.get(0));
+            index.expected = setter != null ? setter.arguments.get(0) : getter.arguments.get(0);
             index.analyze(locals);
             index = index.cast(locals);
 
-            actual = setter != null ? Definition.TypeToClass(setter.arguments.get(1)) : Definition.TypeToClass(getter.rtn);
+            actual = setter != null ? setter.arguments.get(1) : getter.rtn;
         } else {
             throw createError(new IllegalArgumentException("Illegal map shortcut for type [" + struct.name + "]."));
         }
@@ -91,8 +90,8 @@ final class PSubMapShortcut extends AStoreable {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (getter.rtn != getter.handle.type().returnType()) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -122,8 +121,8 @@ final class PSubMapShortcut extends AStoreable {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (getter.rtn != getter.handle.type().returnType()) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -133,7 +132,7 @@ final class PSubMapShortcut extends AStoreable {
 
         setter.write(writer);
 
-        writer.writePop(setter.rtn.type.getSize());
+        writer.writePop(MethodWriter.getType(setter.rtn).getSize());
     }
 
     @Override

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubShortcut.java

@@ -54,12 +54,12 @@ final class PSubShortcut extends AStoreable {
 
     @Override
     void analyze(Locals locals) {
-        if (getter != null && (getter.rtn.clazz == void.class || !getter.arguments.isEmpty())) {
+        if (getter != null && (getter.rtn == void.class || !getter.arguments.isEmpty())) {
             throw createError(new IllegalArgumentException(
                 "Illegal get shortcut on field [" + value + "] for type [" + type + "]."));
         }
 
-        if (setter != null && (setter.rtn.clazz != void.class || setter.arguments.size() != 1)) {
+        if (setter != null && (setter.rtn != void.class || setter.arguments.size() != 1)) {
             throw createError(new IllegalArgumentException(
                 "Illegal set shortcut on field [" + value + "] for type [" + type + "]."));
         }
@@ -69,7 +69,7 @@ final class PSubShortcut extends AStoreable {
         }
 
         if ((getter != null || setter != null) && (!read || getter != null) && (!write || setter != null)) {
-            actual = setter != null ? Definition.TypeToClass(setter.arguments.get(0)) : Definition.TypeToClass(getter.rtn);
+            actual = setter != null ? setter.arguments.get(0) : getter.rtn;
         } else {
             throw createError(new IllegalArgumentException("Illegal shortcut on field [" + value + "] for type [" + type + "]."));
         }
@@ -81,8 +81,8 @@ final class PSubShortcut extends AStoreable {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (!getter.rtn.equals(getter.handle.type().returnType())) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -112,8 +112,8 @@ final class PSubShortcut extends AStoreable {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (getter.rtn != getter.handle.type().returnType()) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -123,7 +123,7 @@ final class PSubShortcut extends AStoreable {
 
         setter.write(writer);
 
-        writer.writePop(setter.rtn.type.getSize());
+        writer.writePop(MethodWriter.getType(setter.rtn).getSize());
     }
 
     @Override

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/SFunction.java

@@ -24,7 +24,6 @@ import org.elasticsearch.painless.Constant;
 import org.elasticsearch.painless.Def;
 import org.elasticsearch.painless.Definition;
 import org.elasticsearch.painless.Definition.Method;
-import org.elasticsearch.painless.Definition.Type;
 import org.elasticsearch.painless.Globals;
 import org.elasticsearch.painless.Locals;
 import org.elasticsearch.painless.Locals.Parameter;
@@ -92,7 +91,7 @@ public final class SFunction extends AStatement {
     private final List<AStatement> statements;
     public final boolean synthetic;
 
-    Type rtnType = null;
+    Class<?> rtnType = null;
     List<Parameter> parameters = new ArrayList<>();
     Method method = null;
 
@@ -120,7 +119,7 @@ public final class SFunction extends AStatement {
 
     void generateSignature(Definition definition) {
         try {
-            rtnType = definition.getType(rtnTypeStr);
+            rtnType = Definition.TypeToClass(definition.getType(rtnTypeStr));
         } catch (IllegalArgumentException exception) {
             throw createError(new IllegalArgumentException("Illegal return type [" + rtnTypeStr + "] for function [" + name + "]."));
         }
@@ -130,23 +129,23 @@ public final class SFunction extends AStatement {
         }
 
         Class<?>[] paramClasses = new Class<?>[this.paramTypeStrs.size()];
-        List<Type> paramTypes = new ArrayList<>();
+        List<Class<?>> paramTypes = new ArrayList<>();
 
         for (int param = 0; param < this.paramTypeStrs.size(); ++param) {
             try {
-                Type paramType = definition.getType(this.paramTypeStrs.get(param));
+                Class<?> paramType = Definition.TypeToClass(definition.getType(this.paramTypeStrs.get(param)));
 
-                paramClasses[param] = paramType.clazz;
+                paramClasses[param] = Definition.defClassToObjectClass(paramType);
                 paramTypes.add(paramType);
-                parameters.add(new Parameter(location, paramNameStrs.get(param), paramType));
+                parameters.add(new Parameter(location, paramNameStrs.get(param), definition.ClassToType(paramType)));
             } catch (IllegalArgumentException exception) {
                 throw createError(new IllegalArgumentException(
                     "Illegal parameter type [" + this.paramTypeStrs.get(param) + "] for function [" + name + "]."));
             }
         }
 
-        org.objectweb.asm.commons.Method method =
-            new org.objectweb.asm.commons.Method(name, MethodType.methodType(rtnType.clazz, paramClasses).toMethodDescriptorString());
+        org.objectweb.asm.commons.Method method = new org.objectweb.asm.commons.Method(
+            name, MethodType.methodType(Definition.defClassToObjectClass(rtnType), paramClasses).toMethodDescriptorString());
         this.method = new Method(name, null, null, rtnType, paramTypes, method, Modifier.STATIC | Modifier.PRIVATE, null);
     }
 
@@ -175,7 +174,7 @@ public final class SFunction extends AStatement {
             allEscape = statement.allEscape;
         }
 
-        if (!methodEscape && rtnType.clazz != void.class) {
+        if (!methodEscape && rtnType != void.class) {
             throw createError(new IllegalArgumentException("Not all paths provide a return value for method [" + name + "]."));
         }
 
@@ -210,7 +209,7 @@ public final class SFunction extends AStatement {
         }
 
         if (!methodEscape) {
-            if (rtnType.clazz == void.class) {
+            if (rtnType == void.class) {
                 function.returnValue();
             } else {
                 throw createError(new IllegalStateException("Illegal tree structure."));

modules/lang-painless/src/main/java/org/elasticsearch/painless/node/SSource.java

@@ -186,8 +186,8 @@ public final class SSource extends AStatement {
     @Override
     void analyze(Locals program) {
         for (SFunction function : functions) {
-            Locals functionLocals = Locals.newFunctionScope(program, function.rtnType, function.parameters,
-                                                            function.reserved.getMaxLoopCounter());
+            Locals functionLocals = Locals.newFunctionScope(program, program.getDefinition().ClassToType(function.rtnType),
+                                                            function.parameters, function.reserved.getMaxLoopCounter());
             function.analyze(functionLocals);
         }
 

modules/lang-painless/src/test/java/org/elasticsearch/painless/PainlessDocGenerator.java

@@ -49,6 +49,7 @@ import static java.util.stream.Collectors.toList;
  * Generates an API reference from the method and type whitelists in {@link Definition}.
  */
 public class PainlessDocGenerator {
+    private static final Definition definition = new Definition(Whitelist.BASE_WHITELISTS);
     private static final Logger logger = ESLoggerFactory.getLogger(PainlessDocGenerator.class);
     private static final Comparator<Field> FIELD_NAME = comparing(f -> f.name);
     private static final Comparator<Method> METHOD_NAME = comparing(m -> m.name);
@@ -67,8 +68,7 @@ public class PainlessDocGenerator {
                 Files.newOutputStream(indexPath, StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE),
                 false, StandardCharsets.UTF_8.name())) {
             emitGeneratedWarning(indexStream);
-            List<Type> types = new Definition(Whitelist.BASE_WHITELISTS).
-                    allSimpleTypes().stream().sorted(comparing(t -> t.name)).collect(toList());
+            List<Type> types = definition.allSimpleTypes().stream().sorted(comparing(t -> t.name)).collect(toList());
             for (Type type : types) {
                 if (type.clazz.isPrimitive()) {
                     // Primitives don't have methods to reference
@@ -139,7 +139,7 @@ public class PainlessDocGenerator {
             stream.print("static ");
         }
 
-        emitType(stream, field.type);
+        emitType(stream, definition.ClassToType(field.clazz));
         stream.print(' ');
 
         String javadocRoot = javadocRoot(field);
@@ -170,7 +170,7 @@ public class PainlessDocGenerator {
         }
 
         if (false == method.name.equals("<init>")) {
-            emitType(stream, method.rtn);
+            emitType(stream, definition.ClassToType(method.rtn));
             stream.print(' ');
         }
 
@@ -182,13 +182,13 @@ public class PainlessDocGenerator {
 
         stream.print("](");
         boolean first = true;
-        for (Type arg : method.arguments) {
+        for (Class<?> arg : method.arguments) {
             if (first) {
                 first = false;
             } else {
                 stream.print(", ");
             }
-            emitType(stream, arg);
+            emitType(stream, definition.ClassToType(arg));
         }
         stream.print(")++");
 
@@ -278,7 +278,8 @@ public class PainlessDocGenerator {
             first = false;
             stream.print(method.owner.clazz.getName());
         }
-        for (Type arg: method.arguments) {
+        for (Class<?> clazz: method.arguments) {
+            Type arg = definition.ClassToType(clazz);
             if (first) {
                 first = false;
             } else {