private Workspace CreateWorkspace(string[] sources, string language = LanguageNames.CSharp)
{
string fileExtension = language == LanguageNames.CSharp ? CSharpFileExtension : VBFileExtension;
var projectId = ProjectId.CreateNewId(TestProjectName);
var workspace = new AdhocWorkspace();
var solution = workspace
.CurrentSolution
.AddProject(projectId, TestProjectName, TestProjectName, language)
.AddMetadataReferences(projectId, GetSolutionMetadataReferences());
int count = 0;
foreach (var source in sources)
{
var fileName = FileNamePrefix + count + fileExtension;
var documentId = DocumentId.CreateNewId(projectId, fileName);
solution = solution.AddDocument(documentId, fileName, SourceText.From(source));
count++;
}
workspace.TryApplyChanges(solution);
return workspace;
}
/// <summary>
/// Creates a new P# project using the specified references.
/// </summary>
/// <param name="references">MetadataReferences</param>
/// <returns>Project</returns>
private Project CreateProject(ISet<MetadataReference> references)
{
var workspace = new AdhocWorkspace();
var solutionInfo = SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Create());
var solution = workspace.AddSolution(solutionInfo);
var project = workspace.AddProject("Test", "C#");
CompilationOptions options = null;
if (this.Configuration.OptimizationTarget == OptimizationTarget.Debug)
{
options = project.CompilationOptions.WithOptimizationLevel(OptimizationLevel.Debug);
}
else if (this.Configuration.OptimizationTarget == OptimizationTarget.Release)
{
options = project.CompilationOptions.WithOptimizationLevel(OptimizationLevel.Release);
}
project = project.WithCompilationOptions(options);
project = project.AddMetadataReferences(references);
workspace.TryApplyChanges(project.Solution);
return project;
}
public async Task TestGetInteriorSymbolsDoesNotCrashOnSpeculativeSemanticModel()
{
var markup = @"
class C
{
void foo()
{
System.Func<int> lambda = () =>
{
int x;
$$
}
}
}";
int position;
string text;
MarkupTestFile.GetPosition(markup, out text, out position);
var sourceText = SourceText.From(text);
var workspace = new AdhocWorkspace();
var project = workspace.AddProject("Test", LanguageNames.CSharp);
var document = workspace.AddDocument(project.Id, "testdocument", sourceText);
var firstModel = await document.GetSemanticModelAsync();
var tree1 = await document.GetSyntaxTreeAsync();
var basemethod1 = tree1.FindTokenOnLeftOfPosition(position, CancellationToken.None).GetAncestor<CSharp.Syntax.BaseMethodDeclarationSyntax>();
// Modify the document so we can use the old semantic model as a base.
var updated = sourceText.WithChanges(new TextChange(new TextSpan(position, 0), "insertion"));
workspace.TryApplyChanges(document.WithText(updated).Project.Solution);
document = workspace.CurrentSolution.GetDocument(document.Id);
var tree2 = await document.GetSyntaxTreeAsync();
var basemethod2 = tree2.FindTokenOnLeftOfPosition(position, CancellationToken.None).GetAncestor<CSharp.Syntax.BaseMethodDeclarationSyntax>();
var service = new CSharp.CSharpSemanticFactsService();
SemanticModel testModel;
var m = service.TryGetSpeculativeSemanticModel(firstModel, basemethod1, basemethod2, out testModel);
var xSymbol = testModel.LookupSymbols(position).First(s => s.Name == "x");
// This should not throw an exception.
Assert.NotNull(SymbolKey.Create(xSymbol));
}
public int Main(string[] args)
{
try
{
// how do dnu commands installs really work?
if (args.FirstOrDefault() == "RoslynLinqRewrite") args = args.Skip(1).ToArray();
NoRewrite = args.Contains("--norewrite");
ForProjBuild = args.Contains("--projbuild");
var posargs = args.Where(x => !x.StartsWith("-")).ToList();
if (posargs.Count >= 1)
{
WriteFiles = false;
var dir = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), posargs.First()));
if (Directory.Exists(dir) || Path.GetExtension(dir) == ".json")
{
#if false
CompileProjectJson(Directory.Exists(dir) ? Path.Combine(dir, "project.json") : dir);
#else
throw new Exception("Compiling project.json projects is not supported.");
#endif
}
else
{
CompileSolution(posargs.First(), posargs.ElementAtOrDefault(1));
}
}
return 0;
}
catch (ExitException ex)
{
return ex.Code;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return 1;
}
if (!args.Contains("--VisualStudio"))
{
Console.WriteLine("LinqRewrite <path-to-sln> [project-name]");
return 1;
}
if (true)
{
//CompileSolution(@"D:\Repositories\shaman-fizzler\Fizzler.sln", "Fizzler", false);
//CompileSolution(@"C:\Repositories\Awdee\Shaman.ApiServer.sln", "Shaman.Core", true);
CompileSolution(@"C:\Repositories\Awdee\Shaman.ApiServer.sln", "Shaman.Inferring.FullLogic");
return 0;
}
var code = @"
using System;
using System.Collections.Generic;
using System.Linq;
static class Meow
{
static void Main()
{
var sdfsdf = (new Exception()).RecursiveEnumeration(x => x.InnerException).Last();
var arr = new []{ 5, 457, 7464, 66 };
var arr2 = new []{ ""a"", ""b"" };
var capture = 5;
var meow = 2;
var k = arr2.Where(x => x.StartsWith(""t"")).Select(x=>x==""miao"").LastOrDefault();
//var k = arr.Where(x =>x > capture).Where(x =>x != 0).Select(x =>{return (double)x - 4;}).Where(x => x < 99).Any(x => x == 100);
// var ka = arr.Sum();
}
public static IEnumerable<T> RecursiveEnumeration<T>(this T first, Func<T, T> parent)
{
var current = first;
while (current != null)
{
yield return current;
current = parent(current);
}
}
}
";
//var syntaxTree = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(code);
#if !CORECLR
var workspace = new AdhocWorkspace();
var proj = workspace.AddProject("LinqRewriteExample", "C#").WithMetadataReferences(
new[] {
MetadataReference.CreateFromFile(typeof(int).GetTypeInfo().Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.Linq.Enumerable).GetTypeInfo().Assembly.Location),
}
).WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var doc = proj.AddDocument("source.cs", code);
if (!workspace.TryApplyChanges(doc.Project.Solution)) throw new Exception();
proj = doc.Project;
var comp = proj.GetCompilationAsync().Result;
var hasErrs = false;
foreach (var item in comp.GetDiagnostics())
{
if (item.Severity == DiagnosticSeverity.Error) hasErrs = true;
PrintDiagnostic(item);
}
if (hasErrs) return 1;
var syntaxTree = doc.GetSyntaxTreeAsync().Result;
var rewriter = new LinqRewriter(proj, comp.GetSemanticModel(syntaxTree), doc.Id);
var rewritten = rewriter.Visit(syntaxTree.GetRoot());
proj = doc.WithSyntaxRoot(rewritten).Project;
foreach (var item in proj.GetCompilationAsync().Result.GetDiagnostics())
{
PrintDiagnostic(item);
}
#endif
}