public RedirectedPackage(Workspace workspace, Package parentPackage, DirectoryInfo directory)
: base(parentPackage.Name, parentPackage.Initializer, directory)
{
_parentPackage = parentPackage;
_redirectedDirectory = directory;
_workspace = workspace;
}
public async Task The_Compile_contract_for_compiling_code_has_not_been_broken()
{
var package = await Package.Copy(await Default.ConsoleWorkspace());
var viewport = ViewportCode();
var requestJson = new WorkspaceRequest(
new Workspace(
workspaceType: package.Name,
buffers: new[]
{
EntrypointCode(),
viewport
}),
activeBufferId: viewport.Id,
requestId: "TestRun");
var response = await CallCompile(requestJson.ToJson());
var result = await response.Content.ReadAsStringAsync();
var compileResult = result.FromJsonTo <CompileResult>();
compileResult.Base64Assembly.Should().NotBeNullOrWhiteSpace();
compileResult = new CompileResult(
compileResult.Succeeded,
"",
compileResult.GetFeature <Diagnostics>(),
compileResult.RequestId);
result = compileResult.ToJson().FormatJson();
this.Assent(result, configuration);
}
public async Task The_Run_contract_for_noncompiling_code_has_not_been_broken()
{
var package = await Package.Copy(await Default.ConsoleWorkspace());
var viewport = ViewportCode("doesn't compile");
var request = new WorkspaceRequest(
new Workspace(
workspaceType: package.Name,
buffers: new[]
{
EntrypointCode(),
viewport
}),
activeBufferId: viewport.Id,
requestId: "TestRun");
var requestBody = request.ToJson();
var response = await CallRun(requestBody);
var result = await response.Content.ReadAsStringAsync();
this.Assent(RemoveMachineSpecificPaths(result).FormatJson(), configuration);
}
protected override Workspace CreateWorkspaceWithMainContaining(string text, Package package)
{
return(Workspace.FromSource(
$@"using System; using System.Linq; using System.Collections.Generic; class Program {{ static void Main() {{ {text}
}}
}}
",
workspaceType: package.Name));
}
public static async Task <(Compilation compilation, IReadOnlyCollection <Document> documents)> GetCompilation(
this Package package,
IReadOnlyCollection <SourceFile> sources,
SourceCodeKind sourceCodeKind,
IEnumerable <string> defaultUsings,
Func <Task <Microsoft.CodeAnalysis.Workspace> > workspaceFactory,
Budget budget)
{
var workspace = await workspaceFactory();
var currentSolution = workspace.CurrentSolution;
var project = currentSolution.Projects.First();
var projectId = project.Id;
foreach (var source in sources)
{
if (currentSolution.Projects
.SelectMany(p => p.Documents)
.FirstOrDefault(d => d.IsMatch(source)) is Document document)
{
// there's a pre-existing document, so overwrite its contents
document = document.WithText(source.Text);
document = document.WithSourceCodeKind(sourceCodeKind);
currentSolution = document.Project.Solution;
}
else
{
var docId = DocumentId.CreateNewId(projectId, $"{package.Name}.Document");
currentSolution = currentSolution.AddDocument(docId, source.Name, source.Text);
currentSolution = currentSolution.WithDocumentSourceCodeKind(docId, sourceCodeKind);
}
}
project = currentSolution.GetProject(projectId);
var usings = defaultUsings?.ToArray() ?? Array.Empty <string>();
if (usings.Length > 0)
{
var options = (CSharpCompilationOptions)project.CompilationOptions;
project = project.WithCompilationOptions(options.WithUsings(usings));
}
var compilation = await project.GetCompilationAsync().CancelIfExceeds(budget);
return(compilation, project.Documents.ToArray());
}
public WebServer(Package package)
{
this.package = package ?? throw new ArgumentNullException(nameof(package));
_listeningAtUri = new AsyncLazy <Uri>(RunKestrel);
_getHttpClient = new AsyncLazy <HttpClient>(async() =>
{
var httpClient = new HttpClient
{
BaseAddress = await EnsureStarted()
};
return(httpClient);
});
}
public async Task The_run_contract_with_no_instrumentation_has_not_been_broken()
{
var package = await Package.Copy(await Default.ConsoleWorkspace());
var requestJson = new WorkspaceRequest(
new Workspace(
workspaceType: package.Name,
buffers: new[]
{
EntrypointCode("int a = 1; int b = 2; a = 3; b = a;")
},
includeInstrumentation: false),
requestId: "TestRun"
).ToJson();
var response = await CallRun(requestJson);
var result = await response.Content.ReadAsStringAsync();
this.Assent(RemoveMachineSpecificPaths(result).FormatJson(), configuration);
}
public static async Task <Compilation> Compile(
this Package package,
Workspace workspace,
Budget budget,
BufferId activeBufferId)
{
var sourceFiles = workspace.GetSourceFiles().ToArray();
var(compilation, documents) = await package.GetCompilationForRun(sourceFiles, SourceCodeKind.Regular, workspace.Usings, budget);
var viewports = workspace.ExtractViewPorts();
var diagnostics = compilation.GetDiagnostics();
if (workspace.IncludeInstrumentation && !diagnostics.ContainsError())
{
var activeDocument = GetActiveDocument(documents, activeBufferId);
compilation = await AugmentCompilationAsync(viewports, compilation, activeDocument, activeBufferId, package);
}
return(compilation);
}
public async Task The_signature_help_contract_has_not_been_broken()
{
var package = await Package.Copy(await Default.ConsoleWorkspace());
var viewport = ViewportCode("Console.Write($$);");
var requestJson = new WorkspaceRequest(
new Workspace(
workspaceType: package.Name,
buffers: new[]
{
EntrypointCode(),
viewport
}),
activeBufferId: viewport.Id,
requestId: "TestRun").ToJson();
var response = await CallSignatureHelp(requestJson);
var result = await response.Content.ReadAsStringAsync();
this.Assent(result.FormatJson(), configuration);
}
protected abstract Workspace CreateWorkspaceWithMainContaining(
string text,
Package package);
private static async Task <Compilation> AugmentCompilationAsync(
IEnumerable <Viewport> viewports,
Compilation compilation,
Document document,
BufferId activeBufferId,
Package build)
{
var regions = InstrumentationLineMapper.FilterActiveViewport(viewports, activeBufferId)
.Where(v => v.Destination?.Name != null)
.GroupBy(v => v.Destination.Name,
v => v.Region,
(name, region) => new InstrumentationMap(name, region))
.ToArray();
var solution = document.Project.Solution;
var newCompilation = compilation;
foreach (var tree in newCompilation.SyntaxTrees)
{
var replacementRegions = regions.FirstOrDefault(r => tree.FilePath.EndsWith(r.FileToInstrument))?.InstrumentationRegions;
var subdocument = solution.GetDocument(tree);
var visitor = new InstrumentationSyntaxVisitor(subdocument, await subdocument.GetSemanticModelAsync(), replacementRegions);
var linesWithInstrumentation = visitor.Augmentations.Data.Keys;
var activeViewport = viewports.DefaultIfEmpty(null).First();
var(augmentationMap, variableLocationMap) =
await InstrumentationLineMapper.MapLineLocationsRelativeToViewportAsync(
visitor.Augmentations,
visitor.VariableLocations,
document,
activeViewport);
var rewrite = new InstrumentationSyntaxRewriter(
linesWithInstrumentation,
variableLocationMap,
augmentationMap);
var newRoot = rewrite.Visit(tree.GetRoot());
var newTree = tree.WithRootAndOptions(newRoot, tree.Options);
newCompilation = newCompilation.ReplaceSyntaxTree(tree, newTree);
}
var instrumentationSyntaxTree = build.GetInstrumentationEmitterSyntaxTree();
newCompilation = newCompilation.AddSyntaxTrees(instrumentationSyntaxTree);
var augmentedDiagnostics = newCompilation.GetDiagnostics();
if (augmentedDiagnostics.ContainsError())
{
throw new InvalidOperationException(
$@"Augmented source failed to compile
Diagnostics
-----------
{string.Join(NewLine, augmentedDiagnostics)}
Source
------
{newCompilation.SyntaxTrees.Select(s => $"// {s.FilePath ?? "(anonymous)"}{NewLine}//---------------------------------{NewLine}{NewLine}{s}").Join(NewLine + NewLine)}");
}
return(newCompilation);
}
public static Task <(Compilation compilation, IReadOnlyCollection <Document> documents)> GetCompilationForRun(
this Package package,
IReadOnlyCollection <SourceFile> sources,
SourceCodeKind sourceCodeKind,
IEnumerable <string> defaultUsings,
Budget budget) =>
public async Task Get_documentation_with_signature_help_for_console_writeline()
{
#region bufferSources
var program = @"using System;
using System.Linq;
namespace FibonacciTest
{
public class Program
{
public static void Main()
{
foreach (var i in FibonacciGenerator.Fibonacci().Take(20))
{
Console.WriteLine(i);
}
}
}
}".EnforceLF();
var generator = @"using System.Collections.Generic;
using System;
namespace FibonacciTest
{
public static class FibonacciGenerator
{
public static IEnumerable<int> Fibonacci()
{
int current = 1, next = 1;
while (true)
{
yield return current;
next = current + (current = next);
Console.WriteLine($$);
}
}
}
}".EnforceLF();
#endregion
var(processed, position) = CodeManipulation.ProcessMarkup(generator);
var package = await Package.Copy(await Default.ConsoleWorkspace());
var workspace = new Workspace(workspaceType: package.Name, buffers: new[]
{
new Buffer("Program.cs", program),
new Buffer("generators/FibonacciGenerator.cs", processed, position)
});
var request = new WorkspaceRequest(workspace, activeBufferId: "generators/FibonacciGenerator.cs");
var server = GetLanguageService();
var result = await server.GetSignatureHelp(request);
result.Signatures.Should().NotBeNullOrEmpty();
var sample = result.Signatures.Where(e => e.Label == "void Console.WriteLine(string format, params object[] arg)").First();
sample.Documentation.Value.Should().Contain("Writes the text representation of the specified array of objects, followed by the current line terminator, to the standard output stream using the specified format information.");
sample.Parameters.Should().HaveCount(2);
sample.Parameters.ElementAt(0).Name.Should().Be("format");
sample.Parameters.ElementAt(0).Label.Should().Be("string format");
sample.Parameters.ElementAt(0).Documentation.Value.Should().Contain("A composite format string.");
sample.Parameters.ElementAt(1).Name.Should().Be("arg");
sample.Parameters.ElementAt(1).Label.Should().Be("params object[] arg");
sample.Parameters.ElementAt(1).Documentation.Value.Should().Contain("An array of objects to write using format.");
}
public async Task Get_documentation_with_autocompletion_of_console_methods()
{
#region bufferSources
var program = @"using System;
using System.Linq;
namespace FibonacciTest
{
public class Program
{
public static void Main()
{
foreach (var i in FibonacciGenerator.Fibonacci().Take(20))
{
Console.WriteLine(i);
}
}
}
}".EnforceLF();
var generator = @"using System.Collections.Generic;
using System;
namespace FibonacciTest
{
public static class FibonacciGenerator
{
public static IEnumerable<int> Fibonacci()
{
int current = 1, next = 1;
while (true)
{
yield return current;
next = current + (current = next);
Console.$$
}
}
}
}".EnforceLF();
#endregion
var package = await Package.Copy(await Default.ConsoleWorkspace());
var(processed, position) = CodeManipulation.ProcessMarkup(generator);
var workspace = new Workspace(workspaceType: package.Name, buffers: new[]
{
new Buffer("Program.cs", program),
new Buffer("generators/FibonacciGenerator.cs", processed, position)
});
var request = new WorkspaceRequest(workspace, activeBufferId: "generators/FibonacciGenerator.cs");
var server = GetLanguageService();
var result = await server.GetCompletionList(request);
result.Should().NotBeNull();
result.Items.Should().NotBeNullOrEmpty();
result.Items
.Where(i => i.Documentation != null && !string.IsNullOrWhiteSpace(i.Documentation.Value))
.Select(i => i.Documentation.Value)
.Should()
.Contain(d => d == "Writes the text representation of the specified Boolean value to the standard output stream.");
}