C# MethodDeclaration.AcceptVisitor方法代码示例

        public IEnumerable<MethodDeclaration> FindCandidatesViaRefactoringPermutations(TargetInfo left, MethodDeclaration right)
        {
            right = right.DeepCopy();
            /*
             * Steps to change one to match the other.
             *      Get the lookup table for left.
             *      Get the lookup table for right.
             *      Loop through left, renaming the corresponding right var as you go (don't worry about collisions yet).
             * Compare.
             *
             * This is essentially a normalization of one to the other.
             */
            Dictionary<string, List<LocalLookupVariable>> left_table = left.GetLookupTableWithParams();
            Dictionary<string, List<LocalLookupVariable>> right_table = right.GetLookupTableWithParams();

            if (left_table.Keys.Count == right_table.Keys.Count)
            {
                IDictionary<string, string> renames = new Dictionary<string, string>();

                for (int i = 0; i < left_table.Count; i++)
                {
                    var left_var_name = left_table.Keys.ToArray()[i];
                    var right_var_name = right_table.Keys.ToArray()[i];

                    // current name => new name
                    renames.Add(right_var_name, left_var_name);
                }

                RenameLocalVariableRefactoring r = new RenameLocalVariableRefactoring(renames);
                right.AcceptVisitor(r, null);

                yield return right;
            }
        }

		public ExtractMethodForm(MethodDeclaration declaration, Func<IOutputAstVisitor> generator)
		{
			//
			// The InitializeComponent() call is required for Windows Forms designer support.
			//
			InitializeComponent();
			
			SetTranslation(this);
			
			this.declaration = declaration;
			this.generator = generator;
			IOutputAstVisitor visitor = this.generator.Invoke();
			body = declaration.Body;
			declaration.Body = new BlockStatement();
			
			declaration.AcceptVisitor(visitor, null);
			
			this.txtName.Text = this.declaration.Name;
			this.txtPreview.Text = visitor.Text;
			
			this.txtName.SelectAll();
		}

		protected void CreateReturnStatement(MethodDeclaration newMethod, List<VariableDeclaration> possibleReturnValues)
		{
			HasReturnStatementVisitor hrsv = new HasReturnStatementVisitor();

			newMethod.AcceptVisitor(hrsv, null);

			if (hrsv.HasReturn) {
				if (this.parentNode is MethodDeclaration)
					newMethod.TypeReference = (this.parentNode as MethodDeclaration).TypeReference;
				if (this.parentNode is PropertyDeclaration)
					newMethod.TypeReference = (this.parentNode as PropertyDeclaration).TypeReference;
				if (this.parentNode is OperatorDeclaration)
					newMethod.TypeReference = (this.parentNode as OperatorDeclaration).TypeReference;
			} else {
				if (possibleReturnValues.Count > 0) {
					newMethod.TypeReference = possibleReturnValues[possibleReturnValues.Count - 1].TypeReference;
					newMethod.Body.Children.Add(new ReturnStatement(new IdentifierExpression(possibleReturnValues[possibleReturnValues.Count - 1].Name)));
					this.returnedVariable = possibleReturnValues[possibleReturnValues.Count - 1];
				} else {
					newMethod.TypeReference = new TypeReference("System.Void", true);
					this.returnedVariable = null;
				}
			}
		}

        private MethodDeclaration MakePermutation(MethodDeclaration right, IEnumerable<PrimExpSet> prim_groups)
        {
            ResetNameCount();

            right = right.DeepCopy();
            var rights_primitives = right.AllPrimitiveExpressions();

            foreach (var prim_grp in prim_groups)
            {
                var param_name = NextName();

                var typeRef = new TypeReference(prim_grp.ValueType.FullName);
                right.Parameters.Add(new ParameterDeclarationExpression(typeRef, param_name));

                var replacer = new PrimitiveReplacer();
                foreach (var pos in prim_grp.Positions)
                {
                    replacer.AddReplacement(rights_primitives[pos], new IdentifierExpression(param_name));
                }
                right.AcceptVisitor(replacer, null);
            }

            return right;
        }

		IEnumerable<Variable> FromParameters(MethodDeclaration newMethod)
		{
			if (parentNode is ParametrizedNode) {
				foreach (ParameterDeclarationExpression pde in (parentNode as ParametrizedNode).Parameters) {
					FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, pde.ParameterName, newMethod.Body.StartLocation, newMethod.Body.EndLocation);
					
					newMethod.AcceptVisitor(frv, null);
					if (frv.Identifiers.Count > 0) {
						pde.ParamModifier &= ~(ParameterModifiers.Params);
						
						if (parentNode is MethodDeclaration) {
							yield return new Variable((parentNode as MethodDeclaration).Body, pde);
						} else if (parentNode is ConstructorDeclaration) {
							yield return new Variable((parentNode as ConstructorDeclaration).Body, pde);
						} else if (parentNode is PropertyDeclaration) {
							var p = parentNode as PropertyDeclaration;
							yield return new Variable(p.BodyStart, p.BodyEnd, pde);
						} else {
							throw new NotSupportedException("not supported!");
						}
					}
				}
			}
			
			if (parentNode is PropertyDeclaration && IsInSetter(parentNode as PropertyDeclaration)) {
				PropertyDeclaration pd = parentNode as PropertyDeclaration;
				yield return new Variable(
					new LocalLookupVariable(
						"value", pd.TypeReference,
						pd.SetRegion.StartLocation, pd.SetRegion.EndLocation,
						false, false, null, null, false
					)
				);
			}
		}

		bool HasReferencesInSelection(MethodDeclaration newMethod, Variable variable)
		{
			FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, variable.Name,
			                                                    newMethod.Body.StartLocation, newMethod.Body.EndLocation);
			
			newMethod.AcceptVisitor(frv, null);
			return frv.Identifiers.Count > 0;
		}

		IEnumerable<Variable> FromParameters(MethodDeclaration newMethod)
		{
			foreach (ParameterDeclarationExpression pde in parentNode.Parameters) {
				FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, pde.ParameterName, newMethod.Body.StartLocation, newMethod.Body.EndLocation);
				
				newMethod.AcceptVisitor(frv, null);
				if (frv.Identifiers.Count > 0) {
					pde.ParamModifier &= ~(ParameterModifiers.Params);
					
					if (parentNode is MethodDeclaration) {
						yield return new Variable((parentNode as MethodDeclaration).Body, pde);
					} else {
						throw new NotSupportedException("not supported!");
					}
				}
			}
		}

		protected static bool HasAssignment(MethodDeclaration method, Variable variable)
		{
			HasAssignmentsVisitor hav = new HasAssignmentsVisitor(variable.Name, variable.Type, variable.StartPos, variable.EndPos);
			
			method.AcceptVisitor(hav, null);
			
			return hav.HasAssignment;
		}

		protected ErrorKind CheckForJumpInstructions(MethodDeclaration method)
		{
			FindJumpInstructionsVisitor fjiv = new FindJumpInstructionsVisitor(method);
			
			method.AcceptVisitor(fjiv, null);
			return fjiv.DoCheck();
		}

		protected static bool CheckForJumpInstructions(MethodDeclaration method, ISelection selection)
		{
			FindJumpInstructionsVisitor fjiv = new FindJumpInstructionsVisitor(method, selection);
			
			method.AcceptVisitor(fjiv, null);
			
			return fjiv.IsOk;
		}