Respond to most deprecation warnings from Java runtime (up to Java 9).

jeff5 · jeff5 · commit bec628f5b451 · 2018-12-27T16:32:55.000Z
The motivation is to reduce noise in the build so we can see when
things go wrong.

Although widespread, all are one of 2 simple types. Class.newInstance
becomes Class.getDeclaredConstructor().newInstance(), and for a
primitive wrapper T.valueOf(x) is preferred to new T(x).
diff --git a/src/com/ziclix/python/sql/DataHandler.java b/src/com/ziclix/python/sql/DataHandler.java
@@ -331,14 +331,14 @@ public PyObject getPyObject(ResultSet set, int col, int type) throws SQLExceptio
                 throw createUnsupportedTypeSQLException("STRUCT", col);
                 
             default :
-                throw createUnsupportedTypeSQLException(new Integer(type), col);
+                throw createUnsupportedTypeSQLException(Integer.valueOf(type), col);
         }
 
         return set.wasNull() || obj == null ? Py.None : obj;
     }
 
     protected final SQLException createUnsupportedTypeSQLException(Object type, int col) {
-        Object[] vals = {type, new Integer(col)};
+        Object[] vals = {type, Integer.valueOf(col)};
         String msg = zxJDBC.getString("unsupportedTypeForColumn", vals);
         return new SQLException(msg);
     }
diff --git a/src/com/ziclix/python/sql/Jython22DataHandler.java b/src/com/ziclix/python/sql/Jython22DataHandler.java
@@ -313,7 +313,7 @@ public PyObject getPyObject(ResultSet set, int col, int type) throws SQLExceptio
                 break;
 
             default :
-                throw createUnsupportedTypeSQLException(new Integer(type), col);
+                throw createUnsupportedTypeSQLException(Integer.valueOf(type), col);
         }
 
         return (set.wasNull() || (obj == null)) ? Py.None : obj;
@@ -401,7 +401,7 @@ public PyObject getPyObject(CallableStatement stmt, int col, int type) throws SQ
                 break;
 
             default :
-                throw createUnsupportedTypeSQLException(new Integer(type), col);
+                throw createUnsupportedTypeSQLException(Integer.valueOf(type), col);
         }
 
         return (stmt.wasNull() || (obj == null)) ? Py.None : obj;
