From 7162fffc743acc3026f6a745b30edc0dc5b16d77 Mon Sep 17 00:00:00 2001
From: m0rkeulv <github@m0rkeulv.net>
Date: Sat, 13 Jul 2024 13:54:09 +0200
Subject: [PATCH] Fix returntype caching issue for recursive expressions

---
 .../haxe/model/type/HaxeExpressionEvaluator.java | 16 +++++++++++++---
 .../type/HaxeExpressionEvaluatorHandlers.java    | 13 +++++++++++--
 2 files changed, 24 insertions(+), 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
index abb77713d..77be93123 100644
--- 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
index 8957ce010..5b335d237 100644
--- 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;
                 }
 
               }