Method CreateGetter(Field f)
		{
			Method m = new Method();
			m.Name = "get";

			// value = ViewState["<f.Name>"]
			m.Body.Statements.Add(
				new ExpressionStatement(
					new BinaryExpression(
						BinaryOperatorType.Assign,
						new ReferenceExpression("value"),
						CreateViewStateSlice(f)
						)
					)
				);

			if (null != _default)
			{
				// return <_default> unless value
				ReturnStatement rs = new ReturnStatement(_default);
				rs.Modifier = new StatementModifier(StatementModifierType.Unless, new ReferenceExpression("value"));
				m.Body.Statements.Add(rs);
			}

			// return value
			m.Body.Statements.Add(
				new ReturnStatement(
					new ReferenceExpression("value")
					)
				);

			return m;
		}

		public override void LeaveReturnStatement(ReturnStatement node)
		{
			if (node.Expression == null)
				return;

			TryToReify(node.Expression, _currentMethod.ReturnType);
		}

			public override void OnReturnStatement(ReturnStatement node)
			{
				noReturnStatement = false;
				if (node.Expression == null) {
					result = ParserService.CurrentProjectContent.SystemTypes.Void;
				} else {
					result = new BooResolver().GetTypeOfExpression(node.Expression, context);
				}
			}

        public void ForCoverage()
        {
            var block = new Block();
            var statement = new ReturnStatement(new StringLiteralExpression("literal"));
            block.Statements.Add(statement);

            var visitor = new ReturnValueVisitor();
            bool found = visitor.Found;
            visitor.OnReturnStatement(statement);
        }

 public void CheckForEmptyCoroutine(Method node)
 {
     if (this.IsEmptyCoroutine(node))
     {
         ReturnStatement statement;
         ReturnStatement statement1 = statement = new ReturnStatement(LexicalInfo.Empty);
         statement.set_Expression(Expression.Lift(this.EmptyEnumeratorReference));
         node.get_Body().Add(statement);
     }
 }

		override public void LeaveReturnStatement(ReturnStatement node)
		{
			Expression expression = node.Expression;
			if (null == expression)
				return;

			if (!HasReturnType(_current))
				return;

			Expression newExpression = Convert(_current.ReturnType, expression);
			if (null == newExpression)
				return;

			node.Expression = newExpression;
		}

		public override void OnReturnStatement(ReturnStatement stmt)
		{
			// First normalize the statement
			normalizer.Visit(stmt);
			//empty return, so error
			if (stmt.Expression == null)
				throw new MonoRailException("An empty return statement on a method with output attribute");
			found = true;
			Block block = (Block) stmt.ParentNode;
			int index = 0;
			while(block.Statements[index] != stmt)
			{
				index ++;
			}

			MethodInvocationExpression invocation = mie.CloneNode();
			invocation.Arguments.Add(stmt.Expression);

			stmt.Expression = invocation;
		}

	protected ReturnStatement  return_expression_stmt() //throws RecognitionException, TokenStreamException
{
		ReturnStatement s;
		
		IToken  r = null;
		
				s = null;
				Expression e = null;
				StatementModifier modifier = null;
			
		
		try {      // for error handling
			r = LT(1);
			match(RETURN);
			{
				switch ( LA(1) )
				{
				case ESEPARATOR:
				case CAST:
				case CHAR:
				case FALSE:
				case NOT:
				case NULL:
				case SELF:
				case SUPER:
				case THEN:
				case TRUE:
				case TYPEOF:
				case TRIPLE_QUOTED_STRING:
				case LPAREN:
				case DOUBLE_QUOTED_STRING:
				case SINGLE_QUOTED_STRING:
				case ID:
				case MULTIPLY:
				case LBRACK:
				case COMMA:
				case SPLICE_BEGIN:
				case DOT:
				case LBRACE:
				case QQ_BEGIN:
				case SUBTRACT:
				case LONG:
				case INCREMENT:
				case DECREMENT:
				case ONES_COMPLEMENT:
				case INT:
				case BACKTICK_QUOTED_STRING:
				case RE_LITERAL:
				case DOUBLE:
				case FLOAT:
				case TIMESPAN:
				{
					e=array_or_expression();
					break;
				}
				case EOL:
				case IF:
				case UNLESS:
				case WHILE:
				case EOS:
				case RBRACE:
				case QQ_END:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			{
				if (((LA(1)==IF||LA(1)==UNLESS||LA(1)==WHILE))&&(!_compact))
				{
					modifier=stmt_modifier();
				}
				else if ((tokenSet_98_.member(LA(1)))) {
				}
				else
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				
			}
			if (0==inputState.guessing)
			{
				
						s = new ReturnStatement(ToLexicalInfo(r));
						s.Modifier = modifier;
						s.Expression = e;
					
			}
		}
		catch (RecognitionException ex)
		{
			if (0 == inputState.guessing)
			{
				reportError(ex, "return_expression_stmt");
				recover(ex,tokenSet_98_);
			}
//.........这里部分代码省略.........

        private static void AddOptionalReturnStatement(Block body)
        {
            if (body.Statements.Count != 1) return;
            var stmt = body.FirstStatement as ExpressionStatement;
            if (null == stmt) return;

            var rs = new ReturnStatement(stmt.LexicalInfo, stmt.Expression, null);
            rs.Annotate(OptionalReturnStatementAnnotation);
            body.Replace(stmt, rs);
        }

        //throws RecognitionException, TokenStreamException
        protected ReturnStatement return_stmt()
        {
            ReturnStatement s;

            IToken  r = null;

                s = null;
                Expression e = null;
                StatementModifier modifier = null;

            try {      // for error handling
            r = LT(1);
            match(RETURN);
            {
                switch ( LA(1) )
                {
                case ESEPARATOR:
                case CAST:
                case CHAR:
                case FALSE:
                case NOT:
                case NULL:
                case SELF:
                case SUPER:
                case TRUE:
                case TYPEOF:
                case ID:
                case TRIPLE_QUOTED_STRING:
                case LPAREN:
                case DOUBLE_QUOTED_STRING:
                case SINGLE_QUOTED_STRING:
                case LBRACK:
                case SUBTRACT:
                case COMMA:
                case SPLICE_BEGIN:
                case DOT:
                case MULTIPLY:
                case LBRACE:
                case QQ_BEGIN:
                case LONG:
                case INCREMENT:
                case DECREMENT:
                case ONES_COMPLEMENT:
                case INT:
                case RE_LITERAL:
                case DOUBLE:
                case FLOAT:
                case TIMESPAN:
                {
                    {
                        e=array_or_expression();
                        {
                            switch ( LA(1) )
                            {
                            case DEF:
                            case DO:
                            case COLON:
                            {
                                e=method_invocation_block(e);
                                break;
                            }
                            case EOF:
                            case IF:
                            case UNLESS:
                            case WHILE:
                            case EOS:
                            case NEWLINE:
                            {
                                {
                                    {
                                        switch ( LA(1) )
                                        {
                                        case IF:
                                        case UNLESS:
                                        case WHILE:
                                        {
                                            modifier=stmt_modifier();
                                            break;
                                        }
                                        case EOF:
                                        case EOS:
                                        case NEWLINE:
                                        {
                                            break;
                                        }
                                        default:
                                        {
                                            throw new NoViableAltException(LT(1), getFilename());
                                        }
                                         }
                                    }
                                    eos();
                                }
                                break;
                            }
                            default:
                            {
                                throw new NoViableAltException(LT(1), getFilename());
                            }
//.........这里部分代码省略.........

        public override void OnReturnStatement(ReturnStatement node)
        {
            EmitDebugInfo(node);
            OpCode retOpCode = _tryBlock > 0 ? OpCodes.Leave : OpCodes.Br;
            Label label = _returnLabel;

            if (null != node.Expression)
            {
                ++_returnStatements;

                Visit(node.Expression);
                EmitCastIfNeeded(_returnType, PopType());

                if (retOpCode == OpCodes.Leave)
                {
                    //`leave' clears the stack, so we have to store return value temporarily
                    //we can use a default value holder for that since it won't be read afterwards
                    //of course this is necessary only if return type is not void
                    LocalBuilder temp = GetDefaultValueHolder(_returnType);
                    _il.Emit(OpCodes.Stloc, temp);
                    label = _leaveLabel;
                    _hasLeaveWithStoredValue = true;
                }
            }
            else if (_returnType != TypeSystemServices.VoidType)
            {
                _returnImplicit = true;
                label = _implicitLabel;
            }

            if (_method.Body.LastStatement != node)
                _il.Emit(retOpCode, label);
            else if (null != node.Expression)
                _returnStatements = -1; //instruct epilogue to branch last ret only if necessary
        }

 public override void OnReturnStatement(ReturnStatement r)
 {
     WriteIndented();
     WriteKeyword("return ");
     Visit(r.Expression);
     Visit(r.Modifier);
     WriteLine();
 }

 public override void LeaveReturnStatement(ReturnStatement node)
 {
     if (HasReturnType(_current))
     {
         Expression expression = node.Expression;
         if (null != expression)
         {
             Expression newExpression = Convert(_current.ReturnType, expression);
             if (null != newExpression)
             {
                 node.Expression = newExpression;
             }
         }
     }
 }

		public override void OnReturnStatement(ReturnStatement node)
		{
			_expression = null;
			if (node.Expression != null)
				node.Expression.Accept(this);
			_statements.Add(new CodeMethodReturnStatement(_expression));
		}

		override public object Clone()
		{
		
			ReturnStatement clone = new ReturnStatement();
			clone._lexicalInfo = _lexicalInfo;
			clone._endSourceLocation = _endSourceLocation;
			clone._documentation = _documentation;
			clone._isSynthetic = _isSynthetic;
			clone._entity = _entity;
			if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
			if (null != _modifier)
			{
				clone._modifier = _modifier.Clone() as StatementModifier;
				clone._modifier.InitializeParent(clone);
			}
			if (null != _expression)
			{
				clone._expression = _expression.Clone() as Expression;
				clone._expression.InitializeParent(clone);
			}
			return clone;


		}

 public void return_statement(Block b)
 {
     IToken token = null;
     try
     {
         Expression expression;
         token = this.LT(1);
         this.match(30);
         if (tokenSet_16_.member(this.LA(1)) && tokenSet_49_.member(this.LA(2)))
         {
             expression = this.expression();
         }
         else if (!tokenSet_15_.member(this.LA(1)) || !tokenSet_20_.member(this.LA(2)))
         {
             throw new NoViableAltException(this.LT(1), this.getFilename());
         }
         if (base.inputState.guessing == 0)
         {
             ReturnStatement statement;
             ReturnStatement statement1 = statement = new ReturnStatement(ToLexicalInfo(token));
             statement.set_Expression(expression);
             b.Add(statement);
         }
     }
     catch (RecognitionException exception)
     {
         if (base.inputState.guessing != 0)
         {
             throw;
         }
         this.reportError(exception);
         this.recover(exception, tokenSet_15_);
     }
 }

		override public void OnReturnStatement(ReturnStatement node)
		{
			RemoveUnreachableCode(node);
		}

        public override void LeaveReturnStatement(ReturnStatement node)
        {
            if (null == node.Expression)
                return;

            // forces anonymous types to be correctly
            // instantiated
            IType expressionType = GetConcreteExpressionType(node.Expression);
            if (TypeSystemServices.VoidType == expressionType
                && node.ContainsAnnotation(OptionalReturnStatementAnnotation))
            {
                node.ParentNode.Replace(
                    node,
                    new ExpressionStatement(node.Expression));
                return;
            }

            IType returnType = _currentMethod.ReturnType;
            if (TypeSystemServices.IsUnknown(returnType))
                _currentMethod.AddReturnExpression(node.Expression);
            else
                AssertTypeCompatibility(node.Expression, returnType, expressionType);

            //bind to nullable Value if needed
            if (TypeSystemServices.IsNullable(expressionType) && !TypeSystemServices.IsNullable(returnType))
            {
                // TODO: move to later steps or introduce an implicit conversion operator
                var mre = new MemberReferenceExpression(node.Expression.LexicalInfo, node.Expression, "Value");
                Visit(mre);
                node.Replace(node.Expression, mre);
            }
        }

        public override void LeaveReturnStatement(ReturnStatement node)
        {
            if (null == node.Expression) return;

            // forces anonymous types to be correctly
            // instantiated
            IType expressionType = GetConcreteExpressionType(node.Expression);
            if (TypeSystemServices.VoidType == expressionType
                && node.ContainsAnnotation(OptionalReturnStatementAnnotation))
            {
                node.ParentNode.Replace(
                    node,
                    new ExpressionStatement(node.Expression));
                return;
            }

            IType returnType = _currentMethod.ReturnType;
            if (TypeSystemServices.IsUnknown(returnType))
            {
                _currentMethod.AddReturnExpression(node.Expression);
            }
            else
            {
                AssertTypeCompatibility(node.Expression, returnType, expressionType);
            }
        }

 public override void LeaveReturnStatement(ReturnStatement node)
 {
     if (InsideEnsure)
     {
         Error(CompilerErrorFactory.CantReturnFromEnsure(node));
     }
     if (null == node.Expression) return;
     CheckExpressionType(node.Expression);
 }