From 47d2bcc3c4c5224dbda4770a0957fa3a289cc422 Mon Sep 17 00:00:00 2001 From: Jack Conradson Date: Fri, 10 Aug 2018 14:46:31 -0700 Subject: [PATCH] Painless: Clean Up Whitelist Names (#32791) Renames variables in the whitelists to match the current naming scheme. Mechanical change. --- .../elasticsearch/painless/spi/Whitelist.java | 12 ++-- .../painless/spi/WhitelistClass.java | 11 ++-- .../painless/spi/WhitelistConstructor.java | 12 ++-- .../painless/spi/WhitelistField.java | 18 +++--- .../painless/spi/WhitelistLoader.java | 28 ++++----- .../painless/spi/WhitelistMethod.java | 49 +++++++-------- .../painless/lookup/PainlessLookup.java | 28 ++++----- .../lookup/PainlessLookupBuilder.java | 60 +++++++++---------- 8 files changed, 109 insertions(+), 109 deletions(-) diff --git a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/Whitelist.java b/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/Whitelist.java index 55b64b0420d..c38325edd14 100644 --- a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/Whitelist.java +++ b/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 whitelistStructs; + public final List whitelistClasses; /** Standard constructor. All values must be not {@code null}. */ - public Whitelist(ClassLoader javaClassLoader, List whitelistStructs) { - this.javaClassLoader = Objects.requireNonNull(javaClassLoader); - this.whitelistStructs = Collections.unmodifiableList(Objects.requireNonNull(whitelistStructs)); + public Whitelist(ClassLoader classLoader, List whitelistClasses) { + this.classLoader = Objects.requireNonNull(classLoader); + this.whitelistClasses = Collections.unmodifiableList(Objects.requireNonNull(whitelistClasses)); } } diff --git a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistClass.java b/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistClass.java index 12aa5f5bdd6..0b216ae5c29 100644 --- a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistClass.java +++ b/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 whitelistConstructors; @@ -61,13 +61,14 @@ public final class WhitelistClass { public final List 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 whitelistConstructors, List whitelistMethods, List 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)); diff --git a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistConstructor.java b/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistConstructor.java index 0e705527602..032ef397def 100644 --- a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistConstructor.java +++ b/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 - * constructors for Java classes are using the 'new' keyword. Painless classes may have multiple + * 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 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 painlessParameterTypeNames; + public final List canonicalTypeNameParameters; /** Standard constructor. All values must be not {@code null}. */ - public WhitelistConstructor(String origin, List painlessParameterTypeNames) { + public WhitelistConstructor(String origin, List canonicalTypeNameParameters) { this.origin = Objects.requireNonNull(origin); - this.painlessParameterTypeNames = Collections.unmodifiableList(Objects.requireNonNull(painlessParameterTypeNames)); + this.canonicalTypeNameParameters = Collections.unmodifiableList(Objects.requireNonNull(canonicalTypeNameParameters)); } } diff --git a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistField.java b/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistField.java index 116aea98fcf..44ed31a227e 100644 --- a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistField.java +++ b/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. */ - public final String javaFieldName; + /** The field name used to look up the field reflection object. */ + public final String fieldName; - /** The Painless type name for the field which can be used to look up the Java field through reflection. */ - public final String painlessFieldTypeName; + /** The canonical type name for the field which can be used to look up the Java field through reflection. */ + 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.painlessFieldTypeName = Objects.requireNonNull(painlessFieldTypeName); + this.fieldName = Objects.requireNonNull(fieldName); + this.canonicalTypeNameParameter = Objects.requireNonNull(canonicalTypeNameParameter); } } diff --git a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistLoader.java b/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistLoader.java index b104d03f1ea..c59023b8622 100644 --- a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistLoader.java +++ b/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 { *
  • 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.
    • - *
  • short Java type name - The text after the final dot symbol of any specified Java class. A + *
  • 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.
    • * @@ -60,7 +60,7 @@ public final class WhitelistLoader { * The following can be parsed from each whitelist text file: *
      *
    • Blank lines will be ignored by the parser.
      • - *
    • Comments may be created starting with a pound '#' symbol and end with a newline. These will + *
    • Comments may be created starting with a pound '#' symbol and end with a newline. These will * be ignored by the parser.
      • *
    • 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.
      • @@ -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 - * fully-qualified Java class name. Method argument types, method return types, and field types + * 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 * 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 whitelistStructs = new ArrayList<>(); + List 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 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)resource::getClassLoader); - return new Whitelist(loader, whitelistStructs); + return new Whitelist(loader, whitelistClasses); } private WhitelistLoader() {} diff --git a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistMethod.java b/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistMethod.java index df86619055b..5cd023a3591 100644 --- a/modules/lang-painless/spi/src/main/java/org/elasticsearch/painless/spi/WhitelistMethod.java +++ b/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 - * 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}. + * 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 + * 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. */ - public final String javaMethodName; + /** The method name used to look up the method reflection object. */ + public final String methodName; /** - * The Painless type name for the return type of the method which can be used to look up the Java - * method through reflection. + * The canonical type name for the return type. */ - 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 - * method which can be used to look up the Java method through reflection. + * A {@link List} of {@link String}s that are the canonical type names for the parameters of the + * method used to look up the method reflection object. */ - public final List painlessParameterTypeNames; + public final List canonicalTypeNameParameters; /** - * Standard constructor. All values must be not {@code null} with the exception of jAugmentedClass; - * jAugmentedClass will be {@code null} unless the method is augmented as described in the class documentation. + * Standard constructor. All values must be not {@code null} with the exception of + * 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, - String painlessReturnTypeName, List painlessParameterTypeNames) { + public WhitelistMethod(String origin, String augmentedCanonicalClassName, String methodName, + String returnCanonicalTypeName, List canonicalTypeNameParameters) { this.origin = Objects.requireNonNull(origin); - this.javaAugmentedClassName = javaAugmentedClassName; - this.javaMethodName = javaMethodName; - this.painlessReturnTypeName = Objects.requireNonNull(painlessReturnTypeName); - this.painlessParameterTypeNames = Collections.unmodifiableList(Objects.requireNonNull(painlessParameterTypeNames)); + this.augmentedCanonicalClassName = augmentedCanonicalClassName; + this.methodName = methodName; + this.returnCanonicalTypeName = Objects.requireNonNull(returnCanonicalTypeName); + this.canonicalTypeNameParameters = Collections.unmodifiableList(Objects.requireNonNull(canonicalTypeNameParameters)); } } diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/lookup/PainlessLookup.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/lookup/PainlessLookup.java index 49ba524bff2..16b8ac14f14 100644 --- a/modules/lang-painless/src/main/java/org/elasticsearch/painless/lookup/PainlessLookup.java +++ b/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) { - Objects.requireNonNull(painlessType); + public Class canonicalTypeNameToType(String canonicalTypeName) { + Objects.requireNonNull(canonicalTypeName); - return PainlessLookupUtility.canonicalTypeNameToType(painlessType, canonicalClassNamesToClasses); + return PainlessLookupUtility.canonicalTypeNameToType(canonicalTypeName, canonicalClassNamesToClasses); } public Set> getClasses() { @@ -64,10 +64,10 @@ public final class PainlessLookup { return classesToPainlessClasses.get(targetClass); } - public PainlessConstructor lookupPainlessConstructor(String targetClassName, int constructorArity) { - Objects.requireNonNull(targetClassName); + public PainlessConstructor lookupPainlessConstructor(String targetCanonicalClassName, int constructorArity) { + 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) { - Objects.requireNonNull(targetClassName); + public PainlessMethod lookupPainlessMethod(String targetCanonicalClassName, boolean isStatic, String methodName, int methodArity) { + 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) { - Objects.requireNonNull(targetClassName); + public PainlessField lookupPainlessField(String targetCanonicalClassName, boolean isStatic, String fieldName) { + 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 lookupRuntimePainlessObject( - Class originalTargetClass, Function objectLookup) { - + private T lookupRuntimePainlessObject(Class originalTargetClass, Function objectLookup) { Class currentTargetClass = originalTargetClass; while (currentTargetClass != null) { diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/lookup/PainlessLookupBuilder.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/lookup/PainlessLookupBuilder.java index e17a01941bc..0346867d35a 100644 --- a/modules/lang-painless/src/main/java/org/elasticsearch/painless/lookup/PainlessLookupBuilder.java +++ b/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, - whitelistMethod.javaMethodName, whitelistMethod.painlessReturnTypeName, - whitelistMethod.painlessParameterTypeNames); + whitelist.classLoader, targetCanonicalClassName, whitelistMethod.augmentedCanonicalClassName, + whitelistMethod.methodName, whitelistMethod.returnCanonicalTypeName, + 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 typeNameParameters) { + public void addPainlessConstructor(String targetCanonicalClassName, List 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> typeParameters = new ArrayList<>(typeNameParameters.size()); + List> typeParameters = new ArrayList<>(canonicalTypeNameParameters.size()); - for (String typeNameParameter : typeNameParameters) { - Class typeParameter = canonicalTypeNameToType(typeNameParameter); + for (String canonicalTypeNameParameter : canonicalTypeNameParameters) { + Class typeParameter = canonicalTypeNameToType(canonicalTypeNameParameter); if (typeParameter == null) { - throw new IllegalArgumentException("type parameter [" + typeNameParameter + "] not found " + - "for constructor [[" + targetCanonicalClassName + "], " + typeNameParameters + "]"); + throw new IllegalArgumentException("type parameter [" + canonicalTypeNameParameter + "] not found " + + "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 typeNameParameters) { + String methodName, String returnCanonicalTypeName, List 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> typeParameters = new ArrayList<>(typeNameParameters.size()); + List> typeParameters = new ArrayList<>(canonicalTypeNameParameters.size()); - for (String typeNameParameter : typeNameParameters) { - Class typeParameter = canonicalTypeNameToType(typeNameParameter); + for (String canonicalTypeNameParameter : canonicalTypeNameParameters) { + Class typeParameter = canonicalTypeNameToType(canonicalTypeNameParameter); if (typeParameter == null) { - throw new IllegalArgumentException("parameter type [" + typeNameParameter + "] not found for method " + - "[[" + targetCanonicalClassName + "], [" + methodName + "], " + typeNameParameters + "]"); + throw new IllegalArgumentException("parameter type [" + canonicalTypeNameParameter + "] not found for method " + + "[[" + 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 + "]"); }