protected ProofOutcome GenericAddPreconditions(ProofObligation obl, IEnumerable <BoxedExpression> preconditions, ProofOutcome originalOutcome,
                                                       InferenceDB preconditionDB, PreconditionChecker checkPrecondition)
        {
            var outcome = originalOutcome;

            foreach (var pre in preconditions)
            {
                if (pre == null)
                {
                    continue;
                }

                // 1. Simplify the expression
                var simplified = SimplifyAndFix(obl.PCForValidation, pre);

                if (simplified == null)
                {
                    continue;
                }

                if (DisjunctivePreconditionsAreDisallowed(simplified))
                {
                    continue;
                }

                // 2. Have we already seen this precondition?
                if (preconditionDB.TryLookUp(obl, simplified, out outcome))
                {
                    continue;
                }
                else
                {
                    outcome = originalOutcome;
                }

                // 3. See if it is valid
                if (checkPrecondition(simplified, outcome, out outcome))
                {
                    preconditionDB.Add(obl, simplified, outcome);
                }
            }

            return(outcome);
        }
        public PostExtractorChecker(
            ContractNodes usedToExtract,
            Action<System.CodeDom.Compiler.CompilerError> errorHandler,
            bool allowPreconditionsInOverrides, bool fSharp, bool explicitUserValidations,
            bool addInterfaceWrappersWhenNeeded, int runtimeCheckingLevel)
        {
            Contract.Requires(errorHandler != null);
            Contract.Requires(usedToExtract != null);

            this.m_errorHandler = errorHandler;
            this.allowPreconditionsInOverrides = allowPreconditionsInOverrides;
            this.explicitUserValidations = explicitUserValidations;
            this.addInterfaceWrappersWhenNeeded = addInterfaceWrappersWhenNeeded;
            this.runtimeCheckingLevel = runtimeCheckingLevel;

            this.purityChecker = new PurityChecker(this.HandleError, fSharp, usedToExtract);
            this.preconditionChecker = new PreconditionChecker(this.HandleError, usedToExtract);
            this.postconditionChecker = new PostconditionChecker(this.HandleError, fSharp);
            this.invariantCallChecker = new CheckForCallsToInvariantMethods(this);
            this.methodBodyChecker = new MethodBodyChecker(this.HandleError, usedToExtract);
            this.invariantChecker = new InvariantChecker(this.HandleError, usedToExtract);
            this.contractNodes = usedToExtract;
            this.visibilityChecker = new VisibilityChecker(this.HandleError, usedToExtract);
            this.invariantMethods = new TrivialHashtable(0);
        }