Add logic to prevent incorrect result caching

Author: m0rkeulv

src/main/java/com/intellij/plugins/haxe/model/evaluator/HaxeExpressionEvaluator.java

@@ -102,7 +102,7 @@ static public HaxeExpressionEvaluatorContext evaluateWithRecursionGuard(@NotNull
     ProgressIndicatorProvider.checkCanceled();
       HaxeExpressionEvaluatorContext context = new HaxeExpressionEvaluatorContext(element);
       ResultHolder result = handleWithRecursionGuard(element, context, null);
-      context.result = result != null ? result : createUnknown(element);
+      context.result = result != null ? result : createUnknown(element, false);
       return context;
   }
 

src/main/java/com/intellij/plugins/haxe/model/evaluator/HaxeExpressionEvaluatorHandlers.java

@@ -943,7 +943,12 @@ static ResultHolder handleForStatement(
   }
 
   static ResultHolder createUnknown(PsiElement element) {
-    return SpecificHaxeClassReference.getUnknown(element).createHolder();
+    return createUnknown(element, true);
+  }
+  static ResultHolder createUnknown(PsiElement element, boolean cacheable) {
+      ResultHolder holder = getUnknown(element).createHolder();
+      holder.cacheable = cacheable;
+      return holder;
   }
 
   static ResultHolder handlePrefixExpression(
@@ -1809,7 +1814,7 @@ static ResultHolder handleCallExpression(
     }
 
     // @TODO: resolve the function type return type
-    return createUnknown(callExpression);
+    return createUnknown(callExpression, false);
   }
 
   private static ResultHolder tryHandleFunctionBind(SpecificFunctionReference functionReference, HaxeCallExpression callExpression) {

src/main/java/com/intellij/plugins/haxe/model/evaluator/callexpression/CallExpressionArgumentModel.java

@@ -10,10 +10,11 @@
 public class CallExpressionArgumentModel {
   PsiElement psiElement;
   SpecificTypeReference type;
+  boolean canCache;
 
 
-  public static CallExpressionArgumentModel create(PsiElement psiElement, SpecificTypeReference type) {
-    return new CallExpressionArgumentModel(psiElement, type);
+  public static CallExpressionArgumentModel create(PsiElement psiElement, SpecificTypeReference type, boolean canCache) {
+    return new CallExpressionArgumentModel(psiElement, type, canCache);
   }
 
 

src/main/java/com/intellij/plugins/haxe/model/evaluator/callexpression/HaxeCallExpressionContext.java

@@ -54,6 +54,7 @@ private record RecursionKey(PsiElement argumentContext, PsiElement parameterCont
     @Nullable
     private PsiElement sourceExpression;
 
+    public boolean canCache = true;
     public boolean isConstructor = false;
     public boolean isMacroFunction = false;
     public boolean isStaticExtension = false;
@@ -186,7 +187,7 @@ private HaxeCallExpressionEvaluation evaluate(boolean trackErrors, PsiElement so
             // while it might be a waste to re-evaluate the callie assignability
             // we do it  here because we need to keep track if typeParameters
             // perhaps the logic above can be moved down into the argument/parameter check loop
-            argumentsList.addFirst(new CallExpressionArgumentModel(callie.context, callie));
+            argumentsList.addFirst(new CallExpressionArgumentModel(callie.context, callie, false));
         }
 
         CallExpressionArgumentModel argumentModel = null;

src/main/java/com/intellij/plugins/haxe/model/evaluator/callexpression/HaxeCallExpressionUtil.java

@@ -238,6 +238,7 @@ public static HaxeCallExpressionContext createContextForConstructorCall(@NotNull
     List<CallExpressionArgumentModel> argumentList = getArgumentList(newExpression);
     ResultHolder type = HaxeTypeResolver.getTypeFromType(newExpression.getType());
     SpecificHaxeClassReference classType = type.getClassType();
+    boolean canCache = type.cacheable && argumentList.stream().allMatch(CallExpressionArgumentModel::isCanCache);
     if (classType != null) {
       SpecificTypeReference typeRef = classType.fullyResolveTypeDefAndUnwrapNullTypeReference();
       if (typeRef instanceof SpecificHaxeClassReference classReference ) {
@@ -273,6 +274,7 @@ public static HaxeCallExpressionContext createContextForConstructorCall(@NotNull
             evaluation.isMacroFunction = false;
             evaluation.isEnumConstructor = false; // enums dont use the new keyword
             evaluation.isConstructor = true;
+            evaluation.canCache = canCache;
             return evaluation;
           }
         }
@@ -303,7 +305,7 @@ private static List<CallExpressionParameterModel> getParameterList(@NotNull Spec
       List<HaxeExpression> expressions = expressionListPsi.getExpressionList();
       for (HaxeExpression expression : expressions) {
         ResultHolder result = HaxeExpressionEvaluator.evaluateWithRecursionGuard(expression).result;
-        CallExpressionArgumentModel model = CallExpressionArgumentModel.create(expression, result.getType());
+        CallExpressionArgumentModel model = CallExpressionArgumentModel.create(expression, result.getType(), result.cacheable);
         argumentList.add(model);
       }
     }
@@ -313,17 +315,18 @@ private static List<CallExpressionParameterModel> getParameterList(@NotNull Spec
     List<CallExpressionArgumentModel> argumentList = new ArrayList<>();
       List<HaxeExpression> expressions = newExpression.getExpressionList();
       for (HaxeExpression expression : expressions) {
-        ResultHolder result = HaxeExpressionEvaluator.evaluateWithRecursionGuard(expression).result;
-        CallExpressionArgumentModel model = CallExpressionArgumentModel.create(expression, result.getType());
-        argumentList.add(model);
+          ResultHolder result = HaxeExpressionEvaluator.evaluateWithRecursionGuard(expression).result;
+          CallExpressionArgumentModel model = CallExpressionArgumentModel.create(expression, result.getType(), result.cacheable);
+          model.canCache = result.cacheable;
+          argumentList.add(model);
       }
     return argumentList;
   }
 
   private static @NotNull List<CallExpressionArgumentModel> getArgumentList(@NotNull List<SpecificTypeReference> types) {
     List<CallExpressionArgumentModel> argumentList = new ArrayList<>();
     for (SpecificTypeReference type : types) {
-      CallExpressionArgumentModel model = CallExpressionArgumentModel.create(type.getElementContext(), type);
+      CallExpressionArgumentModel model = CallExpressionArgumentModel.create(type.getElementContext(), type, false);
       argumentList.add(model);
     }
     return argumentList;