C# BlockStatement.Add方法代码示例

		Ast.BlockStatement TransformBlock(ILBlock block)
		{
			Ast.BlockStatement astBlock = new BlockStatement();
			if (block != null) {
				if (block.EntryGoto != null)
					astBlock.Add((Statement)TransformExpression(block.EntryGoto));
				foreach(ILNode node in block.Body) {
					astBlock.AddRange(TransformNode(node));
				}
			}
			return astBlock;
		}

		public override IEnumerable<CodeAction> GetActions (RefactoringContext context)
		{
			// lambda
			var lambda = context.GetNode<LambdaExpression> ();
			if (lambda != null && lambda.ArrowToken.Contains(context.Location)) {
				if (ContainsLocalReferences (context, lambda, lambda.Body))
					yield break;

				bool noReturn = false;
				BlockStatement body;
				if (lambda.Body is BlockStatement) {
					body = (BlockStatement)lambda.Body.Clone ();
				} else {
					if (!(lambda.Body is Expression))
						yield break;
					body = new BlockStatement ();

					var type = LambdaHelper.GetLambdaReturnType (context, lambda);
					if (type == null || type.ReflectionName == "System.Void") {
						noReturn = true;
						body.Add ((Expression)lambda.Body.Clone ());
					} else {
						body.Add (new ReturnStatement ((Expression)lambda.Body.Clone ()));
					}
				}
				var method = GetMethod (context, (LambdaResolveResult)context.Resolve (lambda), body, noReturn);
				yield return GetAction (context, lambda, method);
			}

			// anonymous method
			var anonymousMethod = context.GetNode<AnonymousMethodExpression> ();
			if (anonymousMethod != null && anonymousMethod.DelegateToken.Contains(context.Location)) {
				if (ContainsLocalReferences (context, anonymousMethod, anonymousMethod.Body))
					yield break;

				var method = GetMethod (context, (LambdaResolveResult)context.Resolve (anonymousMethod), 
										(BlockStatement)anonymousMethod.Body.Clone ());
				yield return GetAction (context, anonymousMethod, method);
			}
		}

			public override void Insert()
			{
				BlockStatement newBlock = new BlockStatement();
				// Move all statements except for the first
				Statement next;
				for (Statement stmt = firstStatement.GetNextStatement(); stmt != lastStatement; stmt = next) {
					next = stmt.GetNextStatement();
					newBlock.Add(stmt.Detach());
				}
				// Replace the first statement with the new (un)checked block
				if (isChecked)
					firstStatement.ReplaceWith(new CheckedStatement { Body = newBlock });
				else
					firstStatement.ReplaceWith(new UncheckedStatement { Body = newBlock });
				// now also move the first node into the new block
				newBlock.Statements.InsertAfter(null, firstStatement);
			}

        public BlockStatement BlockStatement(INode ParentNode=null, IStatement Parent=null)
        {
            var OldPreviousCommentString = PreviousComment;
            PreviousComment = new StringBuilder ();

            var bs = new BlockStatement() { Location=la.Location, ParentNode=ParentNode, Parent=Parent};

            if (Expect(OpenCurlyBrace))
            {
                if (ParseStructureOnly && laKind != CloseCurlyBrace)
                    Lexer.SkipCurrentBlock();
                else
                {
                    while (!IsEOF && laKind != (CloseCurlyBrace))
                    {
                        var prevLocation = la.Location;
                        var s = Statement(Scope: ParentNode as IBlockNode, Parent: bs);

                        // Avoid infinite loops -- hacky?
                        if (prevLocation == la.Location)
                        {
                            Step();
                            break;
                        }

                        bs.Add(s);
                    }
                }

                if (!Expect(CloseCurlyBrace) && IsEOF)
                {
                    bs.EndLocation = la.Location;
                    return bs;
                }
            }
            if(t!=null)
                bs.EndLocation = t.EndLocation;

            PreviousComment = OldPreviousCommentString;
            return bs;
        }

        AstNode TransformByteCode(ILExpression byteCode, List<Ast.Expression> args)
        {
            ILCode opCode = byteCode.Code;
            object operand = byteCode.Operand;
            AstType operandAsTypeRef = AstBuilder.ConvertType(operand as Cecil.TypeReference);
            ILExpression operandAsByteCode = operand as ILExpression;
            Ast.Expression arg1 = args.Count >= 1 ? args[0] : null;
            Ast.Expression arg2 = args.Count >= 2 ? args[1] : null;
            Ast.Expression arg3 = args.Count >= 3 ? args[2] : null;

            BlockStatement branchCommand = null;
            if (byteCode.Operand is ILLabel) {
                branchCommand = new BlockStatement();
                branchCommand.Add(new Ast.GotoStatement(((ILLabel)byteCode.Operand).Name));
            }

            switch((Code)opCode) {
                    #region Arithmetic
                    case Code.Add:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Add, arg2);
                    case Code.Add_Ovf:    return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Add, arg2);
                    case Code.Add_Ovf_Un: return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Add, arg2);
                    case Code.Div:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Divide, arg2);
                    case Code.Div_Un:     return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Divide, arg2);
                    case Code.Mul:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Multiply, arg2);
                    case Code.Mul_Ovf:    return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Multiply, arg2);
                    case Code.Mul_Ovf_Un: return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Multiply, arg2);
                    case Code.Rem:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Modulus, arg2);
                    case Code.Rem_Un:     return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Modulus, arg2);
                    case Code.Sub:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Subtract, arg2);
                    case Code.Sub_Ovf:    return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Subtract, arg2);
                    case Code.Sub_Ovf_Un: return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Subtract, arg2);
                    case Code.And:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.BitwiseAnd, arg2);
                    case Code.Or:         return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.BitwiseOr, arg2);
                    case Code.Xor:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.ExclusiveOr, arg2);
                    case Code.Shl:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.ShiftLeft, arg2);
                    case Code.Shr:        return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.ShiftRight, arg2);
                    case Code.Shr_Un:     return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.ShiftRight, arg2);

                    case Code.Neg:        return new Ast.UnaryOperatorExpression(UnaryOperatorType.Minus, arg1);
                    case Code.Not:        return new Ast.UnaryOperatorExpression(UnaryOperatorType.BitNot, arg1);
                    #endregion
                    #region Arrays
                case Code.Newarr:
                    {
                        var ace = new Ast.ArrayCreateExpression();
                        ace.Type = operandAsTypeRef;
                        ace.Arguments.Add(arg1);
                        return ace;
                    }
                case Code.Ldlen:
                    return arg1.Member("Length");
                case Code.Ldelem_I:
                case Code.Ldelem_I1:
                case Code.Ldelem_I2:
                case Code.Ldelem_I4:
                case Code.Ldelem_I8:
                case Code.Ldelem_U1:
                case Code.Ldelem_U2:
                case Code.Ldelem_U4:
                case Code.Ldelem_R4:
                case Code.Ldelem_R8:
                case Code.Ldelem_Ref:
                    return arg1.Indexer(arg2);
                case Code.Ldelem_Any:
                    return InlineAssembly(byteCode, args);
                case Code.Ldelema:
                    return MakeRef(arg1.Indexer(arg2));

                case Code.Stelem_I:
                case Code.Stelem_I1:
                case Code.Stelem_I2:
                case Code.Stelem_I4:
                case Code.Stelem_I8:
                case Code.Stelem_R4:
                case Code.Stelem_R8:
                case Code.Stelem_Ref:
                    return new Ast.AssignmentExpression(arg1.Indexer(arg2), arg3);
                case Code.Stelem_Any:
                    return InlineAssembly(byteCode, args);
                    #endregion
                    #region Branching
                    case Code.Br:      return new Ast.GotoStatement(((ILLabel)byteCode.Operand).Name);
                    case Code.Brfalse: return new Ast.IfElseStatement(new Ast.UnaryOperatorExpression(UnaryOperatorType.Not, arg1), branchCommand);
                    case Code.Brtrue:  return new Ast.IfElseStatement(arg1, branchCommand);
                    case Code.Beq:     return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Equality, arg2), branchCommand);
                    case Code.Bge:     return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.GreaterThanOrEqual, arg2), branchCommand);
                    case Code.Bge_Un:  return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.GreaterThanOrEqual, arg2), branchCommand);
                    case Code.Bgt:     return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.GreaterThan, arg2), branchCommand);
                    case Code.Bgt_Un:  return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.GreaterThan, arg2), branchCommand);
                    case Code.Ble:     return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.LessThanOrEqual, arg2), branchCommand);
                    case Code.Ble_Un:  return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.LessThanOrEqual, arg2), branchCommand);
                    case Code.Blt:     return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.LessThan, arg2), branchCommand);
                    case Code.Blt_Un:  return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.LessThan, arg2), branchCommand);
                    case Code.Bne_Un:  return new Ast.IfElseStatement(new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.InEquality, arg2), branchCommand);
                    #endregion
                    #region Comparison
                    case Code.Ceq:    return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.Equality, arg2);
                    case Code.Cgt:    return new Ast.BinaryOperatorExpression(arg1, BinaryOperatorType.GreaterThan, arg2);
                case Code.Cgt_Un:
                    // can also mean Inequality, when used with object references
