public IfStatement(LexicalInfo token, Expression condition, Block trueBlock, Block falseBlock)
     : base(token)
 {
     this.Condition = condition;
     this.TrueBlock = trueBlock;
     this.FalseBlock = falseBlock;
 }

		public CompilerError(string code, LexicalInfo lexicalInfo, string message, Exception cause) : base(message, cause)
		{
			if (null == lexicalInfo)
				throw new ArgumentNullException("lexicalInfo");
			_code = code;
			_lexicalInfo = lexicalInfo;
		}

 protected MappedNode(CompileResults results, LexicalInfo lexicalInfo, int length)
     : this(results, null,
         results.LocationToPoint(lexicalInfo),
         results.LocationToPoint(lexicalInfo.Line, lexicalInfo.Column + length))
 {
     LexicalInfo = lexicalInfo;
 }

 public BinaryExpression(LexicalInfo lexicalInfoProvider, BinaryOperatorType operator_, Expression left, Expression right)
     : base(lexicalInfoProvider)
 {
     this.Operator = operator_;
     this.Left = left;
     this.Right = right;
 }

 public Slice(LexicalInfo lexicalInfo, Expression begin, Expression end, Expression step)
     : base(lexicalInfo)
 {
     this.Begin = begin;
     this.End = end;
     this.Step = step;
 }

 public CompilerMessage(LexicalInfo lexicalInfo, string code, string message, TaskErrorCategory errorCategory)
 {
     LexicalInfo = lexicalInfo;
     Code = code;
     Message = message;
     ErrorCategory = errorCategory;
 }

		public CompilerWarning(LexicalInfo lexicalInfo, string message, string code)
		{
			if (null == message) throw new ArgumentNullException("message");
			if (null == code) throw new ArgumentNullException("code");
			_lexicalInfo = lexicalInfo;
			_message = message;
			_code = code;
		}

 public static MethodInvocationExpression CreateMethodInvocationExpression(LexicalInfo li, Expression target, Expression arg)
 {
     MethodInvocationExpression mie = new MethodInvocationExpression(li);
     mie.Target = (Expression)target.Clone();
     mie.Arguments.Add((Expression)arg.Clone());
     mie.IsSynthetic = true;
     return mie;
 }

 void OnParserError(antlr.RecognitionException error)
 {
     var location = new LexicalInfo(error.getFilename(), error.getLine(), error.getColumn());
     var nvae = error as antlr.NoViableAltException;
     if (null != nvae)
         ParserError(location, nvae);
     else
         GenericParserError(location, error);
 }

        public CompilerWarning(LexicalInfo lexicalInfo, string message)
        {
            if (null == message)
            {
                throw new ArgumentNullException("message");
            }

            _code = "BCW0000";
            _lexicalInfo = lexicalInfo;
            _message = Boo.Lang.ResourceManager.Format(_code, message);
        }

 public MemberReferenceExpression CreateReference(LexicalInfo li, Field field)
 {
     MemberReferenceExpression e = CreateReference(field);
     e.LexicalInfo = li;
     return e;
 }

 public Expression CreateMethodReference(LexicalInfo lexicalInfo, IMethod method)
 {
     var e = CreateMethodReference(method);
     e.LexicalInfo = lexicalInfo;
     return e;
 }

 public MethodInvocationExpression CreateMethodInvocation(LexicalInfo li, Expression target, IMethod entity)
 {
     MethodInvocationExpression expression = CreateMethodInvocation(target, entity);
     expression.LexicalInfo = li;
     return expression;
 }

        public Method CreateMethodFromPrototype(LexicalInfo location, IMethod baseMethod, TypeMemberModifiers newModifiers, string newMethodName)
        {
            var method = new Method(location);
            method.Name = newMethodName;
            method.Modifiers = newModifiers;
            method.IsSynthetic = true;

            var optionalTypeMappings = DeclareGenericParametersFromPrototype(method, baseMethod);
            var typeReferenceFactory = optionalTypeMappings != null
                                       	? new MappedTypeReferenceFactory(TypeReferenceFactory, optionalTypeMappings)
                                       	: TypeReferenceFactory;
            _typeReferenceFactory.With(typeReferenceFactory, ()=>
            {
                DeclareParameters(method, baseMethod.GetParameters(), baseMethod.IsStatic ? 0 : 1);
                method.ReturnType = CreateTypeReference(baseMethod.ReturnType);
            });
            EnsureEntityFor(method);
            return method;
        }

 public RaiseStatement RaiseException(LexicalInfo lexicalInfo, IConstructor exceptionConstructor, params Expression[] args)
 {
     Debug.Assert(TypeSystemServices.IsValidException(exceptionConstructor.DeclaringType));
     return new RaiseStatement(lexicalInfo, CreateConstructorInvocation(lexicalInfo, exceptionConstructor, args));
 }

 public TypeReference CreateTypeReference(LexicalInfo li, Type type)
 {
     return CreateTypeReference(li, TypeSystemServices.Map(type));
 }

 public SelfLiteralExpression CreateSelfReference(LexicalInfo location, IType expressionType)
 {
     var reference = CreateSelfReference(expressionType);
     reference.LexicalInfo = location;
     return reference;
 }

 public Expression CreateInitValueType(LexicalInfo li, ReferenceExpression target)
 {
     var mie = CreateBuiltinInvocation(li, BuiltinFunction.InitValueType);
     mie.Arguments.Add(target);
     return mie;
 }

 public Statement CreateSwitch(LexicalInfo li, Expression offset, IEnumerable<LabelStatement> labels)
 {
     offset.LexicalInfo = li;
     return CreateSwitch(offset, labels);
 }

 public MemberReferenceExpression CreateMemberReference(LexicalInfo li, Expression target, IMember member)
 {
     MemberReferenceExpression expression = CreateMemberReference(target, member);
     expression.LexicalInfo = li;
     return expression;
 }