Fix returntype caching issue for recursive expressions

HaxeFoundation · Jul 13, 2024 · 7162fff · 7162fff
1 parent 56163a7
commit 7162fff
Show file tree

Hide file tree

Showing 2 changed files with 24 additions and 5 deletions.
diff --git a/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluator.java b/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluator.java
@@ -460,15 +460,25 @@ private static ResultHolder resolveWithCache(@NotNull PsiElement element, @NotNu
             hitCounter.put(element, new AtomicInteger(0));
             map.put(element, new CacheRecord(result, resolverAsString));
           }
-        }else  if (result.isFunctionType()) {
-          hitCounter.put(element, new AtomicInteger(0));
-          map.put(element, new CacheRecord(result, resolverAsString));
+        }else  if (result.isFunctionType() && result.getFunctionType() != null) {
+          if (!containsUnknowns(result.getFunctionType())) {
+              hitCounter.put(element, new AtomicInteger(0));
+              map.put(element, new CacheRecord(result, resolverAsString));
+          }
         }
       }
       return result;
     }
   }
 
+  private static boolean containsUnknowns(SpecificFunctionReference type) {
+    if (type.getReturnType().isUnknown()) return true;
+    List<SpecificFunctionReference.Argument> arguments = type.getArguments();
+    for (SpecificFunctionReference.Argument argument : arguments) {
+      if(argument.getType().isUnknown()) return true;
+    }
+    return false;
+  }
 
 
   @NotNull

diff --git a/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluatorHandlers.java b/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluatorHandlers.java
@@ -56,7 +56,7 @@ static ResultHolder handleWithRecursionGuard(PsiElement element,
                                                HaxeGenericResolver resolver) {
     RecursionManager.markStack();
     if (element == null ) return null;
-    return evaluatorHandlersRecursionGuard.computePreventingRecursion(element, true, () -> handle(element, context, resolver));
+    return evaluatorHandlersRecursionGuard.doPreventingRecursion(element, true, () -> handle(element, context, resolver));
   }
 
 
@@ -88,6 +88,15 @@ static ResultHolder handleBinaryExpression(HaxeExpressionEvaluatorContext contex
       String operatorText;
       if (children.length == 3) {
         operatorText = children[1].getText();
+
+        PsiElement LeftChild = children[0];
+        PsiElement rightChild = children[2];
+
+        HaxeGenericResolver lhsResolver = HaxeGenericResolverUtil.generateResolverFromScopeParents(LeftChild);
+        HaxeGenericResolver rhsResolver = HaxeGenericResolverUtil.generateResolverFromScopeParents(rightChild);
+        ResultHolder lhsType = HaxeTypeResolver.getPsiElementType(LeftChild, expression, lhsResolver);
+        ResultHolder rhsType = HaxeTypeResolver.getPsiElementType(rightChild, expression, rhsResolver);
+
         SpecificTypeReference left = handle(children[0], context, resolver).getType();
         SpecificTypeReference right = handle(children[2], context, resolver).getType();
         left = resolveAnyTypeDefs(left);
@@ -280,7 +289,7 @@ else if (subelement instanceof HaxeFieldDeclaration fieldDeclaration) {
                   HaxeGenericResolver inheritedClassResolver = createInheritedClassResolver(containingClass, usedIn, resolver);
                   HaxeGenericResolver resolverForContainingClass = inheritedClassResolver.getSpecialization(null).toGenericResolver(containingClass);
                   ResultHolder resolve = resolverForContainingClass.resolve(typeHolder);
-                  if (!resolve.isUnknown())typeHolder = resolve;
+                  if (resolve != null && !resolve.isUnknown()) typeHolder = resolve;
                 }
 
               }