Painless: Clean Up Whitelist Names (#32791)

Renames variables in the whitelists to match the current naming scheme. Mechanical change.

modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/Whitelist.java

@@ -28,7 +28,7 @@ import java.util.Objects;
  * constructors, methods, and fields that can be used within a Painless script at both compile-time
  * and run-time.
  *
- * A whitelist consists of several pieces with {@link WhitelistClass}s as the top level.  Each
+ * A whitelist consists of several pieces with {@link WhitelistClass}s as the top level. Each
  * {@link WhitelistClass} will contain zero-to-many {@link WhitelistConstructor}s, {@link WhitelistMethod}s, and
  * {@link WhitelistField}s which are what will be available with a Painless script.  See each individual
  * whitelist object for more detail.
@@ -56,14 +56,14 @@ public final class Whitelist {
         Collections.singletonList(WhitelistLoader.loadFromResourceFiles(Whitelist.class, BASE_WHITELIST_FILES));
 
     /** The {@link ClassLoader} used to look up the whitelisted Java classes, constructors, methods, and fields. */
-    public final ClassLoader javaClassLoader;
+    public final ClassLoader classLoader;
 
     /** The {@link List} of all the whitelisted Painless classes. */
-    public final List<WhitelistClass> whitelistStructs;
+    public final List<WhitelistClass> whitelistClasses;
 
     /** Standard constructor.  All values must be not {@code null}. */
-    public Whitelist(ClassLoader javaClassLoader, List<WhitelistClass> whitelistStructs) {
+    public Whitelist(ClassLoader classLoader, List<WhitelistClass> whitelistClasses) {
-        this.javaClassLoader = Objects.requireNonNull(javaClassLoader);
+        this.classLoader = Objects.requireNonNull(classLoader);
-        this.whitelistStructs = Collections.unmodifiableList(Objects.requireNonNull(whitelistStructs));
+        this.whitelistClasses = Collections.unmodifiableList(Objects.requireNonNull(whitelistClasses));
     }
 }

modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistClass.java

@@ -30,7 +30,7 @@ import java.util.Objects;
  * specific context, as long as multiple classes representing the same Java class have the same
  * class name and have legal constructor/method overloading they can be merged together.
  *
- * Classes in Painless allow for arity overloading for constructors and methods.  Arity overloading
+ * Classes in Painless allow for arity overloading for constructors and methods. Arity overloading
  * means that multiple constructors are allowed for a single class as long as they have a different
  * number of parameters, and multiples methods with the same name are allowed for a single class
  * as long as they have the same return type and a different number of parameters.
@@ -40,7 +40,7 @@ import java.util.Objects;
  */
 public final class WhitelistClass {
 
-    /** Information about where this class was white-listed from.  Can be used for error messages. */
+    /** Information about where this class was white-listed from. */
     public final String origin;
 
     /** The Java class name this class represents. */
@@ -49,7 +49,7 @@ public final class WhitelistClass {
     /**
      * Allow the Java class name to only be specified as the fully-qualified name.
      */
-    public final boolean onlyFQNJavaClassName;
+    public final boolean noImport;
 
     /** The {@link List} of whitelisted ({@link WhitelistConstructor}s) available to this class. */
     public final List<WhitelistConstructor> whitelistConstructors;
@@ -61,13 +61,14 @@ public final class WhitelistClass {
     public final List<WhitelistField> whitelistFields;
 
     /** Standard constructor. All values must be not {@code null}. */
-    public WhitelistClass(String origin, String javaClassName, boolean onlyFQNJavaClassName,
+    public WhitelistClass(String origin, String javaClassName, boolean noImport,
                           List<WhitelistConstructor> whitelistConstructors,
                           List<WhitelistMethod> whitelistMethods,
                           List<WhitelistField> whitelistFields) {
+
         this.origin = Objects.requireNonNull(origin);
         this.javaClassName = Objects.requireNonNull(javaClassName);
-        this.onlyFQNJavaClassName = onlyFQNJavaClassName;
+        this.noImport = noImport;
 
         this.whitelistConstructors = Collections.unmodifiableList(Objects.requireNonNull(whitelistConstructors));
         this.whitelistMethods = Collections.unmodifiableList(Objects.requireNonNull(whitelistMethods));

modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistConstructor.java

@@ -25,24 +25,24 @@ import java.util.Objects;
 
 /**
  * Constructor represents the equivalent of a Java constructor available as a whitelisted class
- * constructor within Painless.  Constructors for Painless classes may be accessed exactly as
+ * constructor within Painless. Constructors for Painless classes may be accessed exactly as
- * constructors for Java classes are using the 'new' keyword.  Painless classes may have multiple
+ * constructors for Java classes are using the 'new' keyword. Painless classes may have multiple
  * constructors as long as they comply with arity overloading described for {@link WhitelistClass}.
  */
 public final class WhitelistConstructor {
 
-    /** Information about where this constructor was whitelisted from.  Can be used for error messages. */
+    /** Information about where this constructor was whitelisted from. */
     public final String origin;
 
     /**
      * A {@link List} of {@link String}s that are the Painless type names for the parameters of the
      * constructor which can be used to look up the Java constructor through reflection.
      */
-    public final List<String> painlessParameterTypeNames;
+    public final List<String> canonicalTypeNameParameters;
 
     /** Standard constructor. All values must be not {@code null}. */
-    public WhitelistConstructor(String origin, List<String> painlessParameterTypeNames) {
+    public WhitelistConstructor(String origin, List<String> canonicalTypeNameParameters) {
         this.origin = Objects.requireNonNull(origin);
-        this.painlessParameterTypeNames = Collections.unmodifiableList(Objects.requireNonNull(painlessParameterTypeNames));
+        this.canonicalTypeNameParameters = Collections.unmodifiableList(Objects.requireNonNull(canonicalTypeNameParameters));
     }
 }

modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistField.java

@@ -23,24 +23,24 @@ import java.util.Objects;
 
 /**
  * Field represents the equivalent of a Java field available as a whitelisted class field
- * within Painless.  Fields for Painless classes may be accessed exactly as fields for Java classes
+ * within Painless. Fields for Painless classes may be accessed exactly as fields for Java classes
  * are using the '.' operator on an existing class variable/field.
  */
 public class WhitelistField {
 
-    /** Information about where this method was whitelisted from.  Can be used for error messages. */
+    /** Information about where this method was whitelisted from. */
     public final String origin;
 
-    /** The Java field name used to look up the Java field through reflection. */
+    /** The field name used to look up the field reflection object. */
-    public final String javaFieldName;
+    public final String fieldName;
 
-    /** The Painless type name for the field which can be used to look up the Java field through reflection. */
+    /** The canonical type name for the field which can be used to look up the Java field through reflection. */
-    public final String painlessFieldTypeName;
+    public final String canonicalTypeNameParameter;
 
     /** Standard constructor.  All values must be not {@code null}. */
-    public WhitelistField(String origin, String javaFieldName, String painlessFieldTypeName) {
+    public WhitelistField(String origin, String fieldName, String canonicalTypeNameParameter) {
         this.origin = Objects.requireNonNull(origin);
-        this.javaFieldName = Objects.requireNonNull(javaFieldName);
+        this.fieldName = Objects.requireNonNull(fieldName);
-        this.painlessFieldTypeName = Objects.requireNonNull(painlessFieldTypeName);
+        this.canonicalTypeNameParameter = Objects.requireNonNull(canonicalTypeNameParameter);
     }
 }

modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistLoader.java

@@ -35,14 +35,14 @@ import java.util.List;
 public final class WhitelistLoader {
 
     /**
-     * Loads and creates a {@link Whitelist} from one to many text files.  The file paths are passed in as an array of
+     * Loads and creates a {@link Whitelist} from one to many text files. The file paths are passed in as an array of
      * {@link String}s with a single {@link Class} to be be used to load the resources where each {@link String}
-     * is the path of a single text file.  The {@link Class}'s {@link ClassLoader} will be used to lookup the Java
+     * is the path of a single text file. The {@link Class}'s {@link ClassLoader} will be used to lookup the Java
      * reflection objects for each individual {@link Class}, {@link Constructor}, {@link Method}, and {@link Field}
      * specified as part of the whitelist in the text file.
      *
      * A single pass is made through each file to collect all the information about each class, constructor, method,
-     * and field.  Most validation will be done at a later point after all whitelists have been gathered and their
+     * and field. Most validation will be done at a later point after all whitelists have been gathered and their
      * merging takes place.
      *
      * A painless type name is one of the following:
@@ -52,7 +52,7 @@ public final class WhitelistLoader {
      *     <li> fully-qualified Java type name - Any whitelisted Java class will have the equivalent name as
      *     a Painless type name with the exception that any dollar symbols used as part of inner classes will
      *     be replaced with dot symbols. </li>
-     *     <li> short Java type name - The text after the final dot symbol of any specified Java class.  A
+     *     <li> short Java type name - The text after the final dot symbol of any specified Java class. A
      *     short type Java name may be excluded by using the 'only_fqn' token during Painless class parsing
      *     as described later. </li>
      * </ul>
@@ -60,7 +60,7 @@ public final class WhitelistLoader {
      * The following can be parsed from each whitelist text file:
      * <ul>
      *   <li> Blank lines will be ignored by the parser. </li>
-     *   <li> Comments may be created starting with a pound '#' symbol and end with a newline.  These will
+     *   <li> Comments may be created starting with a pound '#' symbol and end with a newline. These will
      *   be ignored by the parser. </li>
      *   <li> Primitive types may be specified starting with 'class' and followed by the Java type name,
      *   an opening bracket, a newline, a closing bracket, and a final newline. </li>
@@ -93,10 +93,10 @@ public final class WhitelistLoader {
      *
      * Note there must be a one-to-one correspondence of Painless type names to Java type/class names.
      * If the same Painless type is defined across multiple files and the Java class is the same, all
-     * specified constructors, methods, and fields will be merged into a single Painless type.  The
+     * specified constructors, methods, and fields will be merged into a single Painless type. The
      * Painless dynamic type, 'def', used as part of constructor, method, and field definitions will
-     * be appropriately parsed and handled.  Painless complex types must be specified with the
+     * be appropriately parsed and handled. Painless complex types must be specified with the
-     * fully-qualified Java class name.  Method argument types, method return types, and field types
+     * fully-qualified Java class name. Method argument types, method return types, and field types
      * must be specified with Painless type names (def, fully-qualified, or short) as described earlier.
      *
      * The following example is used to create a single whitelist text file:
@@ -132,7 +132,7 @@ public final class WhitelistLoader {
      * }
      */
     public static Whitelist loadFromResourceFiles(Class<?> resource, String... filepaths) {
-        List<WhitelistClass> whitelistStructs = new ArrayList<>();
+        List<WhitelistClass> whitelistClasses = new ArrayList<>();
 
         // Execute a single pass through the whitelist text files.  This will gather all the
         // constructors, methods, augmented methods, and fields for each whitelisted class.
@@ -143,7 +143,7 @@ public final class WhitelistLoader {
             try (LineNumberReader reader = new LineNumberReader(
                 new InputStreamReader(resource.getResourceAsStream(filepath), StandardCharsets.UTF_8))) {
 
-                String whitelistStructOrigin = null;
+                String whitelistClassOrigin = null;
                 String javaClassName = null;
                 boolean onlyFQNJavaClassName = false;
                 List<WhitelistConstructor> whitelistConstructors = null;
@@ -178,7 +178,7 @@ public final class WhitelistLoader {
                             throw new IllegalArgumentException("invalid class definition: failed to parse class name [" + line + "]");
                         }
 
-                        whitelistStructOrigin = "[" + filepath + "]:[" + number + "]";
+                        whitelistClassOrigin = "[" + filepath + "]:[" + number + "]";
                         javaClassName = tokens[0];
 
                         // Reset all the constructors, methods, and fields to support a new class.
@@ -194,11 +194,11 @@ public final class WhitelistLoader {
                             throw new IllegalArgumentException("invalid class definition: extraneous closing bracket");
                         }
 
-                        whitelistStructs.add(new WhitelistClass(whitelistStructOrigin, javaClassName, onlyFQNJavaClassName,
+                        whitelistClasses.add(new WhitelistClass(whitelistClassOrigin, javaClassName, onlyFQNJavaClassName,
                             whitelistConstructors, whitelistMethods, whitelistFields));
 
                         // Set all the variables to null to ensure a new class definition is found before other parsable values.
-                        whitelistStructOrigin = null;
+                        whitelistClassOrigin = null;
                         javaClassName = null;
                         onlyFQNJavaClassName = false;
                         whitelistConstructors = null;
@@ -300,7 +300,7 @@ public final class WhitelistLoader {
         }
         ClassLoader loader = AccessController.doPrivileged((PrivilegedAction<ClassLoader>)resource::getClassLoader);
 
-        return new Whitelist(loader, whitelistStructs);
+        return new Whitelist(loader, whitelistClasses);
     }
 
     private WhitelistLoader() {}

modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistMethod.java

@@ -25,52 +25,53 @@ import java.util.Objects;
 
 /**
  * Method represents the equivalent of a Java method available as a whitelisted class method
- * within Painless.  Methods for Painless classes may be accessed exactly as methods for Java classes
+ * within Painless. Methods for Painless classes may be accessed exactly as methods for Java classes
- * are using the '.' operator on an existing class variable/field.  Painless classes may have multiple
+ * are using the '.' operator on an existing class variable/field. Painless classes may have multiple
- * methods with the same name as long as they comply with arity overloading described for {@link WhitelistMethod}.
+ * methods with the same name as long as they comply with arity overloading described in
+ * {@link WhitelistClass}.
  *
  * Classes may also have additional methods that are not part of the Java class the class represents -
- * these are known as augmented methods.  An augmented method can be added to a class as a part of any
+ * these are known as augmented methods. An augmented method can be added to a class as a part of any
  * Java class as long as the method is static and the first parameter of the method is the Java class
- * represented by the class.  Note that the augmented method's parent Java class does not need to be
+ * represented by the class. Note that the augmented method's parent Java class does not need to be
  * whitelisted.
  */
 public class WhitelistMethod {
 
-    /** Information about where this method was whitelisted from.  Can be used for error messages. */
+    /** Information about where this method was whitelisted from. */
     public final String origin;
 
     /**
-     * The Java class name for the owner of an augmented method.  If the method is not augmented
+     * The class name for the owner of an augmented method. If the method is not augmented
      * this should be {@code null}.
      */
-    public final String javaAugmentedClassName;
+    public final String augmentedCanonicalClassName;
 
-    /** The Java method name used to look up the Java method through reflection. */
+    /** The method name used to look up the method reflection object. */
-    public final String javaMethodName;
+    public final String methodName;
 
     /**
-     * The Painless type name for the return type of the method which can be used to look up the Java
+     * The canonical type name for the return type.
-     * method through reflection.
      */
-    public final String painlessReturnTypeName;
+    public final String returnCanonicalTypeName;
 
     /**
-     * A {@link List} of {@link String}s that are the Painless type names for the parameters of the
+     * A {@link List} of {@link String}s that are the canonical type names for the parameters of the
-     * method which can be used to look up the Java method through reflection.
+     * method used to look up the method reflection object.
      */
-    public final List<String> painlessParameterTypeNames;
+    public final List<String> canonicalTypeNameParameters;
 
     /**
-     * Standard constructor. All values must be not {@code null} with the exception of jAugmentedClass;
+     * Standard constructor. All values must be not {@code null} with the exception of
-     * jAugmentedClass will be {@code null} unless the method is augmented as described in the class documentation.
+     * augmentedCanonicalClassName; augmentedCanonicalClassName will be {@code null} unless the method
+     * is augmented as described in the class documentation.
      */
-    public WhitelistMethod(String origin, String javaAugmentedClassName, String javaMethodName,
+    public WhitelistMethod(String origin, String augmentedCanonicalClassName, String methodName,
-                           String painlessReturnTypeName, List<String> painlessParameterTypeNames) {
+                           String returnCanonicalTypeName, List<String> canonicalTypeNameParameters) {
         this.origin = Objects.requireNonNull(origin);
-        this.javaAugmentedClassName = javaAugmentedClassName;
+        this.augmentedCanonicalClassName = augmentedCanonicalClassName;
-        this.javaMethodName = javaMethodName;
+        this.methodName = methodName;
-        this.painlessReturnTypeName = Objects.requireNonNull(painlessReturnTypeName);
+        this.returnCanonicalTypeName = Objects.requireNonNull(returnCanonicalTypeName);
-        this.painlessParameterTypeNames = Collections.unmodifiableList(Objects.requireNonNull(painlessParameterTypeNames));
+        this.canonicalTypeNameParameters = Collections.unmodifiableList(Objects.requireNonNull(canonicalTypeNameParameters));
     }
 }

modules/lang-painless/src/main/java/org/elasticsearch/painless/lookup/PainlessLookup.java

@@ -50,10 +50,10 @@ public final class PainlessLookup {
         return canonicalClassNamesToClasses.containsKey(canonicalClassName);
     }
 
-    public Class<?> canonicalTypeNameToType(String painlessType) {
+    public Class<?> canonicalTypeNameToType(String canonicalTypeName) {
-        Objects.requireNonNull(painlessType);
+        Objects.requireNonNull(canonicalTypeName);
 
-        return PainlessLookupUtility.canonicalTypeNameToType(painlessType, canonicalClassNamesToClasses);
+        return PainlessLookupUtility.canonicalTypeNameToType(canonicalTypeName, canonicalClassNamesToClasses);
     }
 
     public Set<Class<?>> getClasses() {
@@ -64,10 +64,10 @@ public final class PainlessLookup {
         return classesToPainlessClasses.get(targetClass);
     }
 
-    public PainlessConstructor lookupPainlessConstructor(String targetClassName, int constructorArity) {
+    public PainlessConstructor lookupPainlessConstructor(String targetCanonicalClassName, int constructorArity) {
-        Objects.requireNonNull(targetClassName);
+        Objects.requireNonNull(targetCanonicalClassName);
 
-        Class<?> targetClass = canonicalTypeNameToType(targetClassName);
+        Class<?> targetClass = canonicalTypeNameToType(targetCanonicalClassName);
 
         if (targetClass == null) {
             return null;
@@ -95,10 +95,10 @@ public final class PainlessLookup {
         return painlessConstructor;
     }
 
-    public PainlessMethod lookupPainlessMethod(String targetClassName, boolean isStatic, String methodName, int methodArity) {
+    public PainlessMethod lookupPainlessMethod(String targetCanonicalClassName, boolean isStatic, String methodName, int methodArity) {
-        Objects.requireNonNull(targetClassName);
+        Objects.requireNonNull(targetCanonicalClassName);
 
-        Class<?> targetClass = canonicalTypeNameToType(targetClassName);
+        Class<?> targetClass = canonicalTypeNameToType(targetCanonicalClassName);
 
         if (targetClass == null) {
             return null;
@@ -127,10 +127,10 @@ public final class PainlessLookup {
                 targetPainlessClass.methods.get(painlessMethodKey);
     }
 
-    public PainlessField lookupPainlessField(String targetClassName, boolean isStatic, String fieldName) {
+    public PainlessField lookupPainlessField(String targetCanonicalClassName, boolean isStatic, String fieldName) {
-        Objects.requireNonNull(targetClassName);
+        Objects.requireNonNull(targetCanonicalClassName);
 
-        Class<?> targetClass = canonicalTypeNameToType(targetClassName);
+        Class<?> targetClass = canonicalTypeNameToType(targetCanonicalClassName);
 
         if (targetClass == null) {
             return null;
@@ -199,9 +199,7 @@ public final class PainlessLookup {
         return lookupRuntimePainlessObject(originalTargetClass, objectLookup);
     }
 
-    private <T> T lookupRuntimePainlessObject(
+    private <T> T lookupRuntimePainlessObject(Class<?> originalTargetClass, Function<PainlessClass, T> objectLookup) {
-            Class<?> originalTargetClass, Function<PainlessClass, T> objectLookup) {
-
         Class<?> currentTargetClass = originalTargetClass;
 
         while (currentTargetClass != null) {

modules/lang-painless/src/main/java/org/elasticsearch/painless/lookup/PainlessLookupBuilder.java

@@ -166,35 +166,35 @@ public final class PainlessLookupBuilder {
 
         try {
             for (Whitelist whitelist : whitelists) {
-                for (WhitelistClass whitelistClass : whitelist.whitelistStructs) {
+                for (WhitelistClass whitelistClass : whitelist.whitelistClasses) {
                     origin = whitelistClass.origin;
                     painlessLookupBuilder.addPainlessClass(
-                            whitelist.javaClassLoader, whitelistClass.javaClassName, whitelistClass.onlyFQNJavaClassName == false);
+                            whitelist.classLoader, whitelistClass.javaClassName, whitelistClass.noImport == false);
                 }
             }
 
             for (Whitelist whitelist : whitelists) {
-                for (WhitelistClass whitelistClass : whitelist.whitelistStructs) {
+                for (WhitelistClass whitelistClass : whitelist.whitelistClasses) {
                     String targetCanonicalClassName = whitelistClass.javaClassName.replace('$', '.');
 
                     for (WhitelistConstructor whitelistConstructor : whitelistClass.whitelistConstructors) {
                         origin = whitelistConstructor.origin;
                         painlessLookupBuilder.addPainlessConstructor(
-                                targetCanonicalClassName, whitelistConstructor.painlessParameterTypeNames);
+                                targetCanonicalClassName, whitelistConstructor.canonicalTypeNameParameters);
                     }
 
                     for (WhitelistMethod whitelistMethod : whitelistClass.whitelistMethods) {
                         origin = whitelistMethod.origin;
                         painlessLookupBuilder.addPainlessMethod(
-                                whitelist.javaClassLoader, targetCanonicalClassName, whitelistMethod.javaAugmentedClassName,
+                                whitelist.classLoader, targetCanonicalClassName, whitelistMethod.augmentedCanonicalClassName,
-                                whitelistMethod.javaMethodName, whitelistMethod.painlessReturnTypeName,
+                                whitelistMethod.methodName, whitelistMethod.returnCanonicalTypeName,
-                                whitelistMethod.painlessParameterTypeNames);
+                                whitelistMethod.canonicalTypeNameParameters);
                     }
 
                     for (WhitelistField whitelistField : whitelistClass.whitelistFields) {
                         origin = whitelistField.origin;
                         painlessLookupBuilder.addPainlessField(
-                                targetCanonicalClassName, whitelistField.javaFieldName, whitelistField.painlessFieldTypeName);
+                                targetCanonicalClassName, whitelistField.fieldName, whitelistField.canonicalTypeNameParameter);
                     }
                 }
             }
@@ -315,25 +315,25 @@ public final class PainlessLookupBuilder {
         }
     }
 
-    public void addPainlessConstructor(String targetCanonicalClassName, List<String> typeNameParameters) {
+    public void addPainlessConstructor(String targetCanonicalClassName, List<String> canonicalTypeNameParameters) {
         Objects.requireNonNull(targetCanonicalClassName);
-        Objects.requireNonNull(typeNameParameters);
+        Objects.requireNonNull(canonicalTypeNameParameters);
 
         Class<?> targetClass = canonicalClassNamesToClasses.get(targetCanonicalClassName);
 
         if (targetClass == null) {
             throw new IllegalArgumentException("target class [" + targetCanonicalClassName + "] not found" +
-                    "for constructor [[" + targetCanonicalClassName + "], " + typeNameParameters  + "]");
+                    "for constructor [[" + targetCanonicalClassName + "], " + canonicalTypeNameParameters  + "]");
         }
 
-        List<Class<?>> typeParameters = new ArrayList<>(typeNameParameters.size());
+        List<Class<?>> typeParameters = new ArrayList<>(canonicalTypeNameParameters.size());
 
-        for (String typeNameParameter : typeNameParameters) {
+        for (String canonicalTypeNameParameter : canonicalTypeNameParameters) {
-            Class<?> typeParameter = canonicalTypeNameToType(typeNameParameter);
+            Class<?> typeParameter = canonicalTypeNameToType(canonicalTypeNameParameter);
 
             if (typeParameter == null) {
-                throw new IllegalArgumentException("type parameter [" + typeNameParameter + "] not found " +
+                throw new IllegalArgumentException("type parameter [" + canonicalTypeNameParameter + "] not found " +
-                        "for constructor [[" + targetCanonicalClassName + "], " + typeNameParameters  + "]");
+                        "for constructor [[" + targetCanonicalClassName + "], " + canonicalTypeNameParameters  + "]");
             }
 
             typeParameters.add(typeParameter);
@@ -409,19 +409,19 @@ public final class PainlessLookupBuilder {
     }
 
     public void addPainlessMethod(ClassLoader classLoader, String targetCanonicalClassName, String augmentedCanonicalClassName,
-            String methodName, String returnCanonicalTypeName, List<String> typeNameParameters) {
+            String methodName, String returnCanonicalTypeName, List<String> canonicalTypeNameParameters) {
 
         Objects.requireNonNull(classLoader);
         Objects.requireNonNull(targetCanonicalClassName);
         Objects.requireNonNull(methodName);
         Objects.requireNonNull(returnCanonicalTypeName);
-        Objects.requireNonNull(typeNameParameters);
+        Objects.requireNonNull(canonicalTypeNameParameters);
 
         Class<?> targetClass = canonicalClassNamesToClasses.get(targetCanonicalClassName);
 
         if (targetClass == null) {
             throw new IllegalArgumentException("target class [" + targetCanonicalClassName + "] not found for method " +
-                    "[[" + targetCanonicalClassName + "], [" + methodName + "], " + typeNameParameters + "]");
+                    "[[" + targetCanonicalClassName + "], [" + methodName + "], " + canonicalTypeNameParameters + "]");
         }
 
         Class<?> augmentedClass = null;
@@ -431,18 +431,18 @@ public final class PainlessLookupBuilder {
                 augmentedClass = Class.forName(augmentedCanonicalClassName, true, classLoader);
             } catch (ClassNotFoundException cnfe) {
                 throw new IllegalArgumentException("augmented class [" + augmentedCanonicalClassName + "] not found for method " +
-                        "[[" + targetCanonicalClassName + "], [" + methodName + "], " + typeNameParameters + "]", cnfe);
+                        "[[" + targetCanonicalClassName + "], [" + methodName + "], " + canonicalTypeNameParameters + "]", cnfe);
             }
         }
 
-        List<Class<?>> typeParameters = new ArrayList<>(typeNameParameters.size());
+        List<Class<?>> typeParameters = new ArrayList<>(canonicalTypeNameParameters.size());
 
-        for (String typeNameParameter : typeNameParameters) {
+        for (String canonicalTypeNameParameter : canonicalTypeNameParameters) {
-            Class<?> typeParameter = canonicalTypeNameToType(typeNameParameter);
+            Class<?> typeParameter = canonicalTypeNameToType(canonicalTypeNameParameter);
 
             if (typeParameter == null) {
-                throw new IllegalArgumentException("parameter type [" + typeNameParameter + "] not found for method " +
+                throw new IllegalArgumentException("parameter type [" + canonicalTypeNameParameter + "] not found for method " +
-                        "[[" + targetCanonicalClassName + "], [" + methodName + "], " + typeNameParameters + "]");
+                        "[[" + targetCanonicalClassName + "], [" + methodName + "], " + canonicalTypeNameParameters + "]");
             }
 
             typeParameters.add(typeParameter);
@@ -452,7 +452,7 @@ public final class PainlessLookupBuilder {
 
         if (returnType == null) {
             throw new IllegalArgumentException("parameter type [" + returnCanonicalTypeName + "] not found for method " +
-                    "[[" + targetCanonicalClassName + "], [" + methodName + "], " + typeNameParameters + "]");
+                    "[[" + targetCanonicalClassName + "], [" + methodName + "], " + canonicalTypeNameParameters + "]");
         }
 
         addPainlessMethod(targetClass, augmentedClass, methodName, returnType, typeParameters);
@@ -607,10 +607,10 @@ public final class PainlessLookupBuilder {
         }
     }
 
-    public void addPainlessField(String targetCanonicalClassName, String fieldName, String typeNameParameter) {
+    public void addPainlessField(String targetCanonicalClassName, String fieldName, String canonicalTypeNameParameter) {
         Objects.requireNonNull(targetCanonicalClassName);
         Objects.requireNonNull(fieldName);
-        Objects.requireNonNull(typeNameParameter);
+        Objects.requireNonNull(canonicalTypeNameParameter);
 
         Class<?> targetClass = canonicalClassNamesToClasses.get(targetCanonicalClassName);
 
@@ -618,10 +618,10 @@ public final class PainlessLookupBuilder {
             throw new IllegalArgumentException("class [" + targetCanonicalClassName + "] not found");
         }
 
-        Class<?> typeParameter = canonicalTypeNameToType(typeNameParameter);
+        Class<?> typeParameter = canonicalTypeNameToType(canonicalTypeNameParameter);
 
         if (typeParameter == null) {
-            throw new IllegalArgumentException("type parameter [" + typeNameParameter + "] not found " +
+            throw new IllegalArgumentException("type parameter [" + canonicalTypeNameParameter + "] not found " +
                     "for field [[" + targetCanonicalClassName + "], [" + fieldName + "]");
         }