Handle cases where we exit the type resolution without type checking

ballerina-platform · Dec 17, 2024 · ab5691a · ab5691a
1 parent ab2a1b5
commit ab5691a
Show file tree

Hide file tree

Showing 6 changed files with 40 additions and 10 deletions.
diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Context.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Context.java
@@ -52,7 +52,7 @@ public final class Context {
     private int drainedPermits = 0;
     private int nTypeChecking = 0;
     private Phase phase = Phase.INIT;
-    // List<PhaseData> typeCheckPhases = new ArrayList<>();
+    List<PhaseData> typeResolutionPhases = new ArrayList<>();
 
     private Context(Env env) {
         this.env = env;
@@ -100,6 +100,7 @@ public void enterTypeResolutionPhase(MutableSemType type) throws InterruptedExce
             case INIT -> {
                 env.enterTypeResolutionPhase(this, type);
                 phase = Phase.TYPE_RESOLUTION;
+                typeResolutionPhases.add(new PhaseData());
             }
             case TYPE_RESOLUTION -> {
             }
@@ -115,13 +116,13 @@ public void exitTypeResolutionPhaseAbruptly(Exception ex) {
 
     public void enterTypeCheckingPhase(SemType t1, SemType t2) {
         nTypeChecking += 1;
-//        typeCheckPhases.add(new PhaseData(phase, nTypeChecking, Thread.currentThread().getStackTrace()));
         switch (phase) {
             case INIT -> {
                 // This can happen if both types are immutable semtypes
                 phase = Phase.TYPE_CHECKING;
             }
             case TYPE_RESOLUTION -> {
+                typeResolutionPhases.removeLast();
                 drainedPermits = env.enterTypeCheckingPhase(this, t1, t2);
                 phase = Phase.TYPE_CHECKING;
             }
@@ -130,9 +131,14 @@ public void enterTypeCheckingPhase(SemType t1, SemType t2) {
         }
     }
 
+    public void exitTypeResolutionPhase() {
+        if (phase == Phase.TYPE_RESOLUTION) {
+            env.exitTypeResolutionPhase(this);
+        }
+    }
+
     public void exitTypeCheckingPhase() {
         nTypeChecking -= 1;
-//        typeCheckPhases.removeLast();
         switch (phase) {
             case INIT -> throw new IllegalStateException("Cannot exit type checking phase without entering it");
             case TYPE_RESOLUTION ->
@@ -227,17 +233,15 @@ enum Phase {
         INIT, TYPE_RESOLUTION, TYPE_CHECKING
     }
 
-    int getNTypeChecking() {
-        return nTypeChecking;
-    }
+    record PhaseData(StackTraceElement[] stackTrace) {
 
-    record PhaseData(Phase phase, int nTypeCheck, StackTraceElement[] stackTrace) {
+        PhaseData() {
+            this(Thread.currentThread().getStackTrace());
+        }
 
         @Override
         public String toString() {
             StringBuilder builder = new StringBuilder();
-            builder.append("Phase: ").append(phase).append("\n");
-            builder.append("N type checking: ").append(nTypeCheck).append("\n");
             for (StackTraceElement element : stackTrace) {
                 builder.append("\tat ").append(element).append("\n");
             }

diff --git a/...ntime/src/main/java/io/ballerina/runtime/api/types/semtype/DebugSelfDiagnosticRunner.java b/...ntime/src/main/java/io/ballerina/runtime/api/types/semtype/DebugSelfDiagnosticRunner.java
@@ -147,6 +147,13 @@ public void registerAbruptTypeCheckEnd(Context cx, Exception ex) {
         }
     }
 
+    @Override
+    public void registerTypeResolutionExit(Context cx) {
+        synchronized (pendingTypeResolutions) {
+            pendingTypeResolutions.removeIf(data -> data.cx == cx);
+        }
+    }
+
     private static String withIdentity(Object o) {
         return o + "[" + System.identityHashCode(o) + "]";
     }
@@ -174,6 +181,8 @@ private static String pendingTypeResolutionsToString(Collection<TypeResolutionDa
             for (StackTraceElement element : data.t.getStackTrace()) {
                 logBuilder.append("\tat ").append(element).append("\n");
             }
+            logBuilder.append("Entry points\n");
+            data.cx.typeResolutionPhases.forEach(each -> logBuilder.append(each.toString()).append("\n"));
         });
         return logBuilder.toString();
     }

diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Env.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Env.java
@@ -322,10 +322,12 @@ void enterTypeResolutionPhase(Context cx, MutableSemType t) throws InterruptedEx
             synchronized (this) {
                 if (typeResolutionPhaser.isTerminated()) {
                     typeResolutionPhaser = new Phaser();
+                    typeResolutionPhaser.register();
                 }
             }
+        } else {
+            typeResolutionPhaser.register();
         }
-        typeResolutionPhaser.register();
         this.selfDiagnosticsRunner.registerTypeResolutionStart(cx, t);
     }
 
@@ -348,6 +350,12 @@ private void releaseLock(ReentrantReadWriteLock lock) {
         }
     }
 
+    void exitTypeResolutionPhase(Context cx) {
+        typeResolutionSemaphore.release();
+        typeResolutionPhaser.arriveAndDeregister();
+        this.selfDiagnosticsRunner.registerTypeResolutionExit(cx);
+    }
+
     int enterTypeCheckingPhase(Context cx, SemType t1, SemType t2) {
         int drained = typeResolutionSemaphore.drainPermits();
         typeResolutionPhaser.awaitAdvance(typeResolutionPhaser.arriveAndDeregister());

diff --git a/...ntime/src/main/java/io/ballerina/runtime/api/types/semtype/NonOpSelfDiagnosticRunner.java b/...ntime/src/main/java/io/ballerina/runtime/api/types/semtype/NonOpSelfDiagnosticRunner.java
@@ -28,4 +28,9 @@ public void registerAbruptTypeResolutionEnd(Context cx, Exception ex) {
     public void registerAbruptTypeCheckEnd(Context cx, Exception ex) {
 
     }
+
+    @Override
+    public void registerTypeResolutionExit(Context cx) {
+
+    }
 }
diff --git a/.../src/main/java/io/ballerina/runtime/api/types/semtype/TypeCheckSelfDiagnosticsRunner.java b/.../src/main/java/io/ballerina/runtime/api/types/semtype/TypeCheckSelfDiagnosticsRunner.java
@@ -13,4 +13,6 @@ interface TypeCheckSelfDiagnosticsRunner {
     void registerAbruptTypeResolutionEnd(Context cx, Exception ex);
 
     void registerAbruptTypeCheckEnd(Context cx, Exception ex);
+
+    void registerTypeResolutionExit(Context cx);
 }
diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java
@@ -265,6 +265,7 @@ public static boolean checkIsType(Object sourceVal, Type targetType) {
             return true;
         }
         SemType sourceSemType = SemType.tryInto(cx, sourceType);
+        cx.exitTypeResolutionPhase();
         return couldInherentTypeBeDifferent(sourceSemType) &&
                 isSubTypeWithInherentType(cx, sourceVal, SemType.tryInto(cx, targetType));
     }
@@ -822,6 +823,7 @@ public static boolean isEqual(Object lhsValue, Object rhsValue, Set<ValuePair> c
     private static boolean checkValueEqual(Context cx, Object lhsValue, Object rhsValue, Set<ValuePair> checkedValues) {
         SemType lhsShape = ShapeAnalyzer.inherentTypeOf(cx, lhsValue).orElseThrow();
         SemType rhsShape = ShapeAnalyzer.inherentTypeOf(cx, rhsValue).orElseThrow();
+        cx.exitTypeResolutionPhase();
         Predicate<SemType> belongToSameBasicType = (basicType) -> Core.containsBasicType(lhsShape, basicType) &&
                 Core.containsBasicType(rhsShape, basicType);
         if (belongToSameBasicType.test(Builder.getStringType()) ||