static Map<PsiElement, @InspectionMessage String> checkContractClause(PsiMethod method, StandardMethodContract contract, boolean ownContract) {
    PsiCodeBlock body = method.getBody();
    if (body == null) return Collections.emptyMap();

    DfaValueFactory factory = new DfaValueFactory(method.getProject());
    ControlFlow flow = ControlFlowAnalyzer.buildFlow(body, factory, true);
    if (flow == null) return Collections.emptyMap();
    ContractCheckListener interceptor = new ContractCheckListener(method, contract, ownContract);
    StandardDataFlowInterpreter interpreter = new StandardDataFlowInterpreter(flow, interceptor, true) {
      @Override
      protected DfaInstructionState @NotNull [] acceptInstruction(@NotNull DfaInstructionState instructionState) {
        Instruction instruction = instructionState.getInstruction();
        DfaMemoryState memState = instructionState.getMemoryState();
        if (instruction instanceof ThrowInstruction) {
          ContainerUtil.addIfNotNull(interceptor.myFailures, ((ThrowInstruction)instruction).getAnchor());
        }
        else if (instruction instanceof ReturnInstruction) {
          interceptor.myMayReturnNormally = true;
        }
        else if (instruction instanceof MethodCallInstruction) {
          PsiCall call = ((MethodCallInstruction)instruction).getCallExpression();
          if (!memState.isEphemeral() && call != null) {
            if (interceptor.myContract.getReturnValue().isFail()) {
              interceptor.myFailures.add(call);
              return DfaInstructionState.EMPTY_ARRAY;
            }
            if (ContractCheckListener.weCannotInferAnythingAboutMethodReturnValue((MethodCallInstruction)instruction)) {
              DfaInstructionState[] states = super.acceptInstruction(instructionState);
              for (DfaInstructionState state : states) {
                state.getMemoryState().markEphemeral();
              }
              return states;
            }
          }
        }
        return super.acceptInstruction(instructionState);
      }
    };
    PsiParameter[] parameters = method.getParameterList().getParameters();
    final DfaMemoryState initialState = DfaUtil.createStateWithEnabledAssertions(factory);
    for (int i = 0; i < contract.getParameterCount(); i++) {
      ValueConstraint constraint = contract.getParameterConstraint(i);
      DfaValue comparisonValue = constraint.getComparisonValue(factory);
      if (comparisonValue != null) {
        boolean negated = constraint.shouldUseNonEqComparison();
        DfaVariableValue dfaParam = PlainDescriptor.createVariableValue(factory, parameters[i]);
        initialState.applyCondition(dfaParam.cond(RelationType.equivalence(!negated), comparisonValue));
      }
    }
    interpreter.interpret(initialState);
    return interceptor.getErrors();
  }
static Map<PsiElement, @InspectionMessage String> checkContractClause(PsiMethod method, StandardMethodContract contract, boolean ownContract)