/// <summary>
/// Create a project using the inputted strings as sources.
/// </summary>
/// <param name="sources">Classes in the form of strings</param>
/// <param name="language">The language the source code is in</param>
/// <param name="solution">The created workspace containing the project</param>
/// <returns>A Project created out of the Douments created from the source strings</returns>
public static Project CreateProject(string[] sources,
out CustomWorkspace workspace, string language = LanguageNames.CSharp)
{
var fileNamePrefix = DefaultFilePathPrefix;
var fileExt = language == LanguageNames.CSharp ? CSharpDefaultFileExt : VisualBasicDefaultExt;
var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
workspace = new CustomWorkspace();
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), TestProjectName,
TestProjectName, language,
metadataReferences: ImmutableList.Create(
CorlibReference, SystemCoreReference, RegexReference,
CSharpSymbolsReference, CodeAnalysisReference, JsonNetReference));
workspace.AddProject(projectInfo);
const int count = 0;
foreach (var source in sources)
{
var newFileName = fileNamePrefix + count + "." + fileExt;
workspace.AddDocument(projectId, newFileName, SourceText.From(source));
}
var project = workspace.CurrentSolution.GetProject(projectId);
var newCompilationOptions = project.CompilationOptions.WithSpecificDiagnosticOptions(diagOptions);
var solution = workspace.CurrentSolution.WithProjectCompilationOptions(projectId, newCompilationOptions);
var newProject = solution.GetProject(projectId);
return(newProject);
}
public void TestAddProject_CommandLineProject()
{
CreateFiles(GetSimpleCSharpSolutionFiles());
string commandLine = @"CSharpClass.cs /out:foo.dll /target:library";
var baseDirectory = Path.Combine(this.SolutionDirectory.Path, "CSharpProject");
using (var ws = new CustomWorkspace())
{
var info = CommandLineProject.CreateProjectInfo(ws, "TestProject", LanguageNames.CSharp, commandLine, baseDirectory);
ws.AddProject(info);
var project = ws.CurrentSolution.GetProject(info.Id);
Assert.Equal("TestProject", project.Name);
Assert.Equal("foo", project.AssemblyName);
Assert.Equal(OutputKind.DynamicallyLinkedLibrary, project.CompilationOptions.OutputKind);
Assert.Equal(1, project.Documents.Count());
var fooDoc = project.Documents.First(d => d.Name == "CSharpClass.cs");
Assert.Equal(0, fooDoc.Folders.Count);
var expectedPath = Path.Combine(baseDirectory, "CSharpClass.cs");
Assert.Equal(expectedPath, fooDoc.FilePath);
var text = fooDoc.GetTextAsync().Result.ToString();
Assert.NotEqual("", text);
var tree = fooDoc.GetSyntaxRootAsync().Result;
Assert.Equal(false, tree.ContainsDiagnostics);
var compilation = project.GetCompilationAsync().Result;
}
}
private static Document CreateDocument(string code, string language)
{
var solution = new CustomWorkspace(SolutionId.CreateNewId("Solution")).CurrentSolution;
var projectId = ProjectId.CreateNewId();
var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);
return(project.AddDocument("Document", SourceText.From(code)));
}
private static Document CreateDocument(string code, string language)
{
var solution = new CustomWorkspace().CurrentSolution;
var projectId = ProjectId.CreateNewId();
var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);
return(project.AddMetadataReference(TestReferences.NetFx.v4_0_30319.mscorlib)
.AddDocument("Document", SourceText.From(code)));
}
private static Document CreateDocument(string code, string language)
{
var solution = new CustomWorkspace().CurrentSolution;
var projectId = ProjectId.CreateNewId();
var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);
return(project.AddMetadataReference(new MetadataFileReference(typeof(int).Assembly.Location))
.AddDocument("Document", SourceText.From(code)));
}
public void TestAddProject_NameAndLanguage()
{
using (var ws = new CustomWorkspace())
{
var project = ws.AddProject("TestProject", LanguageNames.CSharp);
Assert.Same(project, ws.CurrentSolution.Projects.FirstOrDefault());
Assert.Equal("TestProject", project.Name);
Assert.Equal(LanguageNames.CSharp, project.Language);
}
}
public void TestAddProject_NameAndLanguage()
{
using (var ws = new CustomWorkspace())
{
var project = ws.AddProject("TestProject", LanguageNames.CSharp);
Assert.Same(project, ws.CurrentSolution.Projects.FirstOrDefault());
Assert.Equal("TestProject", project.Name);
Assert.Equal(LanguageNames.CSharp, project.Language);
}
}
public void TestAddDocument_DocumentInfo()
{
using (var ws = new CustomWorkspace())
{
var project = ws.AddProject("TestProject", LanguageNames.CSharp);
var info = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "code.cs");
var doc = ws.AddDocument(info);
Assert.Equal(ws.CurrentSolution.GetDocument(info.Id), doc);
Assert.Equal(info.Name, doc.Name);
}
}
public void TestAddDocument_DocumentInfo()
{
using (var ws = new CustomWorkspace())
{
var project = ws.AddProject("TestProject", LanguageNames.CSharp);
var info = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "code.cs");
var doc = ws.AddDocument(info);
Assert.Equal(ws.CurrentSolution.GetDocument(info.Id), doc);
Assert.Equal(info.Name, doc.Name);
}
}
public void TestAddDocument_NameAndText()
{
using (var ws = new CustomWorkspace())
{
var project = ws.AddProject("TestProject", LanguageNames.CSharp);
var name = "code.cs";
var source = "class C {}";
var doc = ws.AddDocument(project.Id, name, SourceText.From(source));
Assert.Equal(name, doc.Name);
Assert.Equal(source, doc.GetTextAsync().Result.ToString());
}
}
public void TestAddDocument_NameAndText()
{
using (var ws = new CustomWorkspace())
{
var project = ws.AddProject("TestProject", LanguageNames.CSharp);
var name = "code.cs";
var source = "class C {}";
var doc = ws.AddDocument(project.Id, name, SourceText.From(source));
Assert.Equal(name, doc.Name);
Assert.Equal(source, doc.GetTextAsync().Result.ToString());
}
}
internal Tuple <int, Project> Add(ProjectViewModel project)
{
var pid = _workspace.AddProject(project.Name, "C#");
var proj = _workspace.CurrentSolution.GetProject(pid);
int id = Interlocked.Increment(ref _projectsIds);
if (!_contexts.TryAdd(id, project))
{
throw new Exception("Id already taken");
}
if (_host.IsConnected)
{
_host.InitProject(id, project.Path);
}
return(new Tuple <int, Project>(id, proj));
}
public void TestAddProject_ProjectInfo()
{
var info = ProjectInfo.Create(
ProjectId.CreateNewId(),
version: VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject.dll",
language: LanguageNames.CSharp);
using (var ws = new CustomWorkspace())
{
var project = ws.AddProject(info);
Assert.Equal(project, ws.CurrentSolution.Projects.FirstOrDefault());
Assert.Equal(info.Name, project.Name);
Assert.Equal(info.Id, project.Id);
Assert.Equal(info.AssemblyName, project.AssemblyName);
Assert.Equal(info.Language, project.Language);
}
}
public void TestAddProject_ProjectInfo()
{
var info = ProjectInfo.Create(
ProjectId.CreateNewId(),
version: VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject.dll",
language: LanguageNames.CSharp);
using (var ws = new CustomWorkspace())
{
var project = ws.AddProject(info);
Assert.Equal(project, ws.CurrentSolution.Projects.FirstOrDefault());
Assert.Equal(info.Name, project.Name);
Assert.Equal(info.Id, project.Id);
Assert.Equal(info.AssemblyName, project.AssemblyName);
Assert.Equal(info.Language, project.Language);
}
}
private static async Task Work(string[] args)
{
var text = File.ReadAllText(args[0]);
var workspace = new CustomWorkspace();
var project = workspace.AddProject("NameOfRewrite", LanguageNames.CSharp)
.WithMetadataReferences(new[] { MetadataReference.CreateFromAssembly(typeof(object).Assembly) });
var document = project.AddDocument("Test", SourceText.From(text));
project = document.Project;
var compilation = await project.GetCompilationAsync();
var argumentExceptionType = compilation.GetTypeByMetadataName("System.ArgumentException");
var root = await document.GetSyntaxRootAsync();
var rewriter = new NameOfRewriter(compilation.GetSemanticModel(root.SyntaxTree));
var node = rewriter.Visit(root);
Console.WriteLine(node.ToFullString());
}
public void TestLinkedFileSet(string startText, List<string> updatedTexts, string expectedMergedText, string languageName)
{
using (var workspace = new CustomWorkspace())
{
var solution = new CustomWorkspace().CurrentSolution;
var startSourceText = SourceText.From(startText);
var documentIds = new List<DocumentId>();
for (int i = 0; i < updatedTexts.Count; i++)
{
var projectId = ProjectId.CreateNewId();
var documentId = DocumentId.CreateNewId(projectId);
documentIds.Add(documentId);
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), "ProjectName" + i, "AssemblyName" + i, languageName);
solution = solution
.AddProject(projectInfo)
.AddDocument(documentId, "DocumentName", startSourceText, filePath: "FilePath");
}
var startingSolution = solution;
var updatedSolution = solution;
for (int i = 0; i < updatedTexts.Count; i++)
{
var text = updatedTexts[i];
if (text != startText)
{
updatedSolution = updatedSolution
.WithDocumentText(documentIds[i], SourceText.From(text));
}
}
var mergedSolution = updatedSolution.WithMergedLinkedFileChangesAsync(startingSolution).Result;
for (int i = 0; i < updatedTexts.Count; i++)
{
Assert.Equal(expectedMergedText, mergedSolution.GetDocument(documentIds[i]).GetTextAsync().Result.ToString());
}
}
}
public void TestLinkedFileSet(string startText, List <string> updatedTexts, string expectedMergedText, string languageName)
{
using (var workspace = new CustomWorkspace())
{
var solution = new CustomWorkspace().CurrentSolution;
var startSourceText = SourceText.From(startText);
var documentIds = new List <DocumentId>();
for (int i = 0; i < updatedTexts.Count; i++)
{
var projectId = ProjectId.CreateNewId();
var documentId = DocumentId.CreateNewId(projectId);
documentIds.Add(documentId);
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), "ProjectName" + i, "AssemblyName" + i, languageName);
solution = solution
.AddProject(projectInfo)
.AddDocument(documentId, "DocumentName", startSourceText, filePath: "FilePath");
}
var startingSolution = solution;
var updatedSolution = solution;
for (int i = 0; i < updatedTexts.Count; i++)
{
var text = updatedTexts[i];
if (text != startText)
{
updatedSolution = updatedSolution
.WithDocumentText(documentIds[i], SourceText.From(text));
}
}
var mergedSolution = updatedSolution.WithMergedLinkedFileChangesAsync(startingSolution).Result;
for (int i = 0; i < updatedTexts.Count; i++)
{
Assert.Equal(expectedMergedText, mergedSolution.GetDocument(documentIds[i]).GetTextAsync().Result.ToString());
}
}
}
public void TestAddProject_CommandLineProject()
{
CreateFiles(GetSimpleCSharpSolutionFiles());
string commandLine = @"CSharpClass.cs /out:foo.dll /target:library";
var baseDirectory = Path.Combine(this.SolutionDirectory.Path, "CSharpProject");
using (var ws = new CustomWorkspace())
{
var info = CommandLineProject.CreateProjectInfo(ws, "TestProject", LanguageNames.CSharp, commandLine, baseDirectory);
ws.AddProject(info);
var project = ws.CurrentSolution.GetProject(info.Id);
Assert.Equal("TestProject", project.Name);
Assert.Equal("foo", project.AssemblyName);
Assert.Equal(OutputKind.DynamicallyLinkedLibrary, project.CompilationOptions.OutputKind);
Assert.Equal(1, project.Documents.Count());
var fooDoc = project.Documents.First(d => d.Name == "CSharpClass.cs");
Assert.Equal(0, fooDoc.Folders.Count);
var expectedPath = Path.Combine(baseDirectory, "CSharpClass.cs");
Assert.Equal(expectedPath, fooDoc.FilePath);
var text = fooDoc.GetTextAsync().Result.ToString();
Assert.NotEqual("", text);
var tree = fooDoc.GetSyntaxRootAsync().Result;
Assert.Equal(false, tree.ContainsDiagnostics);
var compilation = project.GetCompilationAsync().Result;
}
}
