public SyntacticInformation(IDisjunctiveExpressionRefiner <Variable, BoxedExpression> refiner,
                                    IEnumerable <SyntacticTest> codeTests, IEnumerable <RightExpression> codeExpressions, Dictionary <Variable, APC> variableDefinitions,
                                    IEnumerable <Field> mayUpdateFields,
                                    IEnumerable <MethodCallInfo <Method, Variable> > methodCalls,
                                    List <Tuple <Pair <APC, APC>, Dictionary <Variable, HashSet <Variable> > > > renamingsInfo,
                                    List <Tuple <Pair <APC, APC>, int> > renamingsLength,
                                    bool HasThrow, bool HasExceptionHandlers)
        {
            Contract.Requires(refiner != null);
            Contract.Requires(codeTests != null);
            Contract.Requires(codeExpressions != null);
            Contract.Requires(variableDefinitions != null);
            Contract.Requires(mayUpdateFields != null);
            Contract.Requires(methodCalls != null);
            Contract.Requires(renamingsInfo != null);
            Contract.Requires(renamingsLength != null);

            this.DisjunctionRefiner   = refiner;
            this.TestsInTheMethod     = codeTests.Where(t => t.Guard != null);
            this.RightExpressions     = codeExpressions.Where(t => t.RValueExpression != null);
            this.VariableDefinitions  = variableDefinitions;
            this.MayUpdatedFields     = mayUpdateFields;
            this.MethodCalls          = methodCalls;
            this.HasThrow             = HasThrow;
            this.HasExceptionHandlers = HasExceptionHandlers;
            this.Renamings            = new Renamings <Variable>(renamingsLength, renamingsInfo);
        }
        public BoxedExpressionReader(IExpressionContext <Local, Parameter, Method, Field, Typ, Expression, Variable> context,
                                     IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Typ, Attribute, Assembly> metaDataDecoder,
                                     IDisjunctiveExpressionRefiner <Variable, BoxedExpression> extendedRefiner = null)
        {
            Contract.Requires(context != null);
            Contract.Requires(metaDataDecoder != null);

            this.context         = context;
            this.metaDataDecoder = metaDataDecoder;
            this.extendedRefiner = extendedRefiner;

            Variable retVar;

            if (!this.metaDataDecoder.IsVoidMethod(this.context.MethodContext.CurrentMethod) &&
                this.context.ValueContext.TryResultValue(this.context.MethodContext.CFG.NormalExit, out retVar))
            {
                this.returnVariable = new Optional <Variable>(retVar);
                Typ type = this.metaDataDecoder.ReturnType(this.context.MethodContext.CurrentMethod);
                this.returnExpression = BoxedExpression.Result(type);
            }
            else
            {
                this.returnVariable   = new Optional <Variable>();
                this.returnExpression = null;
            }
        }