Remove default methods from the implementation of PartialMethod. These are now implemented in VTable.

Author: rakachan

espresso/src/com.oracle.truffle.espresso.shared/src/com/oracle/truffle/espresso/shared/vtable/PartialMethod.java

@@ -51,85 +51,6 @@ public interface PartialMethod<C extends TypeAccess<C, M, F>, M extends MethodAc
      */
     boolean isClassInitializer();
 
-    /**
-     * @return Whether this method appears in a method table.
-     */
-    default boolean isVirtualEntry() {
-        return !isPrivate() && !isStatic() && !isConstructor() && !isClassInitializer();
-    }
-
-    /**
-     * Returns whether the current considered {@link PartialMethod method} overrides the method
-     * {@code parentMethod}.
-     * <p>
-     * This check should be done in accordance to the first two cases of the definition of method
-     * overriding of the JVM Specification (jvms-5.4.5).
-     * <p>
-     * In practice, this method simply needs to check whether the declaring class of {@code this}
-     * can access {@code parentMethod}.
-     * <p>
-     * In particular, implementations does not need to check whether there exists a method
-     * in-between the two methods considered, for which {@code this} can override.
-     * <p>
-     * The callers must ensure both {@code this} method and {@code parentMethod}:
-     * <ul>
-     * <li>{@link #isVirtualEntry() Appears in method tables}</li>
-     * <li>Have the same {@link #getSymbolicName() name} and {@link #getSymbolicSignature()
-     * signature}.</li>
-     * </ul>
-     *
-     * @param declaredType The {@link PartialType} provided to the virtual table builder. Should
-     *            represent the declaring type of this {@link PartialMethod}.
-     *
-     * @implNote the {@link ModifiersProvider#isFinalFlagSet() final flag} is irrelevant to the
-     *           definition, and will be checked separately to appropriately throw
-     *           {@link MethodTableException} with the
-     *           {@link MethodTableException.Kind#IllegalClassChangeError} kind set.
-     */
-    default boolean canOverride(PartialType<C, M, F> declaredType, M parentMethod) {
-        assert isVirtualEntry() && parentMethod.isVirtualEntry();
-        assert getSymbolicName() == parentMethod.getSymbolicName() && getSymbolicSignature() == parentMethod.getSymbolicSignature();
-        if (parentMethod.isPublic() || parentMethod.isProtected()) {
-            return true;
-        }
-        return declaredType.sameRuntimePackage(parentMethod.getDeclaringClass());
-    }
-
-    /**
-     * Returns whether {@link PartialMethod this method} and the given {@code parentMethod} obey the
-     * same access checks rules.
-     * <p>
-     * This method is used to determine whether it is necessary to allocate a new vtable slot for a
-     * declared method that overrides a method from the super's vtable.
-     * <p>
-     * Implementing this method is not necessary if using
-     * {@link VTable#create(PartialType, boolean, boolean)} with {@code verbose} set to
-     * {@code true}.
-     * <p>
-     * This method should return {@code true} if:
-     * <ul>
-     * <li>Both methods are either {@link ModifiersProvider#isPublic() public} or
-     * {@link ModifiersProvider#isProtected()} protected}</li>
-     * <li>Both methods are {@link ModifiersProvider#isPackagePrivate()} package-private} and the
-     * declaring classes of both method are in the same runtime package.</li>
-     * </ul>
-     * And returns {@code false} otherwise.
-     * <p>
-     * Note that the callers must ensure both methods are not private.
-     *
-     * @param declaredType The {@link PartialType} provided to the virtual table builder. Should
-     *            represent the declaring type of this {@link PartialMethod}.
-     */
-    default boolean sameOverrideAccess(PartialType<C, M, F> declaredType, M parentMethod) {
-        assert isVirtualEntry() && parentMethod.isVirtualEntry();
-        assert getSymbolicName() == parentMethod.getSymbolicName() && getSymbolicSignature() == parentMethod.getSymbolicSignature();
-        if (isPublic() || isProtected()) {
-            return parentMethod.isPublic() || parentMethod.isProtected();
-        }
-        assert isPackagePrivate();
-        return parentMethod.isPackagePrivate() && declaredType.sameRuntimePackage(parentMethod.getDeclaringClass());
-    }
-
     /**
      * This method is not used as part of the vtable creation process, and is provided simply for
      * simplifying the translation from {@link PartialMethod} to {@link MethodAccess} once the

espresso/src/com.oracle.truffle.espresso.shared/src/com/oracle/truffle/espresso/shared/vtable/VTable.java

@@ -62,8 +62,6 @@ public final class VTable {
      *
      * @param targetClass The type for which method tables should be created
      * @param verbose Whether all declared methods should be unconditionally added to the vtable.
-     *            See {@link PartialMethod#sameOverrideAccess(PartialType, MethodAccess)} for more
-     *            details.
      * @param allowInterfaceResolvingToPrivate Whether the runtime allows selection of interface
      *            invokes to select private methods. Requires implementing
      *            {@link PartialType#lookupOverrideWithPrivate(Symbol, Symbol)}.
@@ -79,6 +77,13 @@ public static <C extends TypeAccess<C, M, F>, M extends MethodAccess<C, M, F>, F
         return new Builder<>(targetClass, verbose, allowInterfaceResolvingToPrivate).build();
     }
 
+    /**
+     * Returns whether a given method may appear in a vtable.
+     */
+    public static <C extends TypeAccess<C, M, F>, M extends MethodAccess<C, M, F>, F extends FieldAccess<C, M, F>> boolean isVirtualEntry(PartialMethod<C, M, F> m) {
+        return !m.isPrivate() && !m.isStatic() && !m.isConstructor() && !m.isClassInitializer();
+    }
+
     private static final class Builder<C extends TypeAccess<C, M, F>, M extends MethodAccess<C, M, F>, F extends FieldAccess<C, M, F>> {
         private final boolean verbose;
         private final boolean allowInterfaceResolvingToPrivate;
@@ -124,7 +129,7 @@ private void buildLocations() {
 
         private void assignCandidateTargets() {
             for (PartialMethod<C, M, F> impl : targetClass.getDeclaredMethodsList()) {
-                if (!impl.isVirtualEntry()) {
+                if (!isVirtualEntry(impl)) {
                     continue;
                 }
                 MethodKey k = MethodKey.of(impl);
@@ -159,7 +164,7 @@ private void resolveVirtual() throws MethodTableException {
                                         MethodTableException.Kind.IllegalClassChangeError);
                     }
                     vtable.add(target);
-                    if (!target.sameOverrideAccess(targetClass, m)) {
+                    if (!sameOverrideAccess(target, m)) {
                         currentLocations.markForPopulation();
                     }
                 } else {
@@ -169,7 +174,7 @@ private void resolveVirtual() throws MethodTableException {
             }
             assert vtable.size() == parentTable.size();
             for (PartialMethod<C, M, F> impl : targetClass.getDeclaredMethodsList()) {
-                if (!impl.isVirtualEntry()) {
+                if (!isVirtualEntry(impl)) {
                     continue;
                 }
                 if (verbose) {
@@ -191,7 +196,7 @@ private void resolveInterfaces() {
                 List<PartialMethod<C, M, F>> table = new ArrayList<>(cursor.getValue().size());
 
                 for (M m : parentTable) {
-                    if (!m.isVirtualEntry()) {
+                    if (!isVirtualEntry(m)) {
                         // This should ideally not happen, but we must respect the decisions
                         // previously made for the tables of our super-interfaces.
                         table.add(m);
@@ -208,7 +213,7 @@ private void resolveInterfaces() {
         private void registerFromTable(List<M> table, LocationKind kind) {
             int index = 0;
             for (M m : table) {
-                if (!m.isVirtualEntry()) {
+                if (!isVirtualEntry(m)) {
                     continue;
                 }
                 MethodKey k = MethodKey.of(m);
@@ -222,21 +227,40 @@ private void registerFromTable(List<M> table, LocationKind kind) {
         }
 
         private boolean canOverride(PartialMethod<C, M, F> candidate, M parentMethod, int vtableIndex) {
-            if (candidate.canOverride(targetClass, parentMethod)) {
+            if (canOverride(candidate, parentMethod)) {
                 return true;
             }
             C parentClass = parentMethod.getDeclaringClass().getSuperClass();
             M currentMethod;
             while (parentClass != null &&
                             (currentMethod = parentClass.lookupVTableEntry(vtableIndex)) != null) {
-                if (candidate.canOverride(targetClass, currentMethod)) {
+                if (canOverride(candidate, currentMethod)) {
                     return true;
                 }
                 parentClass = parentClass.getSuperClass();
             }
             return false;
         }
 
+        private boolean canOverride(PartialMethod<C, M, F> candidate, M parentMethod) {
+            assert isVirtualEntry(candidate) && isVirtualEntry(parentMethod);
+            assert candidate.getSymbolicName() == parentMethod.getSymbolicName() && candidate.getSymbolicSignature() == parentMethod.getSymbolicSignature();
+            if (parentMethod.isPublic() || parentMethod.isProtected()) {
+                return true;
+            }
+            return targetClass.sameRuntimePackage(parentMethod.getDeclaringClass());
+        }
+
+        private boolean sameOverrideAccess(PartialMethod<C, M, F> candidate, M parentMethod) {
+            assert isVirtualEntry(candidate) && isVirtualEntry(parentMethod);
+            assert candidate.getSymbolicName() == parentMethod.getSymbolicName() && candidate.getSymbolicSignature() == parentMethod.getSymbolicSignature();
+            if (candidate.isPublic() || candidate.isProtected()) {
+                return parentMethod.isPublic() || parentMethod.isProtected();
+            }
+            assert candidate.isPackagePrivate();
+            return parentMethod.isPackagePrivate() && targetClass.sameRuntimePackage(parentMethod.getDeclaringClass());
+        }
+
         private record MethodKey(Symbol<Name> name, Symbol<Signature> signature) {
             static <C extends TypeAccess<C, M, F>, M extends MethodAccess<C, M, F>, F extends FieldAccess<C, M, F>> MethodKey of(PartialMethod<C, M, F> method) {
                 return new MethodKey(method.getSymbolicName(), method.getSymbolicSignature());

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/impl/EspressoMethodTableBuilder.java

@@ -144,7 +144,7 @@ public Method.MethodVersion[] getMirandas() {
     private static List<PartialMethod<Klass, Method, Field>> filterInterfaceMethods(Method.MethodVersion[] declaredMethods) {
         List<PartialMethod<Klass, Method, Field>> table = new ArrayList<>(declaredMethods.length);
         for (Method.MethodVersion m : declaredMethods) {
-            if (m.getMethod().isVirtualEntry()) {
+            if (VTable.isVirtualEntry(m.getMethod())) {
                 table.add(m.getMethod());
             }
         }