style fixes

Author: adinn

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/SubstrateUtil.java

@@ -26,13 +26,9 @@
 
 import java.io.FileDescriptor;
 import java.io.FileOutputStream;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Executable;
-import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -275,8 +271,9 @@ public static String digest(String value) {
     }
 
     /**
-     * Convenience method that delegates to the corresponding method of the currently
-     * registered UniqueShortNameProvider image singleton.
+     * Convenience method that delegates to the corresponding method of the currently registered
+     * UniqueShortNameProvider image singleton.
+     * 
      * @param m a method whose unique short name is required
      * @return a unique short name for the method
      */
@@ -287,6 +284,7 @@ public static String uniqueShortName(ResolvedJavaMethod m) {
     /**
      * Delegate to the corresponding method of the currently registered UniqueShortNameProvider
      * image singleton.
+     * 
      * @param loaderName the unique loader id for some method's class loader
      * @param declaringClass the method's declaring class
      * @param methodName the method's name
@@ -301,6 +299,7 @@ public static String uniqueShortName(String loaderName, ResolvedJavaType declari
     /**
      * Delegate to the corresponding method of the currently registered UniqueShortNameProvider
      * image singleton.
+     * 
      * @param m a member whose unique short name is required
      * @return a unique short name for the member
      */
@@ -311,6 +310,7 @@ public static String uniqueShortName(Member m) {
     /**
      * Delegate to the corresponding method of the currently registered UniqueShortNameProvider
      * image singleton.
+     * 
      * @param m a method whose unique stub name is required
      * @return a unique stub name for the method
      */
@@ -321,6 +321,7 @@ public static String uniqueStubName(ResolvedJavaMethod m) {
     /**
      * Delegate to the corresponding method of the currently registered UniqueShortNameProvider
      * image singleton.
+     * 
      * @param loader a class loader whose identifier is required
      * @return A unique identifier for the class loader
      */

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/UniqueShortNameProvider.java

@@ -1,3 +1,27 @@
+/*
+ * Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
 package com.oracle.svm.core;
 
 import com.oracle.svm.core.util.VMError;
@@ -14,10 +38,10 @@
 import java.lang.reflect.Method;
 
 /**
- * An abstract provider class that defines a protocol for generating unique short names for
- * Java methods and fields which are compatible for use as local linker symbols. An instance
- * of this class may be registered as an image singleton in order to ensure that a specific
- * naming convention is adopted.
+ * An abstract provider class that defines a protocol for generating unique short names for Java
+ * methods and fields which are compatible for use as local linker symbols. An instance of this
+ * class may be registered as an image singleton in order to ensure that a specific naming
+ * convention is adopted.
  */
 public abstract class UniqueShortNameProvider {
     private static UniqueShortNameProvider provider = null;
@@ -35,10 +59,11 @@ public static synchronized UniqueShortNameProvider provider() {
     }
 
     /**
-     * Returns a short, reasonably descriptive, but still unique name for the provided method
-     * which can be used as a linker local symbol.
+     * Returns a short, reasonably descriptive, but still unique name for the provided method which
+     * can be used as a linker local symbol.
      */
     public abstract String uniqueShortName(ResolvedJavaMethod method);
+
     /**
      * Returns a short, reasonably descriptive, but still unique name for a method as characterized
      * by its loader name, owner class, method selector, signature and status as a method proper or
@@ -53,30 +78,33 @@ public static synchronized UniqueShortNameProvider provider() {
     public abstract String uniqueShortName(Member m);
 
     /**
-     * Returns a short, reasonably descriptive, but still unique name derived from the provided method
-     * that can be used as the name of a stub method defined on some factory class that invokes it.
-     * Note that although the value returned by this method is unique to the called method it's purpose
-     * is to uniquely define a single component of the full name of the stub method i.e. the method
-     * selector.
+     * Returns a short, reasonably descriptive, but still unique name derived from the provided
+     * method that can be used as the name of a stub method defined on some factory class that
+     * invokes it. Note that although the value returned by this method is unique to the called
+     * method it's purpose is to uniquely define a single component of the full name of the stub
+     * method i.e. the method selector.
      */
 
     public abstract String uniqueStubName(ResolvedJavaMethod method);
+
     /**
      * Returns a unique identifier for a class loader that can be folded into the unique short name
      * of methods where needed in order to disambiguate name collisions that can arise when the same
      * class bytecode is loaded by more than one loader. For a few special loaders, such as the JDK
      * runtime's builtin loaders and GraalVM Native's top level loaders an empty string is returned.
      * There is no need to qualify the method name in this case since the method defined via these
      * loaders is taken to be the primary instance. This is safe so long as the delegation model for
-     * this special set of loaders ensures that none of them will replicate a class loaded by another
-     * loader in the set.
+     * this special set of loaders ensures that none of them will replicate a class loaded by
+     * another loader in the set.
+     * 
      * @param loader The loader whose identifier is to be returned.
-     * @return A unique identifier for the classloader or the empty string when the loader is one
-     * of the special set whose method names do not need qualification.
+     * @return A unique identifier for the classloader or the empty string when the loader is one of
+     *         the special set whose method names do not need qualification.
      */
     public abstract String classLoaderNameAndId(ClassLoader loader);
 
     private static final Field classLoaderNameAndId = ReflectionUtil.lookupField(ClassLoader.class, "nameAndId");
+
     protected String lookupNameAndIdField(ClassLoader loader) {
         try {
             return (String) classLoaderNameAndId.get(loader);
@@ -86,20 +114,16 @@ protected String lookupNameAndIdField(ClassLoader loader) {
     }
 
     /**
-     * Default implementation for unique method and field short names which concatenates the (unqualified)
-     * owner class name and method or field selector with an SHA1 digest of the fully qualified Java
-     * name of the method or field. If a loader prefix is provided it is added as prefix to the Java
-     * name before generating the SHA1 digest.
+     * Default implementation for unique method and field short names which concatenates the
+     * (unqualified) owner class name and method or field selector with an SHA1 digest of the fully
+     * qualified Java name of the method or field. If a loader prefix is provided it is added as
+     * prefix to the Java name before generating the SHA1 digest.
      */
     private static class DefaultUniqueShortNameProvider extends UniqueShortNameProvider {
         @Override
         public String uniqueShortName(ResolvedJavaMethod m) {
             return uniqueShortName("", m.getDeclaringClass(), m.getName(), m.getSignature(), m.isConstructor());
         }
-        public String uniqueStubName(ResolvedJavaMethod m) {
-            // the default short name works as a name for the stub method
-            return uniqueShortName("", m.getDeclaringClass(), m.getName(), m.getSignature(), m.isConstructor());
-        }
 
         @Override
         public String uniqueShortName(String loaderName, ResolvedJavaType declaringClass, String methodName, Signature methodSignature, boolean isConstructor) {
@@ -114,8 +138,8 @@ public String uniqueShortName(String loaderName, ResolvedJavaType declaringClass
             }
 
             return stripPackage(declaringClass.toJavaName()) + "_" +
-                    (isConstructor ? "constructor" : methodName) + "_" +
-                    SubstrateUtil.digest(sb.toString());
+                            (isConstructor ? "constructor" : methodName) + "_" +
+                            SubstrateUtil.digest(sb.toString());
         }
 
         @Override
@@ -139,14 +163,17 @@ public String uniqueShortName(Member m) {
             }
 
             return stripPackage(m.getDeclaringClass().getTypeName()) + "_" +
-                    (m instanceof Constructor ? "constructor" : m.getName()) + "_" +
-                    SubstrateUtil.digest(fullName.toString());
+                            (m instanceof Constructor ? "constructor" : m.getName()) + "_" +
+                            SubstrateUtil.digest(fullName.toString());
         }
-        private static String stripPackage(String qualifiedClassName) {
-            /* Anonymous classes can contain a '/' which can lead to an invalid binary name. */
-            return qualifiedClassName.substring(qualifiedClassName.lastIndexOf(".") + 1).replace("/", "");
+
+        @Override
+        public String uniqueStubName(ResolvedJavaMethod m) {
+            // the default short name works as a name for the stub method
+            return uniqueShortName("", m.getDeclaringClass(), m.getName(), m.getSignature(), m.isConstructor());
         }
 
+        @Override
         public String classLoaderNameAndId(ClassLoader loader) {
             // no need to qualify classes loaded by a bootstrap loader
             if (loader == null) {
@@ -160,4 +187,10 @@ public String classLoaderNameAndId(ClassLoader loader) {
             return name;
         }
     }
+
+    private static String stripPackage(String qualifiedClassName) {
+        /* Anonymous classes can contain a '/' which can lead to an invalid binary name. */
+        return qualifiedClassName.substring(qualifiedClassName.lastIndexOf(".") + 1).replace("/", "");
+    }
+
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImage.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it