internal DoStatementBuilder(SourceSpan statementSpan, SourceLocation location, Statement body) {
            Contract.RequiresNotNull(body, "body");

            _body = body;
            _doLocation = location;
            _statementSpan = statementSpan;
        }

 public static CatchBlock Catch(SourceSpan span, SourceLocation header, Type type, Variable target, Statement body)
 {
     Contract.RequiresNotNull(type, "type");
     Contract.Requires(target == null || TypeUtils.CanAssign(target.Type, type), "target");
     Contract.RequiresNotNull(body, "body");
     return new CatchBlock(span, header, type, target, body);
 }

 public static TryStatement TryCatchFinally(SourceSpan span, SourceLocation header, Statement body, CatchBlock[] handlers, Statement @finally)
 {
     return new TryStatement(
         span, header,
          body, CollectionUtils.ToReadOnlyCollection(handlers), @finally
     );
 }

        public static ScopeStatement Scope(SourceSpan span, Expression scope, Statement body) {
            Contract.RequiresNotNull(scope, "scope");
            Contract.RequiresNotNull(body, "body");
            Contract.Requires(TypeUtils.CanAssign(typeof(IAttributesCollection), scope.Type), "scope", "Scope must be IAttributesCollection");

            return new ScopeStatement(span, scope, body);
        }

 public static ThrowStatement Throw(SourceSpan span, Expression value)
 {
     if (value != null) {
         Contract.Requires(TypeUtils.CanAssign(typeof(Exception), value.Type));
     }
     return new ThrowStatement(span, value);
 }

        public static SwitchStatement Switch(SourceSpan span, SourceLocation header, Expression value, params SwitchCase[] cases)
        {
            Contract.RequiresNotNull(value, "value");
            Contract.Requires(value.Type == typeof(int), "value", "Value must be int");
            Contract.RequiresNotEmpty(cases, "cases");
            Contract.RequiresNotNullItems(cases, "cases");

            bool @default = false;
            int max = Int32.MinValue;
            int min = Int32.MaxValue;
            foreach (SwitchCase sc in cases) {
                if (sc.IsDefault) {
                    Contract.Requires(@default == false, "cases", "Only one default clause allowed");
                    @default = true;
                } else {
                    int val = sc.Value;
                    if (val > max) max = val;
                    if (val < min) min = val;
                }
            }

            Contract.Requires(UniqueCaseValues(cases, min, max), "cases", "Case values must be unique");

            return new SwitchStatement(span, header, value, CollectionUtils.ToReadOnlyCollection(cases));
        }

 public CustomErrorCorrection(int errorId, SourceSpan errorSpan, params object[] parameters)
     : base(CorrectionMethod.Custom)
 {
     ErrorId = errorId;
     ErrorSpan = errorSpan;
     Parameters = parameters;
 }

        public LexemeValue(string content, SourceSpan span)
        {
            CodeContract.RequiresArgumentNotNull(span, "span");

            Content = content;
            Span = span;
        }

 /// <summary>
 /// Called by <see cref="DoStatementBuilder"/>.
 /// </summary>
 internal DoStatement(SourceSpan span, SourceLocation header, Expression /*!*/ test, Statement /*!*/ body)
     : base(AstNodeType.DoStatement, span)
 {
     _header = header;
     _test = test;
     _body = body;
 }

 /// <summary>
 /// Null test means infinite loop.
 /// </summary>
 internal LoopStatement(SourceSpan span, SourceLocation header, Expression test, Expression increment, Statement /*!*/ body, Statement @else)
     : base(AstNodeType.LoopStatement, span) {
     _test = test;
     _increment = increment;
     _body = body;
     _else = @else;
     _header = header;
 }

        public static IfStatementTest IfCondition(SourceSpan span, SourceLocation header, Expression test, Statement body)
        {
            Contract.RequiresNotNull(test, "test");
            Contract.RequiresNotNull(body, "body");
            Contract.Requires(test.Type == typeof(bool), "test", "Test must be boolean");

            return new IfStatementTest(span, header, test, body);
        }

        internal SwitchStatement(SourceSpan span, SourceLocation header, Expression/*!*/ testValue, ReadOnlyCollection<SwitchCase>/*!*/ cases)
            : base(AstNodeType.SwitchStatement, span) {
            Assert.NotNullItems(cases);

            _testValue = testValue;
            _cases = cases;
            _header = header;
        }

 internal Lexeme(ScannerInfo scannerInfo, int state, SourceSpan span, string value, int skippedTokenCount)
 {
     m_scannerInfo = scannerInfo;
     m_stateIndex = state;
     Span = span;
     Value = value;
     SkippedTokenCount = skippedTokenCount;
 }

        internal Lexeme(ScannerInfo scannerInfo, int state, SourceSpan span, string content)
        {
            m_scannerInfo = scannerInfo;
            m_stateIndex = state;
            Value = new LexemeValue(content, span);

            m_trivia = s_emptyTrivia;
        }

 /// <summary>
 /// Called by <see cref="TryStatementBuilder"/>.
 /// Creates a try/catch/finally/else block.
 /// 
 /// The body is protected by the try block.
 /// The handlers consist of a set of language-dependent tests which call into the LanguageContext.
 /// The elseSuite runs if no exception is thrown.
 /// The finallySuite runs regardless of how control exits the body.
 /// </summary>
 internal TryStatement(SourceSpan span, SourceLocation header, Statement body, ReadOnlyCollection<CatchBlock> handlers, Statement @finally)
     : base(AstNodeType.TryStatement, span)
 {
     _body = body;
     _handlers = handlers;
     _finally = @finally;
     _header = header;
 }

 private SourceSpan Add(string message, SourceSpan span, Severity severity)
 {
     if (severity == Severity.Warning) {
         Warnings.Add(new ErrorResult(message, span));
     } else if (severity == Severity.FatalError || severity == Severity.Error) {
         Errors.Add(new ErrorResult(message, span));
     }
     return span;
 }

        public static CodeBlock Generator(SourceSpan span, string name, Type generator, Type next)
        {
            Contract.RequiresNotNull(name, "name");
            Contract.RequiresNotNull(generator, "generator");
            Contract.RequiresNotNull(next, "next");
            Contract.Requires(TypeUtils.CanAssign(typeof(Generator), generator), "generator", "The generator type must inherit from Generator");

            return new GeneratorCodeBlock(span, name, generator, next);
        }

 internal IfStatementTest(SourceSpan span, SourceLocation header, Expression /*!*/ test, Statement /*!*/ body)
     : base(AstNodeType.IfStatementTest)
 {
     _test = test;
     _body = body;
     _header = header;
     _start = span.Start;
     _end = span.End;
 }

 /// <summary>
 /// Initializes an instance of the ReportItem class.
 /// </summary>
 /// <param name="descriptor">A message descriptor.</param>
 /// <param name="sourceFile">A source file.</param>
 /// <param name="sourceSpan">A source span.</param>
 /// <param name="sourceLine">A source line.</param>
 /// <param name="args">Some arguments required by the message descriptor.</param>
 public ReportItem(MessageDescriptor descriptor, SourceFile sourceFile, SourceSpan sourceSpan,
                   TokenList sourceLine, params string[] args)
 {
     MessageDescriptor = descriptor;
     SourceFile = sourceFile;
     SourceSpan = sourceSpan;
     SourceLine = sourceLine;
     Arguments = args;
 }

 public static IfStatement IfThenElse(SourceSpan span, Expression test, Statement body, Statement @else)
 {
     return If(
         span,
         new IfStatementTest[] {
             Ast.IfCondition(SourceSpan.None, SourceLocation.None, test, body)
         },
         @else
     );
 }