List <IMember> CollectMembers(string code, string typeName, Predicate <IUnresolvedMember> filter1, Predicate <IMember> filter2,
bool includeOverloads, bool matchDeclaringType)
{
var fileName = string.Format("test{0}.csproj", Environment.TickCount); // use a new file name for each test to avoid conflicts
var project = new UnknownProject {
FileName = fileName
};
var solution = new Solution();
solution.RootFolder.AddItem(project);
var baseType = GenerateAssembly(project, code).GetTypeDefinition("", typeName, 0);
var members = baseType.GetMembers(filter1).Concat(baseType.GetConstructors(filter1));
if (filter2 != null)
{
members = members.Where(m => filter2(m));
}
var result = MemberCollector.CollectMembers(solution, members.First(), ReferenceFinder.RefactoryScope.Solution,
includeOverloads, matchDeclaringType).ToList();
TypeSystemService.UnloadProject(project, true);
return(result);
}
public static IProject LoadProject(ProjectLoadInformation loadInformation)
{
if (loadInformation == null)
{
throw new ArgumentNullException("loadInformation");
}
string location = FileUtility.NormalizePath(loadInformation.FileName);
string title = loadInformation.ProjectName;
IProgressMonitor progressMonitor = loadInformation.ProgressMonitor;
progressMonitor.CancellationToken.ThrowIfCancellationRequested();
IProjectBinding binding = ProjectBindingService.GetBindingPerProjectFile(location);
IProject newProject;
if (!(binding != null && binding.HandlingMissingProject) && !File.Exists(location))
{
newProject = new MissingProject(location, title);
newProject.TypeGuid = loadInformation.TypeGuid;
}
else
{
if (binding != null)
{
try {
newProject = binding.LoadProject(loadInformation);
} catch (ProjectLoadException ex) {
LoggingService.Warn("Project load error", ex);
progressMonitor.ShowingDialog = true;
newProject = new UnknownProject(location, title, ex.Message, true);
newProject.TypeGuid = loadInformation.TypeGuid;
progressMonitor.ShowingDialog = false;
} catch (UnauthorizedAccessException ex) {
LoggingService.Warn("Project load error", ex);
progressMonitor.ShowingDialog = true;
newProject = new UnknownProject(location, title, ex.Message, true);
newProject.TypeGuid = loadInformation.TypeGuid;
progressMonitor.ShowingDialog = false;
}
}
else
{
string ext = Path.GetExtension(location);
if (".proj".Equals(ext, StringComparison.OrdinalIgnoreCase) ||
".build".Equals(ext, StringComparison.OrdinalIgnoreCase))
{
newProject = new MSBuildFileProject(location, title);
newProject.TypeGuid = loadInformation.TypeGuid;
}
else
{
newProject = new UnknownProject(location, title);
newProject.TypeGuid = loadInformation.TypeGuid;
}
}
}
return(newProject);
}
public static bool TryLoadFromFile(string path, out Project project)
{
if (string.IsNullOrEmpty(path))
{
project = null;
return(false);
}
XDocument doc;
try
{
doc = XDocument.Load(path);
}
catch (DirectoryNotFoundException)
{
project = null;
return(false);
}
catch (FileNotFoundException)
{
project = null;
return(false);
}
var nameNode = doc.XPathSelectElement(@"/x:Project/x:PropertyGroup/x:AssemblyName", NamespaceManager);
var projectInfoNode = doc.XPathSelectElement(ProjectInfoXPath, NamespaceManager);
XAttribute projectTypeAttribute = null;
if (projectInfoNode != null)
{
projectTypeAttribute = projectInfoNode.Attribute("Type");
}
if (nameNode == null)
{
project = null;
return(false);
}
if (projectInfoNode != null)
{
var skippedNode = projectInfoNode.Attribute("Skip");
if (skippedNode != null && skippedNode.Value == "true")
{
project = null;
return(false);
}
var type = projectTypeAttribute != null?ProjectTypeHelper.Parse(projectTypeAttribute.Value) : ProjectType.Unknown;
project = type.CreateInstance(nameNode.Value, path);
}
else
{
project = new UnknownProject(nameNode.Value, path);
}
return(project.TryLoad(doc));
}
public void TestCollectFiles()
{
var code1 = @"
namespace project1 {
class A
{
private void Method1() { }
public void Method2() { }
}
public class B
{ }
}";
var project1 = new UnknownProject {
FileName = "projectc1.csproj"
};
var project2 = new DotNetAssemblyProject {
FileName = "projectc2.csproj"
};
project2.References.Add(new MonoDevelop.Projects.ProjectReference(project1));
var solution = new Solution();
solution.RootFolder.AddItem(project1);
solution.RootFolder.AddItem(project2);
solution.RootFolder.AddItem(new UnknownProject {
FileName = "dummy.csproj"
});
project1.AddFile(new ProjectFile("dummy.cs"));
TypeSystemService.LoadProject(project2);
var wrapper = TypeSystemService.LoadProject(project1);
TypeSystemService.ParseFile("test.cs", "text/x-csharp", code1, wrapper);
var compilation = wrapper.Compilation;
var typeA = compilation.MainAssembly.GetTypeDefinition("project1", "A", 0);
TestCollectFiles(project1, typeA.GetMembers(m => m.Name == "Method1"),
new [] { CreateTestTuple(project1, new [] { (FilePath)"test.cs" }) });
TestCollectFiles(project1, new [] { typeA }, new [] { CreateTestTuple(project1) });
TestCollectFiles(project1, typeA.GetMembers(m => m.Name == "Method2"), new [] { CreateTestTuple(project1) });
TestCollectFiles(project1, typeA.GetMembers(), new [] { CreateTestTuple(project1) });
TestCollectFiles(solution, typeA.GetMembers(m => m.Name == "Method1"),
new [] { CreateTestTuple(project1, new [] { (FilePath)"test.cs" }) });
TestCollectFiles(solution, typeA.GetMembers(), new [] { CreateTestTuple(project1) });
var typeB = compilation.MainAssembly.GetTypeDefinition("project1", "B", 0);
TestCollectFiles(solution, new [] { typeB }, new [] { CreateTestTuple(project1), CreateTestTuple(project2) });
TestCollectFiles(solution, new [] { typeA, typeB }, new [] { CreateTestTuple(project1), CreateTestTuple(project2) });
TypeSystemService.UnloadProject(project1);
TypeSystemService.UnloadProject(project2);
}
public static IProject LoadProject(IMSBuildEngineProvider provider, string location, string title, string projectTypeGuid)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (location == null)
{
throw new ArgumentNullException("location");
}
if (title == null)
{
throw new ArgumentNullException("title");
}
if (projectTypeGuid == null)
{
throw new ArgumentNullException("projectTypeGuid");
}
IProject newProject;
if (!File.Exists(location))
{
newProject = new MissingProject(location, title);
newProject.TypeGuid = projectTypeGuid;
}
else
{
ILanguageBinding binding = LanguageBindingService.GetBindingPerProjectFile(location);
if (binding != null)
{
try {
location = Path.GetFullPath(location);
} catch (Exception) {}
try {
newProject = binding.LoadProject(provider, location, title);
} catch (XmlException ex) {
newProject = new UnknownProject(location, title, ex.Message, true);
newProject.TypeGuid = projectTypeGuid;
} catch (Microsoft.Build.BuildEngine.InvalidProjectFileException ex) {
newProject = new UnknownProject(location, title, ex.Message, true);
newProject.TypeGuid = projectTypeGuid;
} catch (UnauthorizedAccessException ex) {
newProject = new UnknownProject(location, title, ex.Message, true);
newProject.TypeGuid = projectTypeGuid;
}
}
else
{
newProject = new UnknownProject(location, title);
newProject.TypeGuid = projectTypeGuid;
}
}
return(newProject);
}
public void TestCollectProjects()
{
var code = @"
namespace project1 {
class A
{
private void Method1() { }
public void Method2() { }
}
public class B
{
private void Method1() { }
protected void Method2() { }
}
}";
var project1 = new UnknownProject {
FileName = "project1.csproj"
};
var project2 = new DotNetAssemblyProject {
FileName = "project2.csproj"
};
var solution = new Solution();
solution.RootFolder.AddItem(project1);
solution.RootFolder.AddItem(project2);
solution.RootFolder.AddItem(new UnknownProject {
FileName = "project3.csproj"
});
TypeSystemService.LoadProject(project2);
var wrapper = TypeSystemService.LoadProject(project1);
TypeSystemService.ParseFile("test.cs", "text/x-csharp", code, wrapper);
var compilation = wrapper.Compilation;
var typeA = compilation.MainAssembly.GetTypeDefinition("project1", "A", 0);
Assert.IsNotNull(typeA);
TestCollectProjects(solution, new [] { typeA }, new [] { project1 });
TestCollectProjects(solution, typeA.GetMembers(), new [] { project1 });
TestCollectProjects(solution, typeA.GetMembers(m => m.Name == "Method1"), new [] { project1 });
TestCollectProjects(solution, typeA.GetMembers(m => m.Name == "Method2"), new [] { project1 });
project2.References.Add(new MonoDevelop.Projects.ProjectReference(project1));
var typeB = compilation.MainAssembly.GetTypeDefinition("project1", "B", 0);
Assert.IsNotNull(typeB);
TestCollectProjects(solution, new [] { typeB }, new Project [] { project1, project2 });
TestCollectProjects(solution, typeB.GetMembers(), new Project [] { project1, project2 });
TestCollectProjects(solution, typeB.GetMembers(m => m.Name == "Method1"), new [] { project1 });
TestCollectProjects(solution, typeB.GetMembers(m => m.Name == "Method2"), new Project [] { project1, project2 });
TypeSystemService.UnloadProject(project1);
TypeSystemService.UnloadProject(project2);
}
public static bool IsMigratableProject(UnknownProject project)
{
if (project == null)
{
return(false);
}
if (!project.FileName.HasExtension(".xproj"))
{
return(false);
}
return(File.Exists(Path.Combine(Path.GetDirectoryName(project.FileName), "project.json")));
}
public void TestGetBaseTypes()
{
string code = @"
class A { }
class B : A { }
interface IA { }
class C : A, IA { }
interface IB { }
class D : B, IA, IB { }
";
var project = new UnknownProject();
project.FileName = "test.csproj";
var assembly = GenerateAssembly(project, code);
var A = assembly.GetTypeDefinition("", "A", 0);
var B = assembly.GetTypeDefinition("", "B", 0);
var C = assembly.GetTypeDefinition("", "C", 0);
var D = assembly.GetTypeDefinition("", "D", 0);
var IA = assembly.GetTypeDefinition("", "IA", 0);
var IB = assembly.GetTypeDefinition("", "IB", 0);
var result1 = MemberCollector.GetBaseTypes(new [] { A, B, C, D }).ToList();
VerifyResult(result1, new Predicate <ITypeDefinition>[] { t => t == A });
var result2 = MemberCollector.GetBaseTypes(new [] { A, B, C, IA }).ToList();
VerifyResult(result2, new Predicate <ITypeDefinition>[]
{ t => t == A, t => t == IA });
var result3 = MemberCollector.GetBaseTypes(new [] { A, B, C, D, IA, IB }).ToList();
VerifyResult(result3, new Predicate <ITypeDefinition>[]
{ t => t == A, t => t == IA, t => t == IB });
TypeSystemService.UnloadProject(project, true);
}
void TestCreateInterface(string interfacecode, string outputString, string stubString = null)
{
var project = new UnknownProject();
project.FileName = "test.csproj";
TypeSystemService.LoadProject(project);
TypeSystemService.ParseFile(project, "program.cs", "text/x-csharp", interfacecode);
TypeSystemService.ParseFile(project, "stub.cs", "text/x-csharp", "class Stub {\n " + stubString + "}\n");
var wrapper = TypeSystemService.GetProjectContentWrapper(project);
wrapper.UpdateContent(c => c.AddAssemblyReferences(new [] { Mscorlib, SystemCore }));
var pctx = TypeSystemService.GetCompilation(project);
var stubType = pctx.MainAssembly.GetTypeDefinition("", "Stub", 0);
var iface = pctx.MainAssembly.GetTypeDefinition("", "ITest", 0);
var gen = new CSharpCodeGenerator();
gen.EolMarker = "\n";
gen.Compilation = pctx;
string generated = gen.CreateInterfaceImplementation(stubType, stubType.Parts.First(), iface, false);
Assert.IsNotEmpty(generated);
// crop #region
generated = generated.Substring(generated.IndexOf("implementation") + "implementation".Length);
generated = generated.Substring(0, generated.LastIndexOf("#"));
generated = generated.Trim();
if (outputString != generated)
{
Console.WriteLine(generated);
}
Assert.AreEqual(outputString, generated);
}
async Task <bool> Migrate(UnknownProject project, Solution solution, ProgressMonitor monitor)
{
FilePath projectFile;
string migrationFile;
if (project == null)
{
migrationFile = solution.FileName;
}
else
{
projectFile = project.FileName;
migrationFile = Path.Combine(Path.GetDirectoryName(projectFile), "project.json");
}
if (DotNetCoreRuntime.IsMissing)
{
monitor.ReportError(GettextCatalog.GetString(".NET Core is not installed"));
return(false);
}
var process = Runtime.ProcessService.StartProcess(
DotNetCoreRuntime.FileName,
$"migrate \"{migrationFile}\"",
Path.GetDirectoryName(migrationFile),
monitor.Log,
monitor.Log,
null);
await process.Task;
if (process.ExitCode > 0)
{
monitor.ReportError(GettextCatalog.GetString("An unspecified error occurred while running '{0}'", $"dotnet migrate({process.ExitCode})"));
return(false);
}
if (project != null)
{
string newProjectFile;
if (File.Exists(Path.ChangeExtension(projectFile, ".csproj")))
{
newProjectFile = Path.ChangeExtension(projectFile, ".csproj");
}
else if (File.Exists(Path.ChangeExtension(projectFile, ".fsproj")))
{
newProjectFile = Path.ChangeExtension(projectFile, ".fsproj");
}
else if (File.Exists(Path.ChangeExtension(projectFile, ".vbproj")))
{
newProjectFile = Path.ChangeExtension(projectFile, ".vbproj");
}
else
{
monitor.ReportError(GettextCatalog.GetString("Migrated project file not found."));
return(false);
}
var newProject = await project.ParentFolder.AddItem(monitor, newProjectFile);
project.ParentFolder.Items.Remove(project);
await newProject.ParentSolution.SaveAsync(monitor);
RestorePackagesInProjectHandler.Run((DotNetProject)newProject);
}
else
{
solution.NeedsReload = true;
FileService.NotifyFileChanged(solution.FileName);
}
return(true);
}
protected override async void Run(object dataItem)
{
var project = IdeApp.ProjectOperations.CurrentSelectedProject as UnknownProject;
var solution = IdeApp.ProjectOperations.CurrentSelectedSolution;
UnknownProject [] selectedProjects = null;
bool wholeSolution = false;
if (project == null)
{
// ContextMenu on Solution
var dlg = new ProjectSelectorDialog();
try {
dlg.Title = GettextCatalog.GetString("Select projects to migrate");
dlg.RootItem = solution;
dlg.AllowEmptySelection = false;
dlg.SelectableFilter = (arg) => IsMigratableProject(arg as UnknownProject);
dlg.SelectedItem = IdeApp.ProjectOperations.CurrentSelectedObject;
dlg.SelectableItemTypes = new Type [] { typeof(UnknownProject) };
dlg.ActiveItems = solution.GetAllProjects().OfType <UnknownProject> ().Where(p => p.FileName.HasExtension(".xproj"));
dlg.ShowCheckboxes = true;
if (MessageService.RunCustomDialog(dlg, IdeApp.Workbench.RootWindow) == (int)Gtk.ResponseType.Ok)
{
if (dlg.ActiveItems.SequenceEqual(solution.GetAllProjects().OfType <UnknownProject> ().Where(p => p.FileName.HasExtension(".xproj"))))
{
wholeSolution = true;
}
else
{
selectedProjects = dlg.ActiveItems.OfType <UnknownProject> ().ToArray();
}
}
else
{
return;
}
} finally {
dlg.Destroy();
dlg.Dispose();
}
}
else
{
selectedProjects = new UnknownProject [] { project };
}
using (var monitor = CreateOutputProgressMonitor()) {
try {
monitor.BeginTask(GettextCatalog.GetString("Migrating…"), 1);
if (wholeSolution)
{
if (!await Migrate(null, solution, monitor))
{
return;
}
}
else
{
foreach (var proj in selectedProjects)
{
if (!await Migrate(proj, solution, monitor))
{
return;
}
}
}
monitor.ReportSuccess(GettextCatalog.GetString("Successfully migrated"));
} catch (Exception e) {
monitor.ReportError(GettextCatalog.GetString("Failed to migrate") + Environment.NewLine + e);
}
}
}
static void TestInsertionPoints(string text)
{
TestWorkbenchWindow tww = new TestWorkbenchWindow();
TestViewContent sev = new TestViewContent();
var project = new UnknownProject();
project.FileName = "test.csproj";
TypeSystemService.LoadProject(project);
sev.Project = project;
tww.ViewContent = sev;
var doc = new MonoDevelop.Ide.Gui.Document(tww);
var data = doc.Editor;
List <InsertionPoint> loc = new List <InsertionPoint> ();
for (int i = 0; i < text.Length; i++)
{
char ch = text [i];
if (ch == '@')
{
i++;
ch = text [i];
NewLineInsertion insertBefore = NewLineInsertion.None;
NewLineInsertion insertAfter = NewLineInsertion.None;
switch (ch)
{
case 'n':
break;
case 'd':
insertAfter = NewLineInsertion.Eol;
break;
case 'D':
insertAfter = NewLineInsertion.BlankLine;
break;
case 'u':
insertBefore = NewLineInsertion.Eol;
break;
case 'U':
insertBefore = NewLineInsertion.BlankLine;
break;
case 's':
insertBefore = insertAfter = NewLineInsertion.Eol;
break;
case 'S':
insertBefore = insertAfter = NewLineInsertion.BlankLine;
break;
case 't':
insertBefore = NewLineInsertion.Eol;
insertAfter = NewLineInsertion.BlankLine;
break;
case 'T':
insertBefore = NewLineInsertion.None;
insertAfter = NewLineInsertion.BlankLine;
break;
case 'v':
insertBefore = NewLineInsertion.BlankLine;
insertAfter = NewLineInsertion.Eol;
break;
case 'V':
insertBefore = NewLineInsertion.None;
insertAfter = NewLineInsertion.Eol;
break;
default:
Assert.Fail("unknown insertion point:" + ch);
break;
}
loc.Add(new InsertionPoint(data.Document.OffsetToLocation(data.Document.TextLength), insertBefore, insertAfter));
}
else
{
data.Insert(data.Document.TextLength, ch.ToString());
}
}
var parsedFile = TypeSystemService.ParseFile(project, "program.cs", "text/x-csharp", data.Document.Text);
var foundPoints = CodeGenerationService.GetInsertionPoints(doc.Editor, parsedFile, parsedFile.TopLevelTypeDefinitions.First());
Assert.AreEqual(loc.Count, foundPoints.Count, "point count doesn't match");
for (int i = 0; i < loc.Count; i++)
{
Assert.AreEqual(loc[i].Location, foundPoints[i].Location, "point " + i + " doesn't match");
Assert.AreEqual(loc[i].LineAfter, foundPoints[i].LineAfter, "point " + i + " ShouldInsertNewLineAfter doesn't match");
Assert.AreEqual(loc[i].LineBefore, foundPoints[i].LineBefore, "point " + i + " ShouldInsertNewLineBefore doesn't match");
}
}
public static IProject LoadProject(IMSBuildEngineProvider provider, string location, string title, string projectTypeGuid, IProgressMonitor progressMonitor)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (location == null)
{
throw new ArgumentNullException("location");
}
if (title == null)
{
throw new ArgumentNullException("title");
}
if (projectTypeGuid == null)
{
throw new ArgumentNullException("projectTypeGuid");
}
if (progressMonitor != null)
{
progressMonitor.BeginTask("Loading " + title, 0, false);
}
IProject newProject;
if (!File.Exists(location))
{
newProject = new MissingProject(location, title);
newProject.TypeGuid = projectTypeGuid;
}
else
{
ILanguageBinding binding = LanguageBindingService.GetBindingPerProjectFile(location);
if (binding != null)
{
location = FileUtility.NormalizePath(location);
try {
newProject = binding.LoadProject(provider, location, title);
} catch (ProjectLoadException ex) {
LoggingService.Warn("Project load error", ex);
if (progressMonitor != null)
{
progressMonitor.ShowingDialog = true;
}
newProject = new UnknownProject(location, title, ex.Message, true);
newProject.TypeGuid = projectTypeGuid;
if (progressMonitor != null)
{
progressMonitor.ShowingDialog = false;
}
} catch (UnauthorizedAccessException ex) {
LoggingService.Warn("Project load error", ex);
if (progressMonitor != null)
{
progressMonitor.ShowingDialog = true;
}
newProject = new UnknownProject(location, title, ex.Message, true);
newProject.TypeGuid = projectTypeGuid;
if (progressMonitor != null)
{
progressMonitor.ShowingDialog = false;
}
}
}
else
{
string ext = Path.GetExtension(location);
if (".proj".Equals(ext, StringComparison.OrdinalIgnoreCase) ||
".build".Equals(ext, StringComparison.OrdinalIgnoreCase))
{
newProject = new MSBuildFileProject(location, title);
newProject.TypeGuid = projectTypeGuid;
}
else
{
newProject = new UnknownProject(location, title);
newProject.TypeGuid = projectTypeGuid;
}
}
}
return(newProject);
}
public static bool TryLoadFromFile(string path, out Project project)
{
if(string.IsNullOrEmpty(path))
{
project = null;
return false;
}
XDocument doc;
try
{
doc = XDocument.Load(path);
}
catch(DirectoryNotFoundException)
{
project = null;
return false;
}
catch(FileNotFoundException)
{
project = null;
return false;
}
var nameNode = doc.XPathSelectElement(@"/x:Project/x:PropertyGroup/x:AssemblyName", NamespaceManager);
var projectInfoNode = doc.XPathSelectElement(ProjectInfoXPath, NamespaceManager);
XAttribute projectTypeAttribute = null;
if(projectInfoNode != null)
{
projectTypeAttribute = projectInfoNode.Attribute("Type");
}
if(nameNode == null)
{
project = null;
return false;
}
if(projectInfoNode != null)
{
var skippedNode = projectInfoNode.Attribute("Skip");
if(skippedNode != null && skippedNode.Value == "true")
{
project = null;
return false;
}
var type = projectTypeAttribute != null ? ProjectTypeHelper.Parse(projectTypeAttribute.Value) : ProjectType.Unknown;
project = type.CreateInstance(nameNode.Value, path);
}
else
{
project = new UnknownProject(nameNode.Value, path);
}
return project.TryLoad(doc);
}
