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); }