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 void AddAttribute(IType cls, CodeAttributeDeclaration attr)
{
RefactorerContext gctx = GetGeneratorContext(cls);
IRefactorer gen = GetGeneratorForClass(cls);
gen.AddAttribute(gctx, cls, attr);
gctx.Save();
}
public IType AddMembers(IType cls, IEnumerable <CodeTypeMember> members, string foldingRegionName)
{
RefactorerContext gctx = GetGeneratorContext(cls);
IRefactorer gen = GetGeneratorForClass(cls);
gen.AddMembers(gctx, cls, members, foldingRegionName);
gctx.Save();
return(GetUpdatedClass(gctx, cls));
}
public IMember ImplementMember(IType cls, IMember member, IReturnType privateReturnType)
{
RefactorerContext gctx = GetGeneratorContext(cls);
IRefactorer gen = GetGeneratorForClass(cls);
IMember m = gen.ImplementMember(gctx, cls, member, privateReturnType);
gctx.Save();
return(m);
}
public IMember AddMember(IType cls, CodeTypeMember member)
{
RefactorerContext gctx = GetGeneratorContext(cls);
IRefactorer gen = GetGeneratorForClass(cls);
IMember m = gen.AddMember(gctx, cls, member);
gctx.Save();
return(m);
}
public IType CreateClass(Project project, string language, string directory, string namspace, CodeTypeDeclaration type)
{
ProjectDom ctx = ProjectDomService.GetProjectDom(project);
RefactorerContext gctx = new RefactorerContext(ctx, fileProvider, null);
IRefactorer gen = LanguageBindingService.GetRefactorerForLanguage(language);
IType c = gen.CreateClass(gctx, directory, namspace, type);
gctx.Save();
return(c);
}
public bool ClassSupportsOperation(IType cls, RefactorOperations operation)
{
IRefactorer r = GetGeneratorForClass(cls);
if (r == null)
{
return(false);
}
return((r.SupportedOperations & operation) == operation);
}
public bool LanguageSupportsOperation(string langName, RefactorOperations operation)
{
IRefactorer r = LanguageBindingService.GetRefactorerForLanguage(langName);
if (r == null)
{
return(false);
}
return((r.SupportedOperations & operation) == operation);
}
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 void RemoveMember(IType cls, IMember member)
{
try {
RefactorerContext gctx = GetGeneratorContext(cls);
IRefactorer gen = GetGeneratorForClass(cls);
gen.RemoveMember(gctx, cls, member);
gctx.Save();
} catch (Exception e) {
LoggingService.LogError(GettextCatalog.GetString("Error while removing {0}:{1}", member, e.ToString()));
}
}
public IType ImplementMembers(IType cls, IEnumerable <KeyValuePair <IMember, IReturnType> > members,
string foldingRegionName)
{
RefactorerContext gctx = GetGeneratorContext(cls);
cls = GetUpdatedClass(gctx, cls);
IRefactorer gen = GetGeneratorForClass(cls);
gen.ImplementMembers(gctx, cls, members, foldingRegionName);
gctx.Save();
return(GetUpdatedClass(gctx, cls));
}
public void Refactor(IProgressMonitor monitor, RefactorerContext rctx, IRefactorer r, string fileName)
{
try {
IEnumerable <MemberReference> refs = r.FindClassReferences(rctx, fileName, cls, includeXmlComment);
if (refs != null)
{
references.AddRange(refs);
}
} catch (Exception ex) {
monitor.ReportError(GettextCatalog.GetString("Could not look for references in file '{0}': {1}", fileName, ex.Message), ex);
}
}
public IMember ReplaceMember(IType cls, IMember oldMember, CodeTypeMember member)
{
try {
RefactorerContext gctx = GetGeneratorContext(cls);
IRefactorer gen = GetGeneratorForClass(cls);
IMember m = gen.ReplaceMember(gctx, cls, oldMember, member);
gctx.Save();
return(m);
} catch (Exception e) {
LoggingService.LogError(GettextCatalog.GetString("Error while replacing {0}: {1}", member, e.ToString()));
return(null);
}
}
void Refactor(IProgressMonitor monitor, LocalVariable var, RefactorDelegate refactorDelegate)
{
RefactorerContext gctx = GetGeneratorContext(var);
string file = var.FileName;
IRefactorer gen = LanguageBindingService.GetRefactorerForFile(file);
if (gen == null)
{
return;
}
refactorDelegate(monitor, gctx, gen, file);
gctx.Save();
}
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);
}
}
// public IType ImplementMembers (IType cls, IEnumerable<KeyValuePair<IMember,IReturnType>> members,
// string foldingRegionName)
// {
// RefactorerContext gctx = GetGeneratorContext (cls);
// cls = GetUpdatedClass (gctx, cls);
// IRefactorer gen = GetGeneratorForClass (cls);
// gen.ImplementMembers (gctx, cls, members, foldingRegionName);
// gctx.Save ();
// return GetUpdatedClass (gctx, cls);
// }
string GenerateGenerics(IRefactorer gen, IType iface, IReturnType hintReturnType)
{
StringBuilder result = new StringBuilder();
if (hintReturnType != null && hintReturnType.GenericArguments != null)
{
result.Append("<");
for (int i = 0; i < hintReturnType.GenericArguments.Count; i++)
{
result.Append(gen.ConvertToLanguageTypeName(RemoveGenericParamSuffix(hintReturnType.GenericArguments[i].FullName)));
result.Append(GenerateGenerics(gen, iface, hintReturnType.GenericArguments[i]));
if (i + 1 < hintReturnType.GenericArguments.Count)
{
result.Append(", ");
}
}
result.Append(">");
}
return(result.ToString());
}
void RefactorProject(IProgressMonitor monitor, Project p, RefactorDelegate refactorDelegate)
{
RefactorerContext gctx = GetGeneratorContext(p);
monitor.Log.WriteLine(GettextCatalog.GetString("Refactoring project {0}", p.Name));
foreach (ProjectFile file in p.Files)
{
if (file.BuildAction != BuildAction.Compile || !System.IO.File.Exists(file.FilePath))
{
continue;
}
IRefactorer gen = LanguageBindingService.GetRefactorerForFile(file.Name);
if (gen == null)
{
continue;
}
refactorDelegate(monitor, gctx, gen, file.Name);
gctx.Save();
}
}
public void Refactor (IProgressMonitor monitor, RefactorerContext rctx, IRefactorer r, string fileName)
{
try {
IEnumerable<MemberReference> refs = r.FindParameterReferences (rctx, fileName, param, includeXmlComment);
if (refs != null)
references.AddRange (refs);
} catch (Exception ex) {
monitor.ReportError (GettextCatalog.GetString ("Could not look for references in file '{0}': {1}", fileName, ex.Message), ex);
}
}
// public IType ImplementMembers (IType cls, IEnumerable<KeyValuePair<IMember,IReturnType>> members,
// string foldingRegionName)
// {
// RefactorerContext gctx = GetGeneratorContext (cls);
// cls = GetUpdatedClass (gctx, cls);
// IRefactorer gen = GetGeneratorForClass (cls);
// gen.ImplementMembers (gctx, cls, members, foldingRegionName);
// gctx.Save ();
// return GetUpdatedClass (gctx, cls);
// }
string GenerateGenerics (IRefactorer gen, IType iface, IReturnType hintReturnType)
{
StringBuilder result = new StringBuilder ();
if (hintReturnType != null && hintReturnType.GenericArguments != null) {
result.Append ("<");
for (int i = 0; i < hintReturnType.GenericArguments.Count; i++) {
result.Append (gen.ConvertToLanguageTypeName (RemoveGenericParamSuffix (hintReturnType.GenericArguments[i].FullName)));
result.Append (GenerateGenerics (gen, iface, hintReturnType.GenericArguments[i]));
if (i + 1 < hintReturnType.GenericArguments.Count)
result.Append (", ");
}
result.Append (">");
}
return result.ToString ();
}
public void AddLocalNamespaceImport(ProjectDom dom, string fileName, string nsName, DomLocation caretLocation)
{
IRefactorer refactorer = LanguageBindingService.GetRefactorerForFile(fileName);
refactorer.AddLocalNamespaceImport(new RefactorerContext(dom, fileProvider, null), fileName, nsName, caretLocation);
}
public DomLocation CompleteStatement(ProjectDom dom, string fileName, DomLocation caretLocation)
{
IRefactorer refactorer = LanguageBindingService.GetRefactorerForFile(fileName);
return(refactorer.CompleteStatement(new RefactorerContext(dom, fileProvider, null), fileName, caretLocation));
}
void Refactor(IProgressMonitor monitor, IType cls, RefactoryScope scope, RefactorDelegate refactorDelegate)
{
switch (scope)
{
case RefactoryScope.DeclaringType:
ProjectDom ctx = GetParserContext(cls);
if (cls is InstantiatedType)
{
cls = ((InstantiatedType)cls).UninstantiatedType;
}
IType resolvedType = ctx.GetType(cls.FullName, cls.TypeParameters.Count, true, true);
if (resolvedType == null)
{
goto case RefactoryScope.Solution;
}
foreach (IType part in resolvedType.Parts)
{
string file = part.CompilationUnit.FileName;
RefactorerContext gctx = GetGeneratorContext(part);
IRefactorer gen = LanguageBindingService.GetRefactorerForFile(file);
if (gen == null)
{
return;
}
refactorDelegate(monitor, gctx, gen, file);
gctx.Save();
}
break;
case RefactoryScope.File: {
string file = cls.CompilationUnit.FileName;
RefactorerContext gctx = GetGeneratorContext(cls);
IRefactorer gen = LanguageBindingService.GetRefactorerForFile(file);
if (gen == null)
{
return;
}
refactorDelegate(monitor, gctx, gen, file);
gctx.Save();
break;
}
case RefactoryScope.Project:
Project prj = GetProjectForFile(cls.CompilationUnit.FileName);
if (prj == null)
{
return;
}
RefactorProject(monitor, prj, refactorDelegate);
break;
case RefactoryScope.Solution:
if (solution == null)
{
goto case RefactoryScope.File;
}
foreach (Project project in solution.GetAllProjects())
{
RefactorProject(monitor, project, refactorDelegate);
}
break;
}
}
