public IType RenameClass(IProgressMonitor monitor, IType cls, string newName, RefactoryScope scope)
        {
            try {
                MemberReferenceCollection refs = new MemberReferenceCollection();
                Refactor(monitor, cls, scope, new RefactorDelegate(new RefactorFindClassReferences(cls, refs, false).Refactor));
                refs.RenameAll(newName);

                RefactorerContext gctx = GetGeneratorContext(cls);
                IRefactorer       r    = GetGeneratorForClass(cls);

                foreach (IMethod method in cls.Methods)
                {
                    if (method.IsConstructor)
                    {
                        r.RenameMember(gctx, cls, (IMember)method, newName);
                    }
                }

                cls = r.RenameClass(gctx, cls, newName);

                gctx.Save();

                return(cls);
            } catch (Exception e) {
                LoggingService.LogError(GettextCatalog.GetString("Error while renaming {0} to {1}: {2}", cls, newName, e.ToString()));
                return(null);
            }
        }
        public IMember EncapsulateField(IProgressMonitor monitor, IType cls, IField field, string propName, MemberAttributes attr, bool generateSetter, bool updateInternalRefs)
        {
            RefactoryScope scope = GetScope(field);

            MemberReferenceCollection refs = new MemberReferenceCollection();

            Refactor(monitor, cls, scope, new RefactorDelegate(new RefactorFindMemberReferences(cls, field, refs, false).Refactor));

            if (!updateInternalRefs)
            {
                ArrayList list = new ArrayList();
                list.AddRange(refs);
                list.Sort(new MemberReferenceCollection.MemberComparer());

                foreach (MemberReference mref in list)
                {
                    bool rename = true;
                    foreach (IType part in field.DeclaringType.Parts)
                    {
                        if (mref.FileName == part.CompilationUnit.FileName)
                        {
                            DomRegion region = part.BodyRegion;

                            // check if the reference is internal to the class
                            if ((mref.Line > region.Start.Line ||
                                 (mref.Line == region.Start.Line && mref.Column >= region.Start.Column)) &&
                                (mref.Line < region.End.Line ||
                                 (mref.Line == region.End.Line && mref.Column <= region.End.Column)))
                            {
                                // Internal to the class, don't rename
                                rename = false;
                                break;
                            }
                        }
                    }

                    if (rename)
                    {
                        mref.Rename(propName);
                    }
                }
            }
            else
            {
                refs.RenameAll(propName);
            }

            RefactorerContext gctx = GetGeneratorContext(cls);
            IRefactorer       r    = GetGeneratorForClass(cls);
            IMember           m    = r.EncapsulateField(gctx, cls, field, propName, attr, generateSetter);

            gctx.Save();

            return(m);
        }
        IMember InnerRenameMember(IProgressMonitor monitor, IType cls, IMember member, string newName, RefactoryScope scope)
        {
            try {
                MemberReferenceCollection refs = new MemberReferenceCollection();
                Refactor(monitor, cls, scope, new RefactorDelegate(new RefactorFindMemberReferences(cls, member, refs, false).Refactor));
                refs.RenameAll(newName);

                RefactorerContext gctx = GetGeneratorContext(cls);

                IRefactorer gen = GetGeneratorForClass(cls);
                IMember     m   = gen.RenameMember(gctx, cls, member, newName);
                gctx.Save();
                return(m);
            } catch (Exception e) {
                LoggingService.LogError(GettextCatalog.GetString("Error while renaming {0} to {1}: {2}", member, newName, e.ToString()));
                return(null);
            }
        }
        public bool RenameVariable(IProgressMonitor monitor, LocalVariable var, string newName)
        {
            try {
                MemberReferenceCollection refs = new MemberReferenceCollection();
                Refactor(monitor, var, new RefactorDelegate(new RefactorFindVariableReferences(var, refs).Refactor));
                refs.RenameAll(newName);

                RefactorerContext gctx = GetGeneratorContext(var);
                IRefactorer       r    = GetGeneratorForVariable(var);
                bool rv = r.RenameVariable(gctx, var, newName);
                gctx.Save();

                return(rv);
            } catch (Exception e) {
                LoggingService.LogError(GettextCatalog.GetString("Error while renaming {0} to {1}: {2}", var, newName, e.ToString()));
                return(false);
            }
        }
        public bool RenameParameter(IProgressMonitor monitor, IParameter param, string newName)
        {
            try {
                MemberReferenceCollection refs = new MemberReferenceCollection();
                Refactor(monitor, param, new RefactorDelegate(new RefactorFindParameterReferences(param, refs, false).Refactor));
                refs.RenameAll(newName);

                IMember           member = param.DeclaringMember;
                RefactorerContext gctx   = GetGeneratorContext(member.DeclaringType);
                IRefactorer       r      = GetGeneratorForClass(member.DeclaringType);
                bool rv = r.RenameParameter(gctx, param, newName);
                gctx.Save();

                return(rv);
            } catch (Exception e) {
                LoggingService.LogError(GettextCatalog.GetString("Error while renaming {0} to {1}: {2}", param, newName, e.ToString()));
                return(false);
            }
        }
		IMember InnerRenameMember (IProgressMonitor monitor, IType cls, IMember member, string newName, RefactoryScope scope)
		{
			try {
				MemberReferenceCollection refs = new MemberReferenceCollection ();
				Refactor (monitor, cls, scope, new RefactorDelegate (new RefactorFindMemberReferences (cls, member, refs, false).Refactor));
				refs.RenameAll (newName);
				
				RefactorerContext gctx = GetGeneratorContext (cls);
				
				IRefactorer gen = GetGeneratorForClass (cls);
				IMember m = gen.RenameMember (gctx, cls, member, newName);
				gctx.Save ();
				return m;
			} catch (Exception e) {
				LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}",  member, newName, e.ToString ()));
				return null;
			}
		}
		public IType RenameClass (IProgressMonitor monitor, IType cls, string newName, RefactoryScope scope)
		{
			try {
				MemberReferenceCollection refs = new MemberReferenceCollection ();
				Refactor (monitor, cls, scope, new RefactorDelegate (new RefactorFindClassReferences (cls, refs, false).Refactor));
				refs.RenameAll (newName);
				
				RefactorerContext gctx = GetGeneratorContext (cls);
				IRefactorer r = GetGeneratorForClass (cls);
				
				foreach (IMethod method in cls.Methods) {
					if (method.IsConstructor)
						r.RenameMember (gctx, cls, (IMember) method, newName);
				}
				
				cls = r.RenameClass (gctx, cls, newName);
				
				gctx.Save ();
				
				return cls;
			} catch (Exception e) {
				LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}",  cls, newName, e.ToString ()));
				return null;
			}
		}
		public IMember EncapsulateField (IProgressMonitor monitor, IType cls, IField field, string propName, MemberAttributes attr, bool generateSetter, bool updateInternalRefs)
		{
			RefactoryScope scope = GetScope (field);
			
			MemberReferenceCollection refs = new MemberReferenceCollection ();
			Refactor (monitor, cls, scope, new RefactorDelegate (new RefactorFindMemberReferences (cls, field, refs, false).Refactor));
			
			if (!updateInternalRefs) {
				ArrayList list = new ArrayList ();
				list.AddRange (refs);
				list.Sort (new MemberReferenceCollection.MemberComparer ());
				
				foreach (MemberReference mref in list) {
					bool rename = true;
					foreach (IType part in field.DeclaringType.Parts) {
						if (mref.FileName == part.CompilationUnit.FileName) {
							DomRegion region = part.BodyRegion;
							
							// check if the reference is internal to the class
							if ((mref.Line > region.Start.Line ||
							     (mref.Line == region.Start.Line && mref.Column >= region.Start.Column)) &&
							    (mref.Line < region.End.Line ||
							     (mref.Line == region.End.Line && mref.Column <= region.End.Column))) {
								// Internal to the class, don't rename
								rename = false;
								break;
							}
						}
					}
					
					if (rename)
						mref.Rename (propName);
				}
			} else {
				refs.RenameAll (propName);
			}
			
			RefactorerContext gctx = GetGeneratorContext (cls);
			IRefactorer r = GetGeneratorForClass (cls);
			IMember m = r.EncapsulateField (gctx, cls, field, propName, attr, generateSetter);
			gctx.Save ();
			
			return m;
		}
		public bool RenameParameter (IProgressMonitor monitor, IParameter param, string newName)
		{
			try {
				MemberReferenceCollection refs = new MemberReferenceCollection ();
				Refactor (monitor, param, new RefactorDelegate (new RefactorFindParameterReferences (param, refs, false).Refactor));
				refs.RenameAll (newName);
				
				IMember member = param.DeclaringMember;
				RefactorerContext gctx = GetGeneratorContext (member.DeclaringType);
				IRefactorer r = GetGeneratorForClass (member.DeclaringType);
				bool rv = r.RenameParameter (gctx, param, newName);
				gctx.Save ();
				
				return rv;
			} catch (Exception e) {
				LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}",  param, newName, e.ToString ()));
				return false;
			}
		}
		public bool RenameVariable (IProgressMonitor monitor, LocalVariable var, string newName)
		{
			try {
				MemberReferenceCollection refs = new MemberReferenceCollection ();
				Refactor (monitor, var, new RefactorDelegate (new RefactorFindVariableReferences (var, refs).Refactor));
				refs.RenameAll (newName);
				
				RefactorerContext gctx = GetGeneratorContext (var);
				IRefactorer r = GetGeneratorForVariable (var);
				bool rv = r.RenameVariable (gctx, var, newName);
				gctx.Save ();
				
				return rv;
			} catch (Exception e) {
				LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}",  var, newName, e.ToString ()));
				return false;
			}
		}