diff --git a/src/com/ziclix/python/sql/connect/Connectx.java b/src/com/ziclix/python/sql/connect/Connectx.java
@@ -58,7 +58,7 @@ public PyObject __call__(PyObject[] args, String[] keywords) {
 
         try {
             String klass = (String) parser.arg(0).__tojava__(String.class);
-            datasource = Class.forName(klass).newInstance();
+            datasource = Class.forName(klass).getDeclaredConstructor().newInstance();
         } catch (Exception e) {
             throw zxJDBC.makeException(zxJDBC.DatabaseError, "unable to instantiate datasource");
         }
diff --git a/src/com/ziclix/python/sql/pipe/Pipe.java b/src/com/ziclix/python/sql/pipe/Pipe.java
@@ -87,8 +87,8 @@ public PyObject pipe(Source source, Sink sink) {
         // the purpose of the assert, but there's no need to create the buffer if I don't need it and I still
         // want to throw the AssertionError if required
         if ((sourceRunner.getCount() - sinkRunner.getCount()) != 0) {
-            Integer[] counts = {new Integer(sourceRunner.getCount()),
-                                new Integer(sinkRunner.getCount())};
+            Integer[] counts = {Integer.valueOf(sourceRunner.getCount()),
+                                Integer.valueOf(sinkRunner.getCount())};
             String msg = zxJDBC.getString("inconsistentRowCount", counts);
 
             Py.assert_(Py.Zero, Py.newString(msg));
diff --git a/src/com/ziclix/python/sql/zxJDBC.java b/src/com/ziclix/python/sql/zxJDBC.java
@@ -223,7 +223,8 @@ protected static void _addConnectors(PyObject dict) throws PyException {
             String className = props.getProperty(name).trim();
 
             try {
-                connector = (PyObject) Class.forName(className).newInstance();
+                connector =
+                        (PyObject) Class.forName(className).getDeclaredConstructor().newInstance();
                 dict.__setitem__(name, connector);
                 Py.writeComment("zxJDBC", "loaded connector [" + className + "] as [" + name
                                 + "]");
diff --git a/src/org/python/compiler/ClassFile.java b/src/org/python/compiler/ClassFile.java
@@ -243,11 +243,11 @@ public void write(OutputStream stream)
         AnnotationVisitor av = cw.visitAnnotation("Lorg/python/compiler/APIVersion;", true);
         // XXX: should imp.java really house this value or should imp.java point into
         // org.python.compiler?
-        av.visit("value", new Integer(imp.getAPIVersion()));
+        av.visit("value", Integer.valueOf(imp.getAPIVersion()));
         av.visitEnd();
 
         av = cw.visitAnnotation("Lorg/python/compiler/MTime;", true);
-        av.visit("value", new Long(mtime));
+        av.visit("value", Long.valueOf(mtime));
         av.visitEnd();
 
         if (sfilenameShort != null) {
diff --git a/src/org/python/compiler/CodeCompiler.java b/src/org/python/compiler/CodeCompiler.java
@@ -105,7 +105,7 @@
 
 public class CodeCompiler extends Visitor implements Opcodes, ClassConstants {
 
-    private static final Object Exit = new Integer(1);
+    private static final Object Exit = Integer.valueOf(1);
     private static final Object NoExit = null;
     private Module module;
     private Code code;
diff --git a/src/org/python/compiler/LineNumberTable.java b/src/org/python/compiler/LineNumberTable.java
@@ -32,8 +32,8 @@ public void write(DataOutputStream stream) throws IOException {
     }
 
     public void addLine(int startpc, int lineno) {
-        lines.addElement(new Short((short) startpc));
-        lines.addElement(new Short((short) lineno));
+        lines.addElement(Short.valueOf((short) startpc));
+        lines.addElement(Short.valueOf((short) lineno));
     }
 
     public int length() {
diff --git a/src/org/python/compiler/Module.java b/src/org/python/compiler/Module.java
@@ -97,7 +97,7 @@ class PyFloatConstant extends Constant implements ClassConstants, Opcodes {
 
     @Override
     void get(Code c) throws IOException {
-        c.ldc(new Double(value));
+        c.ldc(Double.valueOf(value));
         c.invokestatic(p(Py.class), "newFloat", sig(PyFloat.class, Double.TYPE));
     }
 
@@ -132,7 +132,7 @@ class PyComplexConstant extends Constant implements ClassConstants, Opcodes {
 
     @Override
     void get(Code c) throws IOException {
-        c.ldc(new Double(value));
+        c.ldc(Double.valueOf(value));
         c.invokestatic(p(Py.class), "newImaginary", sig(PyComplex.class, Double.TYPE));
     }
 
diff --git a/src/org/python/core/JavaProxyList.java b/src/org/python/core/JavaProxyList.java
@@ -1,12 +1,5 @@
 package org.python.core;
 
-/**
- * Proxy Java objects implementing java.util.List with Python methods
- * corresponding to the standard list type
- */
-
-import org.python.util.Generic;
-
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -16,7 +9,12 @@
 import java.util.List;
 import java.util.ListIterator;
 
+import org.python.util.Generic;
 
+/**
+ * Proxy Java objects implementing java.util.List with Python methods corresponding to the standard
+ * list type
+ */
 class JavaProxyList {
 
     @Untraversable
@@ -35,10 +33,9 @@ protected List asList() {
 
         protected List newList() {
             try {
-                return (List) asList().getClass().newInstance();
-            } catch (IllegalAccessException e) {
-                throw Py.JavaError(e);
-            } catch (InstantiationException e) {
+                return (List) asList().getClass().getDeclaredConstructor().newInstance();
+            } catch (ReflectiveOperationException | SecurityException
+                    | IllegalArgumentException e) {
                 throw Py.JavaError(e);
             }
         }
@@ -131,8 +128,9 @@ public PyObject getSlice(int start, int stop, int step) {
             int n = PySequence.sliceLength(start, stop, step);
             List newList;
             try {
-                newList = list.getClass().newInstance();
-            } catch (Exception e) {
+                newList = list.getClass().getDeclaredConstructor().newInstance();
+            } catch (ReflectiveOperationException | SecurityException
+                    | IllegalArgumentException e) {
                 throw Py.JavaError(e);
             }
             int j = 0;
@@ -556,10 +554,9 @@ public PyObject __call__(PyObject obj) {
             List jList = asList();
             List jClone;
             try {
-                jClone = (List) jList.getClass().newInstance();
-            } catch (IllegalAccessException e) {
-                throw Py.JavaError(e);
-            } catch (InstantiationException e) {
+                jClone = (List) jList.getClass().getDeclaredConstructor().newInstance();
+            } catch (ReflectiveOperationException | SecurityException
+                    | IllegalArgumentException e) {
                 throw Py.JavaError(e);
             }
             for (Object entry : jList) {
diff --git a/src/org/python/core/JavaProxyMap.java b/src/org/python/core/JavaProxyMap.java
@@ -398,10 +398,10 @@ public PyObject __call__() {
             Map<Object, Object> jmap = asMap();
             Map<Object, Object> jclone;
             try {
-                jclone = (Map<Object, Object>) jmap.getClass().newInstance();
-            } catch (IllegalAccessException e) {
-                throw Py.JavaError(e);
-            } catch (InstantiationException e) {
+                jclone = (Map<Object, Object>) jmap.getClass().getDeclaredConstructor()
+                        .newInstance();
+            } catch (ReflectiveOperationException | SecurityException
+                    | IllegalArgumentException e) {
                 throw Py.JavaError(e);
             }
             for (Map.Entry<Object, Object> entry : jmap.entrySet()) {
@@ -514,14 +514,14 @@ public PyObject __call__(PyObject keys, PyObject _default) {
                  * always injected to java.util.Map, so we know the class object we get from
                  * asClass is subtype of java.util.Map
                  */
-                Map<Object, Object> theMap = (Map<Object, Object>) theClass.newInstance();
+                Map<Object, Object> theMap = (Map<Object, Object>) theClass
+                        .getDeclaredConstructor().newInstance();
                 for (PyObject key : keys.asIterable()) {
                     theMap.put(Py.tojava(key, Object.class), defobj);
                 }
                 return Py.java2py(theMap);
-            } catch (InstantiationException e) {
-                throw Py.JavaError(e);
-            } catch (IllegalAccessException e) {
+            } catch (ReflectiveOperationException | SecurityException
+                    | IllegalArgumentException e) {
                 throw Py.JavaError(e);
             }
         }
diff --git a/src/org/python/core/PyBeanEventProperty.java b/src/org/python/core/PyBeanEventProperty.java
@@ -114,7 +114,7 @@ private synchronized Object getAdapter(Object self) {
             return adapter;
         }
         try {
-            adapter = adapterClass.newInstance();
+            adapter = adapterClass.getDeclaredConstructor().newInstance();
             addMethod.invoke(self, adapter);
         } catch (Exception e) {
             throw Py.JavaError(e);
diff --git a/src/org/python/core/PyFloat.java b/src/org/python/core/PyFloat.java
@@ -301,9 +301,9 @@ final boolean float___nonzero__() {
     public Object __tojava__(Class<?> c) {
         if (c == Double.TYPE || c == Number.class || c == Double.class || c == Object.class
                 || c == Serializable.class) {
-            return new Double(getValue());
+            return Double.valueOf(getValue());
         } else if (c == Float.TYPE || c == Float.class) {
-            return new Float(getValue());
+            return Float.valueOf((float) getValue());
         }
         return super.__tojava__(c);
     }
diff --git a/src/org/python/core/PyInteger.java b/src/org/python/core/PyInteger.java
@@ -226,27 +226,27 @@ final boolean int___nonzero__() {
     public Object __tojava__(Class<?> c) {
         if (c == Integer.TYPE || c == Number.class || c == Object.class || c == Integer.class
                 || c == Serializable.class) {
-            return new Integer(getValue());
+            return Integer.valueOf(getValue());
         }
 
         if (c == Boolean.TYPE || c == Boolean.class) {
-            return new Boolean(getValue() != 0);
+            return Boolean.valueOf(getValue() != 0);
         }
         if (c == Byte.TYPE || c == Byte.class) {
-            return new Byte((byte)getValue());
+            return Byte.valueOf((byte)getValue());
         }
         if (c == Short.TYPE || c == Short.class) {
-            return new Short((short)getValue());
+            return Short.valueOf((short)getValue());
         }
 
         if (c == Long.TYPE || c == Long.class) {
-            return new Long(getValue());
+            return Long.valueOf(getValue());
         }
         if (c == Float.TYPE || c == Float.class) {
-            return new Float(getValue());
+            return Float.valueOf(getValue());
         }
         if (c == Double.TYPE || c == Double.class) {
-            return new Double(getValue());
+            return Double.valueOf(getValue());
         }
         return super.__tojava__(c);
     }
diff --git a/src/org/python/core/PyLong.java b/src/org/python/core/PyLong.java
@@ -296,19 +296,19 @@ public long asLong() {
     public Object __tojava__(Class<?> c) {
         try {
             if (c == Boolean.TYPE || c == Boolean.class) {
-                return new Boolean(!getValue().equals(BigInteger.ZERO));
+                return Boolean.valueOf(!getValue().equals(BigInteger.ZERO));
             }
             if (c == Byte.TYPE || c == Byte.class) {
-                return new Byte((byte)getLong(Byte.MIN_VALUE, Byte.MAX_VALUE));
+                return Byte.valueOf((byte)getLong(Byte.MIN_VALUE, Byte.MAX_VALUE));
             }
             if (c == Short.TYPE || c == Short.class) {
-                return new Short((short)getLong(Short.MIN_VALUE, Short.MAX_VALUE));
+                return Short.valueOf((short)getLong(Short.MIN_VALUE, Short.MAX_VALUE));
             }
             if (c == Integer.TYPE || c == Integer.class) {
-                return new Integer((int)getLong(Integer.MIN_VALUE, Integer.MAX_VALUE));
+                return Integer.valueOf((int)getLong(Integer.MIN_VALUE, Integer.MAX_VALUE));
             }
             if (c == Long.TYPE || c == Long.class) {
-                return new Long(getLong(Long.MIN_VALUE, Long.MAX_VALUE));
+                return Long.valueOf(getLong(Long.MIN_VALUE, Long.MAX_VALUE));
             }
             if (c == Float.TYPE || c == Double.TYPE || c == Float.class || c == Double.class) {
                 return __float__().__tojava__(c);
diff --git a/src/org/python/core/PyObject.java b/src/org/python/core/PyObject.java
@@ -188,7 +188,7 @@ void proxyInit() {
         ThreadContext.initializingProxy.set(new Object[] {this});
         try {
             try {
-                proxy = (PyProxy) c.newInstance();
+                proxy = (PyProxy) c.getDeclaredConstructor().newInstance();
             } catch (java.lang.InstantiationException e) {
                 Class<?> sup = c.getSuperclass();
                 String msg = "Default constructor failed for Java superclass";
diff --git a/src/org/python/core/PySystemState.java b/src/org/python/core/PySystemState.java
@@ -1161,8 +1161,8 @@ private static boolean initialize(Properties pre, Properties post, String[] argv
             return false;
         }
         try {
-            ((JythonInitializer) initializer.newInstance()).initialize(pre, post, argv,
-                    sysClassLoader, adapter);
+            ((JythonInitializer) initializer.getDeclaredConstructor().newInstance()).initialize(pre,
+                    post, argv, sysClassLoader, adapter);
         } catch (Exception e) {
             Py.writeWarning("initializer",
                     "Failed initializing with class '" + className + "', continuing");
diff --git a/src/org/python/core/imp.java b/src/org/python/core/imp.java
@@ -449,20 +449,12 @@ static PyObject createFromClass(String name, Class<?> c) {
         if (PyRunnable.class.isAssignableFrom(c)) {
             try {
                 if (ContainsPyBytecode.class.isAssignableFrom(c)) {
-                    try {
-                        BytecodeLoader.fixPyBytecode((Class<? extends ContainsPyBytecode>) c);
-                    } catch (NoSuchFieldException e) {
-                        throw Py.JavaError(e);
-                    } catch (java.io.IOException e) {
-                        throw Py.JavaError(e);
-                    } catch (ClassNotFoundException e) {
-                        throw Py.JavaError(e);
-                    }
+                    BytecodeLoader.fixPyBytecode((Class<? extends ContainsPyBytecode>) c);
                 }
-                return createFromCode(name, ((PyRunnable)c.newInstance()).getMain());
-            } catch (InstantiationException e) {
-                throw Py.JavaError(e);
-            } catch (IllegalAccessException e) {
+                return createFromCode(name,
+                        ((PyRunnable) c.getDeclaredConstructor().newInstance()).getMain());
+            } catch (ReflectiveOperationException | SecurityException | IllegalArgumentException
+                    | IOException e) {
                 throw Py.JavaError(e);
             }
         }
diff --git a/src/org/python/expose/generate/MethodExposer.java b/src/org/python/expose/generate/MethodExposer.java
@@ -249,26 +249,26 @@ private void pushDefault(String def, Type arg) {
             // For primitive types, parse using the Java wrapper for that type and push onto the
             // stack as a constant. If the default is malformed, a NumberFormatException will be
             // raised.
-            mv.visitLdcInsn(new Long(def));
+            mv.visitLdcInsn(Long.valueOf(def));
         } else if(arg.equals(INT)) {
-            mv.visitLdcInsn(new Integer(def));
+            mv.visitLdcInsn(Integer.valueOf(def));
         } else if(arg.equals(BYTE)) {
             // byte, char, boolean and short go as int constants onto the stack, so convert them
             // to ints to get the right type
-            mv.visitLdcInsn(new Byte(def).intValue());
+            mv.visitLdcInsn(Byte.valueOf(def).intValue());
         } else if(arg.equals(SHORT)) {
-            mv.visitLdcInsn(new Short(def).intValue());
+            mv.visitLdcInsn(Short.valueOf(def).intValue());
         } else if(arg.equals(CHAR)) {
             if(def.length() != 1) {
                 throwInvalid("A default for a char argument must be one character in length");
             }
-            mv.visitLdcInsn((int)new Character(def.charAt(0)).charValue());
+            mv.visitLdcInsn(def.charAt(0));
         } else if(arg.equals(BOOLEAN)) {
             mv.visitLdcInsn(Boolean.valueOf(def) ? 1 : 0);
         } else if(arg.equals(Type.FLOAT_TYPE)) {
-            mv.visitLdcInsn(new Float(def));
+            mv.visitLdcInsn(Float.valueOf(def));
         } else if(arg.equals(Type.DOUBLE_TYPE)) {
-            mv.visitLdcInsn(new Double(def));
+            mv.visitLdcInsn(Double.valueOf(def));
         }
     }
 
diff --git a/src/org/python/expose/generate/TypeExposer.java b/src/org/python/expose/generate/TypeExposer.java
@@ -90,7 +90,7 @@ public TypeBuilder makeBuilder() {
         }
         Class<?> descriptor = load(l);
         try {
-            return (TypeBuilder)descriptor.newInstance();
+            return (TypeBuilder)descriptor.getDeclaredConstructor().newInstance();
         } catch(Exception e) {
             // If we're unable to create the generated class, the process is
             // definitely ill, but that shouldn't be the case most of the time
diff --git a/src/org/python/modules/posix/PyStatResult.java b/src/org/python/modules/posix/PyStatResult.java
diff --git a/src/org/python/util/TemplateAntTask.java b/src/org/python/util/TemplateAntTask.java
diff --git a/tests/java/javatests/Dict2JavaTest.java b/tests/java/javatests/Dict2JavaTest.java
diff --git a/tests/java/javatests/ListTest.java b/tests/java/javatests/ListTest.java
diff --git a/tests/java/org/python/expose/generate/DescriptorExposerTest.java b/tests/java/org/python/expose/generate/DescriptorExposerTest.java
diff --git a/tests/java/org/python/expose/generate/ExposedTypeProcessorTest.java b/tests/java/org/python/expose/generate/ExposedTypeProcessorTest.java
diff --git a/tests/java/org/python/expose/generate/NewExposerTest.java b/tests/java/org/python/expose/generate/NewExposerTest.java
diff --git a/tests/java/org/python/expose/generate/OverridableNewExposerTest.java b/tests/java/org/python/expose/generate/OverridableNewExposerTest.java

Original file line number	Diff line number	Diff line change
`@@ -331,14 +331,14 @@ public PyObject getPyObject(ResultSet set, int col, int type) throws SQLExceptio`
`331`	`331`	`throw createUnsupportedTypeSQLException("STRUCT", col);`
`332`	`332`
`333`	`333`	`default :`
`334`		`- throw createUnsupportedTypeSQLException(new Integer(type), col);`
	`334`	`+ throw createUnsupportedTypeSQLException(Integer.valueOf(type), col);`
`335`	`335`	`}`
`336`	`336`
`337`	`337`	`return set.wasNull() \|\| obj == null ? Py.None : obj;`
`338`	`338`	`}`
`339`	`339`
`340`	`340`	`protected final SQLException createUnsupportedTypeSQLException(Object type, int col) {`
`341`		`- Object[] vals = {type, new Integer(col)};`
	`341`	`+ Object[] vals = {type, Integer.valueOf(col)};`
`342`	`342`	`String msg = zxJDBC.getString("unsupportedTypeForColumn", vals);`
`343`	`343`	`return new SQLException(msg);`
`344`	`344`	`}`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ public PyObject getPyObject(ResultSet set, int col, int type) throws SQLExceptio`
`313`	`313`	`break;`
`314`	`314`
`315`	`315`	`default :`
`316`		`- throw createUnsupportedTypeSQLException(new Integer(type), col);`
	`316`	`+ throw createUnsupportedTypeSQLException(Integer.valueOf(type), col);`
`317`	`317`	`}`
`318`	`318`
`319`	`319`	`return (set.wasNull() \|\| (obj == null)) ? Py.None : obj;`
`@@ -401,7 +401,7 @@ public PyObject getPyObject(CallableStatement stmt, int col, int type) throws SQ`
`401`	`401`	`break;`
`402`	`402`
`403`	`403`	`default :`
`404`		`- throw createUnsupportedTypeSQLException(new Integer(type), col);`
	`404`	`+ throw createUnsupportedTypeSQLException(Integer.valueOf(type), col);`
`405`	`405`	`}`
`406`	`406`
`407`	`407`	`return (stmt.wasNull() \|\| (obj == null)) ? Py.None : obj;`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public PyObject __call__(PyObject[] args, String[] keywords) {`
`58`	`58`
`59`	`59`	`try {`
`60`	`60`	`String klass = (String) parser.arg(0).__tojava__(String.class);`
`61`		`- datasource = Class.forName(klass).newInstance();`
	`61`	`+ datasource = Class.forName(klass).getDeclaredConstructor().newInstance();`
`62`	`62`	`} catch (Exception e) {`
`63`	`63`	`throw zxJDBC.makeException(zxJDBC.DatabaseError, "unable to instantiate datasource");`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,8 @@ public void write(DataOutputStream stream) throws IOException {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public void addLine(int startpc, int lineno) {`
`35`		`- lines.addElement(new Short((short) startpc));`
`36`		`- lines.addElement(new Short((short) lineno));`
	`35`	`+ lines.addElement(Short.valueOf((short) startpc));`
	`36`	`+ lines.addElement(Short.valueOf((short) lineno));`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public int length() {`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ class PyFloatConstant extends Constant implements ClassConstants, Opcodes {`
`97`	`97`
`98`	`98`	`@Override`
`99`	`99`	`void get(Code c) throws IOException {`
`100`		`- c.ldc(new Double(value));`
	`100`	`+ c.ldc(Double.valueOf(value));`
`101`	`101`	`c.invokestatic(p(Py.class), "newFloat", sig(PyFloat.class, Double.TYPE));`
`102`	`102`	`}`
`103`	`103`
`@@ -132,7 +132,7 @@ class PyComplexConstant extends Constant implements ClassConstants, Opcodes {`
`132`	`132`
`133`	`133`	`@Override`
`134`	`134`	`void get(Code c) throws IOException {`
`135`		`- c.ldc(new Double(value));`
	`135`	`+ c.ldc(Double.valueOf(value));`
`136`	`136`	`c.invokestatic(p(Py.class), "newImaginary", sig(PyComplex.class, Double.TYPE));`
`137`	`137`	`}`
`138`	`138`