Move comments and spaces from javassist 1:1 to make another migrations easier + small fix in Callback.java and Reflection.java

Author: kkrzywanski

hotswap-agent-core/src/main/java/org/hotswap/agent/javassist/ClassPool.java

@@ -301,7 +301,7 @@ public void clearImportedPackages() {
     }
 
     /**
-     * Returns all the package names recorded by <code>importPackage()</code>.
+     * Returns all the package names recorded by <code>importPackage()</code>. 
      *
      * @see #importPackage(String)
      * @since 3.1
@@ -474,7 +474,7 @@ public CtClass getOrNull(String classname) {
      * that classname can be an array-type "descriptor" (an encoded
      * type name) such as <code>[Ljava/lang/Object;</code>.
      *
-     * <p>Using this method is not recommended; this method should be
+     * <p>Using this method is not recommended; this method should be 
      * used only to obtain the <code>CtClass</code> object
      * with a name returned from <code>getClassInfo</code> in
      * <code>javassist.bytecode.ClassPool</code>.  <code>getClassInfo</code>
@@ -538,7 +538,7 @@ protected synchronized CtClass get0(String classname, boolean useCache)
      * @return null if the class file could not be found.
      */
     protected CtClass createCtClass(String classname, boolean useCache) {
-        // accept "[L<class name>;" as a class name.
+        // accept "[L<class name>;" as a class name. 
         if (classname.charAt(0) == '[')
             classname = Descriptor.toClassName(classname);
 
@@ -890,7 +890,7 @@ public synchronized CtClass makeInterface(String name, CtClass superclass)
      * the new interface overwrites that previous one.
      *
      * @param name      a fully-qualified interface name.
-     *                  Or null if the annotation has no super interface.
+     *                  Or null if the annotation has no super interface. 
      * @throws RuntimeException if the existing interface is frozen.
      * @since 3.19
      */
@@ -1025,8 +1025,8 @@ public void appendPathList(String pathlist) throws NotFoundException {
      * allowed any more.
      * To load the class, this method uses the context class loader
      * of the current thread.  It is obtained by calling
-     * <code>getClassLoader()</code>.
-     *
+     * <code>getClassLoader()</code>.  
+     * 
      * <p>This behavior can be changed by subclassing the pool and changing
      * the <code>getClassLoader()</code> method.
      * If the program is running on some application
@@ -1053,26 +1053,26 @@ public void appendPathList(String pathlist) throws NotFoundException {
     public Class toClass(CtClass clazz) throws CannotCompileException {
         // Some subclasses of ClassPool may override toClass(CtClass,ClassLoader).
         // So we should call that method instead of toClass(.., ProtectionDomain).
-        return toClass(clazz, getClassLoader());
+        return toClass(clazz, getClassLoader()); 
     }
 
     /**
      * Get the classloader for <code>toClass()</code>, <code>getAnnotations()</code> in
      * <code>CtClass</code>, etc.
-     *
+     * 
      * <p>The default is the context class loader.
-     *
+     * 
      * @return the classloader for the pool
      * @see #toClass(CtClass)
      * @see CtClass#getAnnotations()
      */
     public ClassLoader getClassLoader() {
         return getContextClassLoader();
     }
-
+    
     /**
      * Obtains a class loader that seems appropriate to look up a class
-     * by name.
+     * by name. 
      */
     static ClassLoader getContextClassLoader() {
         return Thread.currentThread().getContextClassLoader();
@@ -1250,15 +1250,11 @@ public Class toClass(CtClass ct, Class<?> neighbor, ClassLoader loader,
      * performs nothing.
      *
      * <p>You do not necessarily need to
-     * call this method.  If this method is called, then
-     * <code>getPackage()</code> on the <code>Class</code> object returned
+     * call this method.  If this method is called, then  
+     * <code>getPackage()</code> on the <code>Class</code> object returned 
      * by <code>toClass()</code> will return a non-null object.</p>
      *
-     * <p>The jigsaw module introduced by Java 9 has broken this method.
-     * In Java 9 or later, the VM argument
-     * <code>--add-opens java.base/java.lang=ALL-UNNAMED</code>
-     * has to be given to the JVM so that this method can run.
-     * </p>
+     * <p>The jigsaw module introduced by Java 9 has broken this method.</p>
      *
      * @param loader        the class loader passed to <code>toClass()</code> or
      *                      the default one obtained by <code>getClassLoader()</code>.

hotswap-agent-core/src/main/java/org/hotswap/agent/javassist/ClassPoolTail.java

@@ -16,10 +16,6 @@
 
 package org.hotswap.agent.javassist;
 
-import org.hotswap.agent.javassist.ClassClassPath;
-import org.hotswap.agent.javassist.LoaderClassPath;
-import org.hotswap.agent.javassist.NotFoundException;
-
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;

hotswap-agent-core/src/main/java/org/hotswap/agent/javassist/CodeConverter.java

@@ -131,7 +131,7 @@ public void replaceNew(CtClass newClass,
      *
      * <p>Note that <code>Point2</code> must be type-compatible with <code>Point</code>.
      * It must have the same set of methods, fields, and constructors as the
-     * replaced class.
+     * replaced class. 
      */
     public void replaceNew(CtClass oldClass, CtClass newClass) {
         transformers = new TransformNewClass(transformers, oldClass.getName(),
@@ -244,28 +244,28 @@ public void replaceFieldWrite(CtField field,
     }
 
     /**
-     * Modify a method body, so that ALL accesses to an array are replaced with
-     * calls to static methods within another class. In the case of reading an
-     * element from the array, this is replaced with a call to a static method with
-     * the array and the index as arguments, the return value is the value read from
-     * the array. If writing to an array, this is replaced with a call to a static
-     * method with the array, index and new value as parameters, the return value of
+     * Modify a method body, so that ALL accesses to an array are replaced with 
+     * calls to static methods within another class. In the case of reading an 
+     * element from the array, this is replaced with a call to a static method with 
+     * the array and the index as arguments, the return value is the value read from 
+     * the array. If writing to an array, this is replaced with a call to a static 
+     * method with the array, index and new value as parameters, the return value of 
      * the static method is <code>void</code>.
-     *
-     * <p>The <code>calledClass</code> parameter is the class containing the static methods to be used
-     * for array replacement. The <code>names</code> parameter points to an implementation of
-     * <code>ArrayAccessReplacementMethodNames</code> which specifies the names of the method to be
-     * used for access for each type of array.  For example reading from an <code>int[]</code> will
-     * require a different method than if writing to an <code>int[]</code>, and writing to a <code>long[]</code>
-     * will require a different method than if writing to a <code>byte[]</code>. If the implementation
-     * of <code>ArrayAccessReplacementMethodNames</code> does not contain the name for access for a
+     * 
+     * <p>The <code>calledClass</code> parameter is the class containing the static methods to be used 
+     * for array replacement. The <code>names</code> parameter points to an implementation of 
+     * <code>ArrayAccessReplacementMethodNames</code> which specifies the names of the method to be 
+     * used for access for each type of array.  For example reading from an <code>int[]</code> will 
+     * require a different method than if writing to an <code>int[]</code>, and writing to a <code>long[]</code> 
+     * will require a different method than if writing to a <code>byte[]</code>. If the implementation 
+     * of <code>ArrayAccessReplacementMethodNames</code> does not contain the name for access for a 
      * type of array, that access is not replaced.
-     *
-     * <p>A default implementation of <code>ArrayAccessReplacementMethodNames</code> called
-     * <code>DefaultArrayAccessReplacementMethodNames</code> has been provided and is what is used in the
-     * following example. This also assumes that <code>'foo.ArrayAdvisor'</code> is the name of the
+     * 
+     * <p>A default implementation of <code>ArrayAccessReplacementMethodNames</code> called 
+     * <code>DefaultArrayAccessReplacementMethodNames</code> has been provided and is what is used in the 
+     * following example. This also assumes that <code>'foo.ArrayAdvisor'</code> is the name of the 
      * <code>CtClass</code> passed in.
-     *
+     * 
      * <p>If we have the following class:
      * <pre>class POJO{
      *    int[] ints = new int[]{1, 2, 3, 4, 5};
@@ -276,64 +276,64 @@ public void replaceFieldWrite(CtField field,
      * </pre>
      * and this is accessed as:
      * <pre>POJO p = new POJO();
-     *
+     * 
      * //Write to int array
      * p.ints[2] = 7;
-     *
+     * 
      * //Read from int array
      * int i = p.ints[2];
-     *
+     * 
      * //Write to long array
      * p.longs[2] = 1000L;
-     *
+     * 
      * //Read from long array
      * long l = p.longs[2];
-     *
+     * 
      * //Write to Object array
      * p.objects[2] = "Hello";
-     *
+     * 
      * //Read from Object array
      * Object o = p.objects[2];
-     *
+     * 
      * //Write to Integer array
      * Integer integer = new Integer(5);
      * p.integers[0] = integer;
-     *
+     * 
      * //Read from Object array
      * integer = p.integers[0];
      * </pre>
-     *
+     * 
      * Following instrumentation we will have
      * <pre>POJO p = new POJO();
-     *
+     * 
      * //Write to int array
      * ArrayAdvisor.arrayWriteInt(p.ints, 2, 7);
-     *
+     * 
      * //Read from int array
      * int i = ArrayAdvisor.arrayReadInt(p.ints, 2);
-     *
+     * 
      * //Write to long array
      * ArrayAdvisor.arrayWriteLong(p.longs, 2, 1000L);
-     *
+     * 
      * //Read from long array
      * long l = ArrayAdvisor.arrayReadLong(p.longs, 2);
-     *
+     * 
      * //Write to Object array
      * ArrayAdvisor.arrayWriteObject(p.objects, 2, "Hello");
-     *
+     * 
      * //Read from Object array
      * Object o = ArrayAdvisor.arrayReadObject(p.objects, 2);
-     *
+     * 
      * //Write to Integer array
      * Integer integer = new Integer(5);
      * ArrayAdvisor.arrayWriteObject(p.integers, 0, integer);
-     *
+     * 
      * //Read from Object array
      * integer = ArrayAdvisor.arrayWriteObject(p.integers, 0);
      * </pre>
-     *
+     * 
      * @see DefaultArrayAccessReplacementMethodNames
-     *
+     * 
      * @param calledClass        the class containing the static methods.
      * @param names              contains the names of the methods to replace
      *                           the different kinds of array access with.

hotswap-agent-core/src/main/java/org/hotswap/agent/javassist/CtBehavior.java

@@ -41,7 +41,7 @@
 
 /**
  * <code>CtBehavior</code> represents a method, a constructor,
- * or a static constructor (class initializer).
+ * or a static constructor (class initializer). 
  * It is the abstract super class of
  * <code>CtMethod</code> and <code>CtConstructor</code>.
  *
@@ -191,9 +191,9 @@ public void setModifiers(int mod) {
     public boolean hasAnnotation(String typeName) {
        MethodInfo mi = getMethodInfo2();
        AnnotationsAttribute ainfo = (AnnotationsAttribute)
-                   mi.getAttribute(AnnotationsAttribute.invisibleTag);
+                   mi.getAttribute(AnnotationsAttribute.invisibleTag);  
        AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
-                   mi.getAttribute(AnnotationsAttribute.visibleTag);
+                   mi.getAttribute(AnnotationsAttribute.visibleTag);  
        return CtClassType.hasAnnotationType(typeName,
                                             getDeclaringClass().getClassPool(),
                                             ainfo, ainfo2);
@@ -214,9 +214,9 @@ public boolean hasAnnotation(String typeName) {
     public Object getAnnotation(Class<?> clz) throws ClassNotFoundException {
        MethodInfo mi = getMethodInfo2();
        AnnotationsAttribute ainfo = (AnnotationsAttribute)
-                   mi.getAttribute(AnnotationsAttribute.invisibleTag);
+                   mi.getAttribute(AnnotationsAttribute.invisibleTag);  
        AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
-                   mi.getAttribute(AnnotationsAttribute.visibleTag);
+                   mi.getAttribute(AnnotationsAttribute.visibleTag);  
        return CtClassType.getAnnotationType(clz,
                                             getDeclaringClass().getClassPool(),
                                             ainfo, ainfo2);
@@ -238,7 +238,7 @@ public Object[] getAnnotations() throws ClassNotFoundException {
      * Returns the annotations associated with this method or constructor.
      * If any annotations are not on the classpath, they are not included
      * in the returned array.
-     *
+     * 
      * @return an array of annotation-type objects.
      * @see #getAnnotations()
      * @since 3.3
@@ -258,9 +258,9 @@ private Object[] getAnnotations(boolean ignoreNotFound)
     {
        MethodInfo mi = getMethodInfo2();
        AnnotationsAttribute ainfo = (AnnotationsAttribute)
-                   mi.getAttribute(AnnotationsAttribute.invisibleTag);
+                   mi.getAttribute(AnnotationsAttribute.invisibleTag);  
        AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
-                   mi.getAttribute(AnnotationsAttribute.visibleTag);
+                   mi.getAttribute(AnnotationsAttribute.visibleTag);  
        return CtClassType.toAnnotationType(ignoreNotFound,
                                            getDeclaringClass().getClassPool(),
                                            ainfo, ainfo2);
@@ -285,7 +285,7 @@ public Object[][] getParameterAnnotations() throws ClassNotFoundException {
      * Returns the parameter annotations associated with this method or constructor.
      * If any annotations are not on the classpath, they are not included in the
      * returned array.
-     *
+     * 
      * @return an array of annotation-type objects.  The length of the returned array is
      * equal to the number of the formal parameters.  If each parameter has no
      * annotation, the elements of the returned array are empty arrays.
@@ -308,9 +308,9 @@ Object[][] getParameterAnnotations(boolean ignoreNotFound)
     {
         MethodInfo mi = getMethodInfo2();
         ParameterAnnotationsAttribute ainfo = (ParameterAnnotationsAttribute)
-                    mi.getAttribute(ParameterAnnotationsAttribute.invisibleTag);
+                    mi.getAttribute(ParameterAnnotationsAttribute.invisibleTag);  
         ParameterAnnotationsAttribute ainfo2 = (ParameterAnnotationsAttribute)
-                    mi.getAttribute(ParameterAnnotationsAttribute.visibleTag);
+                    mi.getAttribute(ParameterAnnotationsAttribute.visibleTag);  
         return CtClassType.toAnnotationType(ignoreNotFound,
                                             getDeclaringClass().getClassPool(),
                                             ainfo, ainfo2, mi);
@@ -727,7 +727,7 @@ public void instrument(CodeConverter converter)
      * in <code>Expr</code> is available for bytecode modification.
      * Other methods such as <code>insertBefore()</code> may collapse
      * the bytecode because the <code>ExprEditor</code> loses
-     * its current position.
+     * its current position.  
      *
      * @param editor            specifies how to modify.
      * @see javassist.expr.Expr#replace(String)
@@ -812,7 +812,7 @@ private void insertBefore(String src, boolean rebuild)
 
     /**
      * Inserts bytecode at the end of the body.
-     * The bytecode is inserted just before every return insturction.
+     * The bytecode is inserted just before every return instruction.
      * It is not executed when an exception is thrown.
      *
      * @param src       the source code representing the inserted bytecode.
@@ -826,7 +826,7 @@ public void insertAfter(String src)
 
     /**
      * Inserts bytecode at the end of the body.
-     * The bytecode is inserted just before every return insturction.
+     * The bytecode is inserted just before every return instruction.
      *
      * @param src       the source code representing the inserted bytecode.
      *                  It must be a single statement or block.
@@ -893,7 +893,7 @@ public void insertAfter(String src, boolean asFinally, boolean redundant)
                                                 jv, src);
             int handlerPos = iterator.getCodeLength();
             if (asFinally)
-                ca.getExceptionTable().add(getStartPosOfBody(ca), handlerPos, handlerPos, 0);
+                ca.getExceptionTable().add(getStartPosOfBody(ca), handlerPos, handlerPos, 0); 
 
             int adviceLen = 0;
             int advicePos = 0;
@@ -1025,7 +1025,7 @@ else if (offset <= Short.MAX_VALUE) {
         else {
             if (gap.length < 4) {
                 CodeIterator.Gap gap2 =  iterator.insertGapAt(gap.position, 2, false);
-                pos = gap2.position + gap2.length + gap.length - 4;
+                pos = gap2.position + gap2.length + gap.length - 4; 
             }
 
             iterator.writeByte(Opcode.GOTO_W, pos);
@@ -1242,7 +1242,7 @@ public int insertAt(int lineNum, String src)
      * For example, if there is only a closing brace at that line, the
      * bytecode would be inserted at another line below.
      * To know exactly where the bytecode will be inserted, call with
-     * <code>modify</code> set to <code>false</code>.
+     * <code>modify</code> set to <code>false</code>. 
      *
      * @param lineNum   the line number.  The bytecode is inserted at the
      *                  beginning of the code at the line specified by this