Painless: Clean Up Whitelist Names (#32791)

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

Author: jdconrad

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

@@ -28,7 +28,7 @@
  * 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) {
-        this.javaClassLoader = Objects.requireNonNull(javaClassLoader);
-        this.whitelistStructs = Collections.unmodifiableList(Objects.requireNonNull(whitelistStructs));
+    public Whitelist(ClassLoader classLoader, List<WhitelistClass> whitelistClasses) {
+        this.classLoader = Objects.requireNonNull(classLoader);
+        this.whitelistClasses = Collections.unmodifiableList(Objects.requireNonNull(whitelistClasses));
     }
 }

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

@@ -30,7 +30,7 @@
  * 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 @@
  */
 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 @@
 
 /**
  * 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<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 @@
 
 /**
  * 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);
     }
 }

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

@@ -35,14 +35,14 @@
 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,15 +52,15 @@ 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>
      *
      * 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
-     * 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<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 static Whitelist loadFromResourceFiles(Class<?> resource, String... filep
             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 static Whitelist loadFromResourceFiles(Class<?> resource, String... filep
                             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 static Whitelist loadFromResourceFiles(Class<?> resource, String... filep
                             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 static Whitelist loadFromResourceFiles(Class<?> resource, String... filep
         }
         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 @@
 
 /**
  * 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<String> painlessParameterTypeNames;
+    public final List<String> 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<String> painlessParameterTypeNames) {
+    public WhitelistMethod(String origin, String augmentedCanonicalClassName, String methodName,
+                           String returnCanonicalTypeName, List<String> 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));
     }
 }