//.........这里部分代码省略.........

        /// <summary>
        /// Builds and adds the needed nested types in a current type representing explicit interfaces
        /// </summary>
        /// <param name="currentType"></param>
        public static void GetExplicitInterfaceTypes(TypeDeclaration currentType)
        {
            //Trim the type name to avoid errors with generic types
            string currentTypeName = currentType.Name.TrimEnd("_Base".ToCharArray()).TrimEnd("_T".ToCharArray());

            //SEARCH FOR THE METHODS IN THE CURRENT TYPE THAT SHOULD BE IMPLEMENTED IN A NESTED CLASS
            List<MethodDeclaration> methodsOfCurrentType = new List<MethodDeclaration>();
            foreach (KeyValuePair<AstType, List<MethodDeclaration>> kvp in Cache.GetPrivateImplementation())
            {
                foreach (MethodDeclaration m in kvp.Value)
                {
                    if (m.TypeMember.Name == currentTypeName)
                        methodsOfCurrentType.Add(m);
                }
            }

            //CREATE A DICTIONARY WITH THE NESTEDCLASS AND METHODS NEEDED (SORTED)
            Dictionary<AstType, List<MethodDeclaration>> privateImplClass = new Dictionary<AstType, List<MethodDeclaration>>();
            foreach (MethodDeclaration m in methodsOfCurrentType)
            {
                foreach (KeyValuePair<AstType, List<MethodDeclaration>> kvp in Cache.GetPrivateImplementation())
                {
                    if (kvp.Value.Contains(m))
                    {
                        //If the method private implementation is corresponding to the current key type in the loop, continue
                        if (GetTypeName(m.PrivateImplementationType) == GetTypeName(kvp.Key))
                        {
                            //REMOVE THE METHOD FROM THE CURRENT TYPE                            
                            currentType.Members.Remove(m);
                            RemoveHeaderNode(m, currentType);

                            //REMOVE THE PRIVATE IMPLEMENTATION
                            m.PrivateImplementationType = Ast.AstType.Null;

                            //Add the method in the sorted dictionary
                            if (privateImplClass.ContainsKey(kvp.Key))
                                privateImplClass[kvp.Key].Add((MethodDeclaration)m.Clone());

                            else
                                privateImplClass.Add(kvp.Key, new List<MethodDeclaration>() { (MethodDeclaration)m.Clone() });

                        }
                    }
                }
            }

            //CREATE FROM THE NESTED CLASS THE NESTEDTYPEDECLARATION NODE
            foreach (KeyValuePair<AstType, List<MethodDeclaration>> kvp in privateImplClass)
            {
                TypeDeclaration type = new TypeDeclaration();
                string nestedTypeName = "_interface_" + GetTypeName(kvp.Key);
                type.NameToken = new Identifier(nestedTypeName, TextLocation.Empty);
                type.Name = nestedTypeName;
                type.ModifierTokens.Add(new CppModifierToken(TextLocation.Empty, Modifiers.Public));

                if (kvp.Key is SimpleType)
                {
                    foreach (AstType tp in (kvp.Key as SimpleType).TypeArguments)
                        type.TypeParameters.Add(new TypeParameterDeclaration() { NameToken = new Identifier(GetTypeName(tp), TextLocation.Empty) });
                }

                //ADD BASE TYPES
                SimpleType baseType = new SimpleType(GetTypeName(kvp.Key));
                if (kvp.Key is SimpleType)
                {
                    foreach (AstType tp in (kvp.Key as SimpleType).TypeArguments)
                        baseType.TypeArguments.Add((AstType)tp.Clone());
                }

                type.AddChild(baseType, TypeDeclaration.BaseTypeRole);

                //REMOVE THE BASE TYPE BECAUSE THE NESTED TYPE WILL INHERIT FROM IT
                try
                {
                    currentType.BaseTypes.Remove(currentType.BaseTypes.First(x => GetTypeName(x) == GetTypeName(baseType)));
                }
                catch (InvalidOperationException)
                {
                    //The element is not present in the list
                    //Safe to ignore this :)
                }

                //ADD METHODS
                type.Members.AddRange(kvp.Value);

                //ADD FIELD
                HeaderFieldDeclaration fdecl = new HeaderFieldDeclaration();
                SimpleType nestedType = new SimpleType(nestedTypeName);
                foreach (TypeParameterDeclaration tp in type.TypeParameters)
                    nestedType.TypeArguments.Add(new SimpleType(tp.Name));

                ExplicitInterfaceTypeDeclaration ntype = new Ast.ExplicitInterfaceTypeDeclaration(type);

                fdecl.ReturnType = nestedType;
                string _tmp = "_" + GetTypeName(fdecl.ReturnType).ToLower();
                fdecl.Variables.Add(new VariableInitializer(_tmp));
//.........这里部分代码省略.........

        public void VisitLambdaExpression(LambdaExpression node)
        {
            // Convert "() => 0" to "() => { return 0; }"
            if (node.Body.NodeType == NodeType.Expression) {
                var expression = (Expression)node.Body;
                var block = new BlockStatement();
                expression.ReplaceWith(block);
                block.Add(new ReturnStatement(expression));
            }

            VisitChildren(node);
        }

        public static IBlockNode UpdateBlockPartly(this BlockStatement bs, string code, int caretOffset, CodeLocation caretLocation, out bool isInsideNonCodeSegment)
        {
            isInsideNonCodeSegment = false;
            var finalParentMethod = bs.ParentNode as DMethod;
            var finalStmtsList = bs._Statements;

            var startLoc = bs.Location;
            int startStmtIndex;
            for(startStmtIndex = finalStmtsList.Count-1; startStmtIndex >= 0; startStmtIndex--) {
                var n = finalStmtsList [startStmtIndex];
                if (n.EndLocation.Line > 0 && n.EndLocation.Line < caretLocation.Line) {
                    startLoc = --startStmtIndex == -1 ?
                        bs.Location : finalStmtsList [startStmtIndex].EndLocation;
                    break;
                }
            }

            var startOff = startLoc.Line > 1 ? DocumentHelper.GetOffsetByRelativeLocation (code, caretLocation, caretOffset, startLoc) : 0;

            if (startOff >= caretOffset)
                return null;

            var tempParentBlock = new DMethod();//new DBlockNode();
            var tempBlockStmt = new BlockStatement { ParentNode = tempParentBlock };
            tempParentBlock.Body = tempBlockStmt;
            tempBlockStmt.Location = startLoc;
            tempParentBlock.Location = startLoc;

            using (var sv = new StringView (code, startOff, caretOffset - startOff))
            using (var p = DParser.Create(sv)) {
                p.Lexer.SetInitialLocation (startLoc);
                p.Step ();

                if(p.laKind == DTokens.OpenCurlyBrace)
                    p.Step();

                while (!p.IsEOF) {

                    if (p.laKind == DTokens.CloseCurlyBrace) {
                        p.Step ();
                        /*if (metaDecls.Count > 0)
                            metaDecls.RemoveAt (metaDecls.Count - 1);*/
                        continue;
                    }

                    var stmt = p.Statement (true, false, tempParentBlock, tempBlockStmt);
                    if (stmt != null)
                        tempBlockStmt.Add(stmt);
                    else
                        p.Step();
                }

                tempBlockStmt.EndLocation = new CodeLocation(p.la.Column+1,p.la.Line);
                tempParentBlock.EndLocation = tempBlockStmt.EndLocation;

                if(isInsideNonCodeSegment = p.Lexer.endedWhileBeingInNonCodeSequence)
                    return null;
            }

            DoubleDeclarationSilencer.RemoveDoubles(finalParentMethod, tempParentBlock);

            tempParentBlock.Parent = finalParentMethod;
            //tempParentBlock.Add(new PseudoStaticStmt { Block = tempBlockStmt, ParentNode = tempParentBlock, Location = tempBlockStmt.Location, EndLocation = tempBlockStmt.EndLocation });

            return tempParentBlock;
        }

        public BlockStatement BlockStatement(INode ParentNode=null, IStatement Parent=null)
        {
            var OldPreviousCommentString = PreviousComment;
            PreviousComment = "";

            var bs = new BlockStatement() { StartLocation=la.Location, ParentNode=ParentNode, Parent=Parent};
            LastParsedObject = bs;

            if (Expect(OpenCurlyBrace))
            {
                if (ParseStructureOnly && laKind != CloseCurlyBrace)
                {
                    Lexer.SkipCurrentBlock();
                    laKind = la.Kind;
                }
                else
                    while (!IsEOF && laKind != (CloseCurlyBrace))
                    {
                        var s = Statement(Scope: ParentNode as IBlockNode);
                        bs.Add(s);
                    }
                if (Expect(CloseCurlyBrace))
                    LastParsedObject = null;

                if (!IsEOF)
                    LastParsedObject = bs;
            }
            if(t!=null)
                bs.EndLocation = t.EndLocation;

            PreviousComment = OldPreviousCommentString;
            return bs;
        }

        public static void UpdateBlockPartly(this BlockStatement bs, string code, int caretOffset, CodeLocation caretLocation, out bool isInsideNonCodeSegment)
        {
            isInsideNonCodeSegment = false;
            var finalParentMethod = bs.ParentNode as DMethod;
            var finalStmtsList = bs._Statements;

            var startLoc = bs.Location;
            int startStmtIndex;
            for(startStmtIndex = finalStmtsList.Count-1; startStmtIndex >= 0; startStmtIndex--) {
                var n = finalStmtsList [startStmtIndex];
                if (n.EndLocation.Line > 0 && n.EndLocation.Line < caretLocation.Line) {
                    startLoc = --startStmtIndex == -1 ?
                        bs.Location : finalStmtsList [startStmtIndex].EndLocation;
                    break;
                }
            }

            var startOff = startLoc.Line > 1 ? DocumentHelper.GetOffsetByRelativeLocation (code, caretLocation, caretOffset, startLoc) : 0;

            if (startOff >= caretOffset)
                return;

            var tempParentBlock = new DMethod ();
            var tempBlockStmt = new BlockStatement { ParentNode = tempParentBlock };

            try{
                using (var sv = new StringView (code, startOff, caretOffset - startOff))
                using (var p = DParser.Create(sv)) {
                    p.Lexer.SetInitialLocation (startLoc);
                    p.Step ();

                    if(p.laKind == DTokens.OpenCurlyBrace)
                        p.Step();

                    while (!p.IsEOF) {

                        if (p.laKind == DTokens.CloseCurlyBrace) {
                            p.Step ();
                            /*if (metaDecls.Count > 0)
                                metaDecls.RemoveAt (metaDecls.Count - 1);*/
                            continue;
                        }

                        var stmt = p.Statement (true, true, tempParentBlock, tempBlockStmt);
                        if(stmt != null)
                            tempBlockStmt.Add(stmt);
                    }

                    tempBlockStmt.EndLocation = new CodeLocation(p.la.Column+1,p.la.Line);

                    if(isInsideNonCodeSegment = p.Lexer.endedWhileBeingInNonCodeSequence)
                        return;
                }
            }catch(Exception ex) {
                Console.WriteLine (ex.Message);
            }

            // Remove old statements from startLoc until caretLocation
            int i = startStmtIndex + 1;
            while (i < finalStmtsList.Count && finalStmtsList [i].Location < caretLocation)
                finalStmtsList.RemoveAt (i);

            // Insert new statements
            if (tempBlockStmt.EndLocation > bs.EndLocation)
                bs.EndLocation = tempBlockStmt.EndLocation;
            foreach (var stmt in tempBlockStmt._Statements)
            {
                stmt.ParentNode = finalParentMethod;
                stmt.Parent = bs;
            }
            AssignInStatementDeclarationsToNewParentNode(tempBlockStmt, finalParentMethod);
            finalStmtsList.InsertRange(startStmtIndex+1, tempBlockStmt._Statements);

            if (finalParentMethod != null) {
                var finalParentChildren = finalParentMethod.AdditionalChildren;
                // Remove old parent block children
                int startDeclIndex;
                for(startDeclIndex = finalParentChildren.Count-1; startDeclIndex >= 0; startDeclIndex--) {
                    var n = finalParentChildren [startDeclIndex];
                    if (n == null) {
                        finalParentChildren.RemoveAt (startDeclIndex);
                        continue;
                    }
                    if (n.Location < startLoc)
                        break;
                    if (n.Location < caretLocation)
                        finalParentChildren.RemoveAt(startDeclIndex);
                }

                // Insert new special declarations
                foreach (var decl in tempParentBlock)
                    decl.Parent = finalParentMethod;
                finalParentChildren.InsertRange(startDeclIndex+1, tempParentBlock);

                finalParentMethod.UpdateChildrenArray ();
                if (bs.EndLocation > finalParentMethod.EndLocation)
                    finalParentMethod.EndLocation = bs.EndLocation;
            }

            //TODO: Handle DBlockNode parents?
//.........这里部分代码省略.........

			public override void VisitInvocationExpression (InvocationExpression invocationExpression)
			{
				base.VisitInvocationExpression (invocationExpression);

				var hasRefs = invocationExpression.Arguments.OfType<DirectionExpression> ().Any ();

				if (hasRefs) {

					var args = invocationExpression.Arguments.OfType<DirectionExpression> ().ToList ();

					var target = invocationExpression.Target;

					var lblock = new BlockStatement {

					};

					for (int i = 0; i < args.Count; i++) {
						var a = args [i];
						var vname = "_p" + i;
						var va = new VariableDeclarationStatement (AstType.Null, vname, new ArrayCreateExpression {
							Initializer = new ArrayInitializerExpression (a.Expression.Clone ())
						});
						a.ReplaceWith (new IdentifierExpression (vname));
						lblock.Add (va);
					}
					var rname = "_r";
					var ra = new VariableDeclarationStatement (AstType.Null, rname, invocationExpression.Clone ());
					lblock.Add (ra);
					for (int i = 0; i < args.Count; i++) {
						var a = args [i];
						var vname = "_p" + i;
						var va = new AssignmentExpression (a.Expression.Clone (), 
							new IndexerExpression (
								new IdentifierExpression (vname), new PrimitiveExpression (0)));
						lblock.Add (va);
					}
					lblock.Add (new ReturnStatement (new IdentifierExpression (rname)));

					var lambda = new LambdaExpression {
						Body = lblock,
					};

					var ilambda = new InvocationExpression (lambda);

					invocationExpression.ReplaceWith (ilambda);
				}
			}

			public override void VisitMethodDeclaration (MethodDeclaration methodDeclaration)
			{
				base.VisitMethodDeclaration (methodDeclaration);

				if (methodDeclaration.Body.IsNull && methodDeclaration.GetParent<TypeDeclaration> ().ClassType != ClassType.Interface ) {
					var block = new BlockStatement ();
					block.Add (new ThrowStatement (new ObjectCreateExpression (new SimpleType ("NotSupportedException"))));
					methodDeclaration.Body = block;

				}
			}

			public override void VisitTryCatchStatement (TryCatchStatement tryCatchStatement)
			{
				base.VisitTryCatchStatement (tryCatchStatement);

				var catches = tryCatchStatement.CatchClauses.ToList ();
				if (catches.Count == 0)
					return;

				var varName = catches.Where (x => !string.IsNullOrEmpty (x.VariableName)).Select (x => x.VariableName).FirstOrDefault ();
				if (varName == null) {
					varName = "_ex";
				}

				//
				// Fix first
				//
				foreach (var c in catches) {
					if (string.IsNullOrEmpty (c.VariableName)) {
						c.VariableName = varName;
					}
				}

				//
				// Merge them
				//
				if (catches.Count > 0) {
					var body = new BlockStatement ();
					var newCatch = new CatchClause {
						VariableName = varName,
						Body = body,
					};

					IfElseStatement lastIf = null;

					foreach (var c in catches) {

						var cbody = c.Body;
						cbody.Remove ();

						var iff = new IfElseStatement (GetNotNullTypeCheck (varName, c.Type), cbody);

						if (lastIf == null)
							body.Add (iff);
						else
							lastIf.FalseStatement = iff;

						lastIf = iff;

						c.Remove ();
					}

					var rethrow = new ThrowStatement (new IdentifierExpression (varName));

					if (lastIf == null)
						body.Add (rethrow);
					else
						lastIf.FalseStatement = rethrow;

					tryCatchStatement.CatchClauses.Add (newCatch);
				}
			}

        private string Generate(String fieldName, String propertyTypeName, string indent)
        {
            String lowerName = fieldName.Substring(0, 1).ToLowerInvariant() + fieldName.Substring(1);
            String upperName = fieldName.Substring(0, 1).ToUpperInvariant() + fieldName.Substring(1);

            String getterName = lowerName;
            String setterName = "set" + upperName + ":";

            // Create the field declaration
            //FieldDeclaration fieldDeclaration = GetFieldDeclaration(lowerName, new SimpleType (propertyTypeName));
            String fieldDeclaration = String.Format("private {0} {1};", propertyTypeName, lowerName);

            // Create the property declaration
            PropertyDeclaration propertyDeclaration = GetPropertyDeclaration(upperName, new SimpleType (propertyTypeName));

            {
                // Create the attribute
                AttributeSection attributeSection = new AttributeSection ();
                var attribute = GetAttribute(Constants.OBJECTIVE_C_MESSAGE_SHORTFORM, getterName);
                attributeSection.Attributes.Add (attribute);

                // Create the member reference
                MemberReferenceExpression memberReferenceExpression = new MemberReferenceExpression(new ThisReferenceExpression (), lowerName);
                ReturnStatement returnStatement = new ReturnStatement (memberReferenceExpression);

                // Create the "get" region
                propertyDeclaration.Getter = new Accessor();
                propertyDeclaration.Getter.Attributes.Add(attributeSection);
                propertyDeclaration.Getter.Body = new BlockStatement ();
                propertyDeclaration.Getter.Body.Add(returnStatement);
            }

            {
                // Create the attribute
                AttributeSection attributeSection = new AttributeSection ();
                var attribute = GetAttribute(Constants.OBJECTIVE_C_MESSAGE_SHORTFORM, setterName);
                attributeSection.Attributes.Add (attribute);

                BlockStatement blockStatement = new BlockStatement();
                // Create a simple assignment
                MemberReferenceExpression memberReferenceExpression2 = new MemberReferenceExpression(new ThisReferenceExpression (), lowerName);
                AssignmentExpression assignmentExpression = new AssignmentExpression(memberReferenceExpression2, new IdentifierExpression ("value"));
                blockStatement.Add(assignmentExpression);

                // Create the "set" region
                propertyDeclaration.Setter = new Accessor();
                propertyDeclaration.Setter.Attributes.Add(attributeSection);
                propertyDeclaration.Setter.Body = blockStatement;
            }

            // Return the result of the AST generation
            StringBuilder builder = new StringBuilder();
            builder.AppendLine(fieldDeclaration);
            builder.AppendLine();
            builder.AppendLine(this.Options.OutputNode(propertyDeclaration));
            String generated = builder.ToString();

            // Add ident space
            return Indent(generated, indent);
        }

		protected override string GenerateCode(ITypeDefinition currentClass)
		{
			MethodDeclaration insertedOverrideMethod = refactoringContext.GetNode().PrevSibling as MethodDeclaration;
			if (insertedOverrideMethod == null)
			{
				// We are not inside of a method declaration
				return null;
			}
			
			using (Script script = refactoringContext.StartScript()) {
				NewLineNode nextNewLineNode = insertedOverrideMethod.NextSibling as NewLineNode;
				
//			if (Options.AddIEquatableInterface) {
				// TODO : add IEquatable<T> to class
//				IAmbience ambience = currentClass.CompilationUnit.Language.GetAmbience();
//
//				IReturnType baseRType = currentClass.CompilationUnit.ProjectContent.GetClass("System.IEquatable", 1).DefaultReturnType;
//
//				IClass newClass = new DefaultClass(currentClass.CompilationUnit, currentClass.FullyQualifiedName, currentClass.Modifiers, currentClass.Region, null);
//
//				foreach (IReturnType type in currentClass.BaseTypes) {
//					newClass.BaseTypes.Add(type);
//				}
//
//
//				newClass.BaseTypes.Add(new ConstructedReturnType(baseRType, new List<IReturnType>() { currentClass.DefaultReturnType }));
//
//				ambience.ConversionFlags = ConversionFlags.IncludeBody;
//
//				string a = ambience.Convert(currentClass);
//
//				int startOffset = editor.Document.PositionToOffset(currentClass.Region.BeginLine, currentClass.Region.BeginColumn);
//				int endOffset = editor.Document.PositionToOffset(currentClass.BodyRegion.EndLine, currentClass.BodyRegion.EndColumn);
//
//				editor.Document.Replace(startOffset, endOffset - startOffset, a);
//			}
				
				if (Options.SurroundWithRegion) {
					script.InsertBefore(insertedOverrideMethod, new PreProcessorDirective(PreProcessorDirectiveType.Region, "Equals and GetHashCode implementation"));
				}
				
				if ("Equals".Equals(selectedMethod.Name, StringComparison.Ordinal)) {
					IList<MethodDeclaration> equalsOverrides = CreateEqualsOverrides(currentClass);
					MethodDeclaration defaultOverride = equalsOverrides.First();
					equalsOverrides = equalsOverrides.Skip(1).ToList();
					
					// Insert children of default Equals method into
					foreach (AstNode element in defaultOverride.Body.Children) {
						script.AddTo(insertedOverrideMethod.Body, element.Clone());
					}
					
					// Add other Equals() overrides after our main inserted method
					if (addOtherMethod.IsChecked == true) {
						if (equalsOverrides.Any()) {
							foreach (var equalsMethod in equalsOverrides) {
								AppendNewLine(script, insertedOverrideMethod, nextNewLineNode);
								script.InsertAfter(insertedOverrideMethod, equalsMethod);
							}
						}
						
						AppendNewLine(script, insertedOverrideMethod, nextNewLineNode);
						script.InsertAfter(insertedOverrideMethod, CreateGetHashCodeOverride(currentClass));
					}
				} else {
					StringBuilder builder = new StringBuilder();
					
					foreach (AstNode element in CreateGetHashCodeOverride(currentClass).Body.Children) {
						script.AddTo(insertedOverrideMethod.Body, element.Clone());
					}
					
					if (addOtherMethod.IsChecked == true) {
						foreach (var equalsMethod in CreateEqualsOverrides(currentClass)) {
							AppendNewLine(script, insertedOverrideMethod, nextNewLineNode);
							script.InsertAfter(insertedOverrideMethod, equalsMethod);
						}
					}
				}
				
				if (Options.AddOperatorOverloads) {
					var checkStatements = new[] {
						new IfElseStatement(
							new InvocationExpression(
								new IdentifierExpression("ReferenceEquals"),
								new List<Expression>() { new IdentifierExpression("lhs"), new IdentifierExpression("rhs") }
							),
							new ReturnStatement(new PrimitiveExpression(true))
						),
						new IfElseStatement(
							new BinaryOperatorExpression(
								new InvocationExpression(
									new IdentifierExpression("ReferenceEquals"),
									new List<Expression>() { new IdentifierExpression("lhs"), new PrimitiveExpression(null) }
								),
								BinaryOperatorType.ConditionalOr,
								new InvocationExpression(
									new IdentifierExpression("ReferenceEquals"),
									new List<Expression>() { new IdentifierExpression("rhs"), new PrimitiveExpression(null) }
								)
							),
							new ReturnStatement(new PrimitiveExpression(false))
//.........这里部分代码省略.........