private static @NotNull Map<PsiExpression, ThreeState> computeOperandValues(PsiPolyadicExpression expressionToAnalyze) {
    DfaValueFactory factory = new DfaValueFactory(expressionToAnalyze.getProject());
    ControlFlow flow = ControlFlowAnalyzer.buildFlow(expressionToAnalyze, factory, true);
    if (flow == null) return Map.of();
    var listener = new JavaDfaListener() {
      final Map<PsiExpression, ThreeState> values = new HashMap<>();
      final Set<DfaVariableValue> myOkNullChecks = new HashSet<>();
      DataFlowInterpreter myInterpreter;

      @Override
      public void beforeExpressionPush(@NotNull DfaValue value,
                                       @NotNull PsiExpression expression,
                                       @NotNull DfaMemoryState state) {
        if (value instanceof DfaVariableValue && myOkNullChecks.contains(value)) {
          DfType type = state.getDfType(value);
          if (type instanceof DfReferenceType && ((DfReferenceType)type).getNullability() == DfaNullability.NOT_NULL) {
            type = type instanceof DfConstantType ? DfType.TOP : ((DfReferenceType)type).dropNullability();
            ((DfaMemoryStateImpl)state).recordVariableType((DfaVariableValue)value, type);
          }
        }
        if (PsiUtil.skipParenthesizedExprUp(expression.getParent()) != expressionToAnalyze) return;
        ThreeState old = values.get(expression);
        if (old == ThreeState.UNSURE) return;
        ThreeState result = ThreeState.UNSURE;
        Boolean bool = state.getDfType(value).getConstantOfType(Boolean.class);
        if (bool != null) {
          result = ThreeState.fromBoolean(bool);
        }
        values.put(expression, old == null || old == result ? result : ThreeState.UNSURE);
      }

      @Override
      public void onCondition(@NotNull UnsatisfiedConditionProblem problem,
                              @NotNull DfaValue value,
                              @NotNull ThreeState failed,
                              @NotNull DfaMemoryState state) {
        if (failed != ThreeState.NO && problem instanceof ContractFailureProblem) {
          myInterpreter.cancel();
        }
        else if (problem instanceof NullabilityProblemKind.NullabilityProblem<?> && value instanceof DfaVariableValue) {
          myOkNullChecks.add((DfaVariableValue)value);
        }
      }
    };
    var interpreter = new StandardDataFlowInterpreter(flow, listener);
    listener.myInterpreter = interpreter;
    RunnerResult result = interpreter.interpret(createMemoryState(factory));
    return result == RunnerResult.OK ? listener.values : Collections.emptyMap();
  }
private static @NotNull Map<PsiExpression, ThreeState> computeOperandValues(PsiPolyadicExpression expressionToAnalyze)