Replace raw arrays with List (cont 1)

Author: mur47x111

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/code/VirtualObject.java

@@ -109,7 +109,7 @@ private static StringBuilder appendValue(StringBuilder buf, JavaValue value, Set
                             appendValue(buf, vo.values[i], visited);
                         }
                     } else {
-                        List<ResolvedJavaField> fields = vo.type.getInstanceFields(true);
+                        List<? extends ResolvedJavaField> fields = vo.type.getInstanceFields(true);
                         int fieldIndex = 0;
                         for (int i = 0; i < vo.values.length; i++, fieldIndex++) {
                             if (i != 0) {
@@ -156,7 +156,7 @@ default JavaKind getStorageKind(ResolvedJavaField field) {
 
     public void verifyLayout(LayoutVerifier verifier) {
         if (!type.isArray()) {
-            List<ResolvedJavaField> fields = type.getInstanceFields(true);
+            List<? extends ResolvedJavaField> fields = type.getInstanceFields(true);
             int fieldIndex = 0;
             for (int i = 0; i < values.length; i++, fieldIndex++) {
                 JavaKind slotKind = slotKinds.get(i);

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotMetaAccessProvider.java

@@ -88,7 +88,7 @@ public ResolvedJavaField lookupJavaField(Field reflectionField) {
 
         HotSpotResolvedJavaType holder = runtime.fromClass(fieldHolder);
         assert holder != null : fieldHolder;
-        List<ResolvedJavaField> fields;
+        List<? extends ResolvedJavaField> fields;
         if (Modifier.isStatic(reflectionField.getModifiers())) {
             fields = holder.getStaticFields();
         } else {

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/amd64/AMD64HotSpotRegisterConfig.java

@@ -218,9 +218,10 @@ public List<Register> getCallingConventionRegisters(Type type, JavaKind kind) {
      *
      * @return the resulting calling convention
      */
-    private CallingConvention callingConvention(List<Register> generalParameterRegisters, List<Register> xmmParameterRegisters, boolean unified, JavaType returnType, List<JavaType> parameterTypes,
-                    HotSpotCallingConventionType type,
-                    ValueKindFactory<?> valueKindFactory) {
+    private CallingConvention callingConvention(List<Register> generalParameterRegisters, List<Register> xmmParameterRegisters, boolean unified, JavaType returnType,
+                                                List<? extends JavaType> parameterTypes,
+                                                HotSpotCallingConventionType type,
+                                                ValueKindFactory<?> valueKindFactory) {
         assert !unified || generalParameterRegisters.size() == xmmParameterRegisters.size() : "must be same size in unified mode";
         AllocatableValue[] locations = new AllocatableValue[parameterTypes.size()];
 

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/riscv64/RISCV64HotSpotRegisterConfig.java

@@ -127,7 +127,7 @@ public List<RegisterAttributes> getAttributesMap() {
     public static final Register threadRegister = x23;
     public static final Register heapBaseRegister = x27;
 
-    private static final List<Register> reservedRegisters =List.of(zero, ra, sp, gp, tp, t0, t1, t2, fp);
+    private static final List<Register> reservedRegisters = List.of(zero, ra, sp, gp, tp, t0, t1, t2, fp);
 
     private static List<Register> initAllocatable(Architecture arch, boolean reserveForHeapBase) {
         List<Register> allRegisters = arch.getAvailableValueRegisters();
@@ -140,7 +140,7 @@ private static List<Register> initAllocatable(Architecture arch, boolean reserve
                 continue;
             }
             assert !(reg.equals(zero) || reg.equals(ra) || reg.equals(sp) || reg.equals(gp) || reg.equals(tp) ||
-                     reg.equals(t0) || reg.equals(t1) || reg.equals(t2) || reg.equals(fp));
+                    reg.equals(t0) || reg.equals(t1) || reg.equals(t2) || reg.equals(fp));
             if (reserveForHeapBase && reg.equals(heapBaseRegister)) {
                 // skip heap base register
                 continue;
@@ -189,7 +189,7 @@ public boolean areAllAllocatableRegistersCallerSaved() {
     }
 
     @Override
-    public CallingConvention getCallingConvention(Type type, JavaType returnType, List<JavaType> parameterTypes, ValueKindFactory<?> valueKindFactory) {
+    public CallingConvention getCallingConvention(Type type, JavaType returnType, List<? extends JavaType> parameterTypes, ValueKindFactory<?> valueKindFactory) {
         HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
         if (type == HotSpotCallingConventionType.NativeCall) {
             return callingConvention(nativeGeneralParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
@@ -208,8 +208,9 @@ public List<Register> getCallingConventionRegisters(Type type, JavaKind kind) {
         };
     }
 
-    private CallingConvention callingConvention(List<Register> generalParameterRegisters, JavaType returnType, List<JavaType> parameterTypes, HotSpotCallingConventionType type,
-                    ValueKindFactory<?> valueKindFactory) {
+    private CallingConvention callingConvention(List<Register> generalParameterRegisters, JavaType returnType,
+                                                List<? extends JavaType> parameterTypes, HotSpotCallingConventionType type,
+                                                ValueKindFactory<?> valueKindFactory) {
         AllocatableValue[] locations = new AllocatableValue[parameterTypes.size()];
 
         int currentGeneral = 0;

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/MetaAccessProvider.java

@@ -49,7 +49,7 @@ public interface MetaAccessProvider {
      * @param classes the Java class objects
      * @return the resolved Java type objects
      */
-    default List<ResolvedJavaType> lookupJavaTypes(Class<?>[] classes) {
+    default List<? extends ResolvedJavaType> lookupJavaTypes(Class<?>[] classes) {
         ResolvedJavaType[] result = new ResolvedJavaType[classes.length];
         for (int i = 0; i < result.length; i++) {
             result[i] = lookupJavaType(classes[i]);

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ResolvedJavaType.java

@@ -167,7 +167,7 @@ default boolean isJavaLangObject() {
      * {@link Class#getInterfaces()} and as such, only returns the interfaces directly implemented
      * or extended by this type.
      */
-    List<ResolvedJavaType> getInterfaces();
+    List<? extends ResolvedJavaType> getInterfaces();
 
     /**
      * Gets the single implementor of this type. Calling this method on a non-interface type causes
@@ -285,14 +285,14 @@ default ResolvedJavaMethod resolveConcreteMethod(ResolvedJavaMethod method, Reso
      *            type are included in the result with superclass fields coming before subclass fields
      * @return a list of non-static fields
      */
-    List<ResolvedJavaField> getInstanceFields(boolean includeSuperclasses);
+    List<? extends ResolvedJavaField> getInstanceFields(boolean includeSuperclasses);
 
     /**
      * Returns the static fields of this class, including {@linkplain ResolvedJavaField#isInternal()
      * internal} fields. A zero-length array is returned for array and primitive types. The order of
      * fields returned by this method is the same as {@link Class#getDeclaredFields}.
      */
-    List<ResolvedJavaField> getStaticFields();
+    List<? extends ResolvedJavaField> getStaticFields();
 
     /**
      * Returns the instance field of this class (or one of its super classes) at the given offset,
@@ -328,15 +328,15 @@ default ResolvedJavaMethod resolveConcreteMethod(ResolvedJavaMethod method, Reso
      * similar to {@link Class#getDeclaredConstructors()} in terms of returned constructors. Calling
      * this method forces this type to be {@link #link linked}.
      */
-    List<ResolvedJavaMethod> getDeclaredConstructors();
+    List<? extends ResolvedJavaMethod> getDeclaredConstructors();
 
     /**
      * Returns a list reflecting all the constructors declared by this type. This method is
      * similar to {@link Class#getDeclaredConstructors()} in terms of returned constructors.
      *
      * @param forceLink if {@code true}, forces this type to be {@link #link linked}
      */
-    default List<ResolvedJavaMethod> getDeclaredConstructors(boolean forceLink) {
+    default List<? extends ResolvedJavaMethod> getDeclaredConstructors(boolean forceLink) {
         throw new UnsupportedOperationException();
     }
 
@@ -345,15 +345,15 @@ default List<ResolvedJavaMethod> getDeclaredConstructors(boolean forceLink) {
      * {@link Class#getDeclaredMethods()} in terms of returned methods. Calling this method forces
      * this type to be {@link #link linked}.
      */
-    List<ResolvedJavaMethod> getDeclaredMethods();
+    List<? extends ResolvedJavaMethod> getDeclaredMethods();
 
     /**
      * Returns a list reflecting all the methods declared by this type. This method is similar to
      * {@link Class#getDeclaredMethods()} in terms of returned methods.
      *
      * @param forceLink if {@code true}, forces this type to be {@link #link linked}
      */
-    default List<ResolvedJavaMethod> getDeclaredMethods(boolean forceLink) {
+    default List<? extends ResolvedJavaMethod> getDeclaredMethods(boolean forceLink) {
         throw new UnsupportedOperationException();
     }
 
@@ -366,7 +366,7 @@ default List<ResolvedJavaMethod> getDeclaredMethods(boolean forceLink) {
      *
      * @param forceLink if {@code true}, forces this type to be {@link #link linked}
      */
-    List<ResolvedJavaMethod> getAllMethods(boolean forceLink);
+    List<? extends ResolvedJavaMethod> getAllMethods(boolean forceLink);
 
     /**
      * Returns the {@code <clinit>} method for this class if there is one.