Experimental caching of CallExpression evaluations

Author: m0rkeulv

src/main/java/com/intellij/plugins/haxe/ide/completion/HaxeCompletionPriorityUtil.java

@@ -8,8 +8,8 @@
 import com.intellij.plugins.haxe.ide.lookup.*;
 import com.intellij.plugins.haxe.lang.psi.*;
 import com.intellij.plugins.haxe.model.*;
+import com.intellij.plugins.haxe.model.evaluator.HaxeCallExpressionEvaluatorCacheService;
 import com.intellij.plugins.haxe.model.evaluator.HaxeExpressionEvaluator;
-import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionContext;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionContextContainer;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionEvaluation;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionUtil;
@@ -294,8 +294,7 @@ private static HaxeCallExpressionEvaluation getValidationForMethod(HaxeCallExpre
     if (callExpression.getExpression() instanceof HaxeReferenceExpression referenceExpression) {
       PsiElement resolve = referenceExpression.resolve();
       if (resolve instanceof HaxeMethod method) {
-        HaxeCallExpressionContextContainer contextContainer = HaxeCallExpressionUtil.createContextForMethodCall(callExpression, method);
-        return contextContainer.evaluateContexts();
+        return HaxeCallExpressionEvaluatorCacheService.cachedHaxeCallExpressionEvaluation(method, callExpression);
       }
     }
     return null;

src/main/java/com/intellij/plugins/haxe/ide/hint/parameters/HaxeInlayParameterHintsProvider.java

@@ -6,6 +6,7 @@
 import com.intellij.plugins.haxe.HaxeHintBundle;
 import com.intellij.plugins.haxe.lang.psi.*;
 import com.intellij.plugins.haxe.model.*;
+import com.intellij.plugins.haxe.model.evaluator.HaxeCallExpressionEvaluatorCacheService;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionContext;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionContextContainer;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionEvaluation;
@@ -94,8 +95,7 @@ private void handleEnumValueConstructor(HaxeCallExpression callExpression, HaxeE
     List<HaxeExpression> expressions = expressionList == null ? List.of() : expressionList.getExpressionList();
 
     if (enumValueModel instanceof HaxeEnumValueConstructorModel constructorModel && constructorModel.getConstructorParameters() != null) {
-      HaxeCallExpressionContextContainer contextContainer = HaxeCallExpressionUtil.createContextForMethodCall(callExpression, constructorModel.getMethod());
-      HaxeCallExpressionEvaluation validation = contextContainer.evaluateContexts();
+      HaxeCallExpressionEvaluation validation = HaxeCallExpressionEvaluatorCacheService.cachedHaxeCallExpressionEvaluation(constructorModel.getMethod(), callExpression);
       if(validation != null) {
         List<HaxeParameterModel> parameters = MapParametersToModel(constructorModel.getConstructorParameters());
         processArguments(validation.getArgumentToParameterMapping(), expressions, parameters, infoList, false);

src/main/java/com/intellij/plugins/haxe/ide/hint/types/HaxeSharedBypassCollector.java

@@ -61,7 +61,7 @@ private static void buildTypeTexts(ResultHolder type, PresentationTreeBuilder bu
                 builder.text(className, inlayActionData);
             }
             // hide Unknown generics if Dynamic
-            if(type.isDynamic() && type.containsUnknownTypeParameters()) return;;
+            if(type.isDynamic() && type.containsUnknownOrUnresolvedTypeParameters()) return;;
 
             @NotNull ResultHolder[] specifics = classReference.getSpecifics();
             if(specifics.length > 0 ) {

src/main/java/com/intellij/plugins/haxe/ide/inspections/intentions/HaxeUnresolvedSymbolIntentionBase.java

@@ -11,6 +11,7 @@
 import com.intellij.plugins.haxe.model.HaxeBaseMemberModel;
 import com.intellij.plugins.haxe.model.HaxeClassModel;
 import com.intellij.plugins.haxe.model.HaxeFieldModel;
+import com.intellij.plugins.haxe.model.evaluator.HaxeCallExpressionEvaluatorCacheService;
 import com.intellij.plugins.haxe.model.evaluator.HaxeExpressionEvaluator;
 import com.intellij.plugins.haxe.model.evaluator.HaxeExpressionEvaluatorContext;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionContextContainer;
@@ -324,8 +325,7 @@ private static ResultHolder findTypeFromCallExpression(HaxeCallExpressionList li
         if (callExpression.getExpression() instanceof HaxeReference reference) {
           PsiElement resolved = reference.resolve();
           if (resolved instanceof HaxeMethod method) {
-            HaxeCallExpressionContextContainer contextContainer = HaxeCallExpressionUtil.createContextForMethodCall(callExpression, method);
-            HaxeCallExpressionEvaluation validation = contextContainer.evaluateContexts();
+            HaxeCallExpressionEvaluation validation = HaxeCallExpressionEvaluatorCacheService.cachedHaxeCallExpressionEvaluation(method, callExpression);
             if (validation != null) {
               Integer parameterIndex = validation.getArgumentToParameterMapping().get(index);
               if (parameterIndex != null) {

src/main/java/com/intellij/plugins/haxe/lang/psi/HaxeResolver.java

@@ -37,6 +37,7 @@
 import com.intellij.plugins.haxe.metadata.psi.HaxeMetadataCompileTimeMeta;
 import com.intellij.plugins.haxe.metadata.util.HaxeMetadataUtils;
 import com.intellij.plugins.haxe.model.*;
+import com.intellij.plugins.haxe.model.evaluator.HaxeCallExpressionEvaluatorCacheService;
 import com.intellij.plugins.haxe.model.evaluator.HaxeExpressionEvaluator;
 import com.intellij.plugins.haxe.model.evaluator.HaxeExpressionEvaluatorContext;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionContextContainer;
@@ -259,7 +260,7 @@ private List<? extends PsiElement> doResolveInner(@NotNull HaxeReference referen
                 }
             return matchesInImport.isEmpty() ? null : matchesInImport;
           }
-        boolean expectedEnumIsConstructor = parent instanceof HaxeCallExpression;
+        boolean expectedEnumIsConstructor = parent instanceof HaxeCallExpression|| parent.getParent() instanceof  HaxeEnumArgumentExtractor;
         PsiElement target = HaxeResolveUtil.searchInSamePackage(fileModel, referenceText, true, expectedEnumIsConstructor);
 
         if (target != null) {
@@ -432,8 +433,7 @@ private ResultHolder findParentAssignType(@NotNull PsiElement reference, boolean
             PsiElement resolve = referenceExpression.resolve();
             if (resolve instanceof HaxeMethod method) {
               int index = expressionList.getExpressionList().indexOf(reference);
-              HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(callExpression, method);
-              HaxeCallExpressionEvaluation evaluate = contextContainer.evaluateContexts();
+              HaxeCallExpressionEvaluation evaluate = cachedHaxeCallExpressionEvaluation(method, callExpression);
               return evaluate == null ? null : evaluate.getParameterType(index);
             }
           }
@@ -477,8 +477,7 @@ private ResultHolder findParentAssignType(@NotNull PsiElement reference, boolean
           PsiElement resolve = referenceExpression.resolve();
           if (resolve instanceof HaxeMethod method) {
             int index = expressionList.getExpressionList().indexOf(reference);
-            HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(callExpression, method);
-            HaxeCallExpressionEvaluation evaluate = contextContainer.evaluateContexts();
+            HaxeCallExpressionEvaluation evaluate = cachedHaxeCallExpressionEvaluation(method, callExpression);
             return evaluate == null ? null : evaluate.getParameterType(index);
           }
         }
@@ -538,11 +537,17 @@ private ResultHolder findParentAssignType(@NotNull PsiElement reference, boolean
     return findParentAssignType(parent, isValueExpression);
   }
 
+  private static @Nullable HaxeCallExpressionEvaluation cachedHaxeCallExpressionEvaluation(HaxeMethod method, HaxeCallExpression callExpression) {
+
+    HaxeCallExpressionEvaluatorCacheService service = method.getProject().getService(HaxeCallExpressionEvaluatorCacheService.class);
+    HaxeCallExpressionEvaluation evaluation = service.callExpressionCachedEvaluation(method, callExpression);
+    return evaluation;
+  }
+
   private static boolean testAsEnumValueConstructor(@NotNull HaxeEnumValueDeclarationConstructor enumValueDeclaration, @NotNull HaxeReference reference) {
       if (reference.getParent() instanceof HaxeCallExpression haxeCallExpression) {
         HaxeMethod method = enumValueDeclaration.getModel().getMethod();
-        HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(haxeCallExpression, method);
-        HaxeCallExpressionEvaluation validation = contextContainer.evaluateContexts();
+        HaxeCallExpressionEvaluation validation = cachedHaxeCallExpressionEvaluation(method, haxeCallExpression);
         return validation != null && validation.isCompleted() && validation.isValid();
       }
     return false;
@@ -909,8 +914,7 @@ private List<? extends PsiElement> checkEnumMemberHints(HaxeReference reference)
           if (argumentList != null) {
             int argumentIndex = argumentList.getExpressionList().indexOf(argument);
             if (argumentIndex > -1) {
-              HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(methodCallCall, haxeMethod);
-              HaxeCallExpressionEvaluation validation = contextContainer.evaluateContexts();
+              HaxeCallExpressionEvaluation validation = cachedHaxeCallExpressionEvaluation(haxeMethod, methodCallCall);
               if(validation != null) {
                 int parameterIndex = validation.getParameterForArgument(argumentIndex);
                 ResultHolder parameterType = validation.getParameterType(parameterIndex);
@@ -1915,8 +1919,7 @@ private List<? extends PsiElement> checkByTreeWalk(HaxeReference reference,  @Nu
           // the code might be incomplete and validation might fail so we keep track of the element
           // as a method  match is more correct than a field match
           bestGuess = psiElement;
-          HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(callExpression, method);
-          HaxeCallExpressionEvaluation evaluation = contextContainer.evaluateContexts();
+          HaxeCallExpressionEvaluation evaluation = cachedHaxeCallExpressionEvaluation(method, callExpression);
           if (evaluation != null && evaluation.isValid()) {
             LogResolution(reference, "via tree walk. (method filtered)");
             return List.of(psiElement);
@@ -2445,8 +2448,7 @@ private static void clearFakePsi(HaxeReference reference) {
     for (HaxeBaseMemberModel member : members) {
       if (member instanceof HaxeMethodModel methodModel) {
         if (reference.getParent() instanceof HaxeCallExpression callExpression) {
-          HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(callExpression, methodModel.getMethod());
-          HaxeCallExpressionEvaluation evaluate = contextContainer.evaluateContexts();
+          HaxeCallExpressionEvaluation evaluate = cachedHaxeCallExpressionEvaluation(methodModel.getMethod(), callExpression);
           if (evaluate != null && evaluate.isValid()) {
             return Collections.singletonList(member.getNamedComponentPsi());
           }
@@ -2455,8 +2457,7 @@ private static void clearFakePsi(HaxeReference reference) {
           if (argumentList.getParent() instanceof HaxeCallExpression callExpression) {
             if (callExpression.getExpression() instanceof HaxeReferenceExpression referenceExpression) {
               if (referenceExpression.resolve() instanceof HaxeMethod haxeMethod) {
-                HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(callExpression, haxeMethod);
-                HaxeCallExpressionEvaluation evaluate = contextContainer.evaluateContexts();
+                HaxeCallExpressionEvaluation evaluate = cachedHaxeCallExpressionEvaluation(haxeMethod, callExpression);
                 if(evaluate != null) {
                   int paramIndex = evaluate.getParameterForArgument(argIndex);
                   if (paramIndex != -1) {

src/main/java/com/intellij/plugins/haxe/lang/psi/impl/HaxeReferenceImpl.java

@@ -34,6 +34,7 @@
 import com.intellij.plugins.haxe.metadata.psi.HaxeMeta;
 import com.intellij.plugins.haxe.metadata.util.HaxeMetadataUtils;
 import com.intellij.plugins.haxe.model.*;
+import com.intellij.plugins.haxe.model.evaluator.HaxeCallExpressionEvaluatorCacheService;
 import com.intellij.plugins.haxe.model.evaluator.HaxeExpressionEvaluator;
 import com.intellij.plugins.haxe.model.evaluator.HaxeExpressionEvaluatorContext;
 import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionContextContainer;
@@ -928,8 +929,7 @@ public static ResultHolder tryToFindTypeFromCallExpression(@NotNull HaxeFunction
               if (expressionListPsi != null) {
                 expressionList = expressionListPsi.getExpressionList();
                 methodModel = haxeMethod.getModel();
-                HaxeCallExpressionContextContainer contextContainer = HaxeCallExpressionUtil.createContextForMethodCall(callExpression, haxeMethod);
-                validation = contextContainer.evaluateContexts();
+                validation = HaxeCallExpressionEvaluatorCacheService.cachedHaxeCallExpressionEvaluation(haxeMethod, callExpression);
               }
             }
           }

src/main/java/com/intellij/plugins/haxe/model/HaxeMethodModel.java

@@ -194,7 +194,7 @@ public ResultHolder getReturnType(@Nullable HaxeGenericResolver resolver) {
     ResultHolder result = CachedValuesManager.getProjectPsiDependentCache(haxeMethod, HaxeMethodModel::getReturnTypeCacheProvider);
     if (resolver != null) {
       ResultHolder resolve = resolver.resolve(result);
-      if(resolve != null && resolve.containsUnknownTypeParameters()){
+      if(resolve != null && resolve.containsUnknownOrUnresolvedTypeParameters()){
         // Special corner-case, might be only for multi-type abstracts ?
         // if we dont have any typeTag the return type is resolved come from an expression, and for abstracts that can be underlying type
         // and in the case of abstract Map(IMap) methods like the "get" method that use underlying type that is an interface so we need to translate

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

@@ -0,0 +1,79 @@
+package com.intellij.plugins.haxe.model.evaluator;
+
+import com.intellij.plugins.haxe.lang.psi.HaxeCallExpression;
+import com.intellij.plugins.haxe.lang.psi.HaxeMethod;
+import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionContextContainer;
+import com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionEvaluation;
+import com.intellij.plugins.haxe.model.type.ResultHolder;
+import lombok.CustomLog;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static com.intellij.plugins.haxe.model.evaluator.callexpression.HaxeCallExpressionUtil.createContextForMethodCall;
+
+/**
+ * Avoids unnecessary re-evaluation of callExpressions
+ */
+@CustomLog
+public class HaxeCallExpressionEvaluatorCacheService  {
+
+  private volatile  Map<CallExpressionEvaluationKey, HaxeCallExpressionEvaluation> cacheMap = new ConcurrentHashMap<>();
+  public static boolean skipCaching = false;// just convenience flag for debugging
+
+  public static @Nullable HaxeCallExpressionEvaluation cachedHaxeCallExpressionEvaluation(HaxeMethod method, HaxeCallExpression callExpression) {
+
+    HaxeCallExpressionEvaluatorCacheService service = method.getProject().getService(HaxeCallExpressionEvaluatorCacheService.class);
+    return  service.callExpressionCachedEvaluation(method, callExpression);
+
+  }
+
+
+  public @Nullable HaxeCallExpressionEvaluation callExpressionCachedEvaluation(HaxeMethod method, HaxeCallExpression callExpression) {
+
+    if(skipCaching){
+      HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(callExpression, method);
+      return contextContainer.evaluateContexts();
+    }
+
+    CallExpressionEvaluationKey key = new CallExpressionEvaluationKey(method, callExpression);
+    if (cacheMap.containsKey(key)) {
+      return cacheMap.get(key);
+    }
+
+    HaxeCallExpressionContextContainer contextContainer = createContextForMethodCall(callExpression, method);
+    HaxeCallExpressionEvaluation evaluate = contextContainer.evaluateContexts();
+    if(evaluate == null) return null;
+
+    if(evaluate.isValid() && evaluate.isCompleted()) {
+      if(noUnknownResolvedValues(evaluate)) {
+        cacheMap.put(key, evaluate);
+      }
+    }
+
+    return evaluate;
+  }
+
+    private boolean noUnknownResolvedValues(HaxeCallExpressionEvaluation evaluate) {
+      if(evaluate.getReturnTypeWithoutResolve().containsUnknownTypes()) {
+        return false;
+      }
+      for (ResultHolder argumentType : evaluate.getParameterTypes()) {
+        if(argumentType.containsUnknownTypes()) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+
+  public void clearCaches() {
+    synchronized(this) {
+      cacheMap.clear();
+    }
+  }
+}
+
+record CallExpressionEvaluationKey(HaxeMethod method, HaxeCallExpression callExpression) {
+}

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

@@ -743,8 +743,7 @@ private static ResultHolder checkSearchResult(HaxeExpressionEvaluatorContext con
           final HaxeReference leftReference = PsiTreeUtil.getChildOfType(callExpression.getExpression(), HaxeReference.class);
           if (hint != null && leftReference == reference) {
             if (resolved instanceof HaxeMethod method ) {
-              HaxeCallExpressionContextContainer contextContainer = HaxeCallExpressionUtil.createContextForMethodCall(callExpression, method);
-              HaxeCallExpressionEvaluation validation  = contextContainer.evaluateContexts();
+              HaxeCallExpressionEvaluation validation = HaxeCallExpressionEvaluatorCacheService.cachedHaxeCallExpressionEvaluation(method, callExpression);
               if(validation != null) {
                 ResultHolder hintResolved = validation.getCallExpressionResolver().resolve(hint);
                 if (hintResolved != null) return hintResolved;

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

@@ -18,6 +18,7 @@ public HaxeExpressionEvaluatorCacheChangeListener(Project project) {
 
   public void modificationCountChanged() {
     myProject.getService(HaxeExpressionEvaluatorCacheService.class).clearCaches();
+    myProject.getService(HaxeCallExpressionEvaluatorCacheService.class).clearCaches();
   }
 }