コード例 #1
0
        /// <summary>
        ///     Returns type visitor that contains the type variables of f in the context
        /// </summary>
        public static TypeIsaVisitor FunTypeIsaVisitor(Function f, IVariableTranslationFactory varTranslationFactory)
        {
            var typeVarTranslation = varTranslationFactory.CreateEmptyTranslation().TypeVarTranslation;

            /*
             * types variables are numbered as they appear in the list as opposed to type variables appearing later having a smaller number
             * that's the reason the loop iterates in reverse order
             */
            foreach (var tv in ((IEnumerable <TypeVariable>)f.TypeParameters).Reverse())
            {
                typeVarTranslation.AddBoundVariable(tv);
            }

            return(new TypeIsaVisitor(typeVarTranslation));
        }
コード例 #2
0
        /// <summary>The returned list in-sync with <see cref="AllAssumptionLabels" />.</summary>
        public IList <Term> AllAssumptions(
            IDictionary <Function, TermIdent> funInterpMapping,
            IDictionary <NamedDeclaration, Term> declToVCMapping,
            Term state,
            BoogieContextIsa boogieContext,
            IVariableTranslation <Variable> varTranslation
            )
        {
            var assumptions = new List <Term>();

            foreach (var obj in _assumptionLabelMap.Keys)
            {
                if (obj is Function f)
                {
                    assumptions.Add(LemmaHelper.FunctionCtxtWfAssm(f, funInterpMapping, boogieContext));
                    assumptions.Add(LemmaHelper.FunctionVcCorresAssm(f, funInterpMapping, declToVCMapping,
                                                                     boogieContext));
                }
                else if (obj is Variable v)
                {
                    assumptions.Add(LemmaHelper.LocalStateVariableAssumption(v, boogieContext.varContext, state,
                                                                             declToVCMapping, varTranslation));
                    if (!TypeUtil.IsPrimitive(v.TypedIdent.Type))
                    {
                        assumptions.Add(LemmaHelper.VariableTypeAssumption(
                                            v,
                                            declToVCMapping[v],
                                            new TypeIsaVisitor(_factory.CreateEmptyTranslation().TypeVarTranslation),
                                            boogieContext.absValTyMap));
                    }
                }
                else if (obj is SpecialAssumptionsKind kind)
                {
                    switch (kind)
                    {
                    case SpecialAssumptionsKind.TypeValClosed:
                        assumptions.Add(EndToEndAssumptions.ClosednessAssumption(boogieContext.absValTyMap));
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                }
            }

            return(assumptions);
        }