private <T> T computeWithKnownTargetType(final Computable<T> computable, PsiSubstitutor substitutor) {
    if (myArgumentList instanceof PsiExpressionList) {
      PsiExpressionList argumentList = (PsiExpressionList)myArgumentList;
      PsiElement parent = argumentList.getParent();
      boolean prohibitCaching = CachedValuesManager.getCachedValue(parent,
                                                                   () -> new CachedValueProvider.Result<>(
                                                                     !(parent instanceof PsiCallExpression) ||
                                                                     JavaPsiFacade.getInstance(parent.getProject())
                                                                       .getResolveHelper()
                                                                       .hasOverloads((PsiCallExpression)parent),
                                                                     PsiModificationTracker.MODIFICATION_COUNT));

      PsiExpression[] expressions = Arrays.stream(argumentList.getExpressions())
        .map(expression -> PsiUtil.skipParenthesizedExprDown(expression))
        .filter(expression -> expression != null &&
                              PsiPolyExpressionUtil.isPolyExpression(expression))
        .toArray(PsiExpression[]::new);
      return ThreadLocalTypes.performWithTypes(expressionTypes -> {
        PsiMethod method = getElement();
        boolean varargs = isVarargs();
        for (PsiExpression context : expressions) {
          expressionTypes.forceType(context,
                                    PsiTypesUtil.getTypeByMethod(context, argumentList, method, varargs, substitutor, false));
        }
        return computable.compute();
      }, prohibitCaching);
    }
    else {
      return computable.compute();
    }
  }
private <T> T computeWithKnownTargetType(final Computable<T> computable, PsiSubstitutor substitutor)