public async Task CheckPEReferencesSameAfterSolutionChangedTest()
{
using (var ws = new AdhocWorkspace())
{
var projectInfo = ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"TestProject",
"TestProject",
LanguageNames.CSharp,
metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)));
var project = ws.AddProject(projectInfo);
// get original references
var compilation1 = await project.GetCompilationAsync();
var references1 = compilation1.ExternalReferences;
// just some arbitary action to create new snpahost that doesnt affect references
var info = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "code.cs");
var document = ws.AddDocument(info);
// get new compilation
var compilation2 = await document.Project.GetCompilationAsync();
var references2 = compilation2.ExternalReferences;
Assert.Equal(references1, references2);
}
}
public void TestAddProject_NameAndLanguage()
{
using (var ws = new AdhocWorkspace())
{
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 async Task CreateSolutionSnapshotId_Project_Serialization()
{
var solution = new AdhocWorkspace().CurrentSolution;
var project = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
var snapshotService = (new SolutionChecksumServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionChecksumService;
using (var snapshot = await snapshotService.CreateChecksumAsync(project.Solution, CancellationToken.None).ConfigureAwait(false))
{
await VerifySnapshotSerializationAsync(snapshotService, solution, snapshot.SolutionChecksum).ConfigureAwait(false);
}
}
public void AcquireCompletionService()
{
var workspace = new AdhocWorkspace();
var document = workspace
.AddProject("TestProject", LanguageNames.CSharp)
.AddDocument("TestDocument.cs", "");
var service = CompletionService.GetService(document);
Assert.NotNull(service);
}
public void TestAddDocument_DocumentInfo()
{
using (var ws = new AdhocWorkspace())
{
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 async Task CheckCrossLanguageReferencesSameAfterSolutionChangedTest()
{
using var ws = new AdhocWorkspace();
var referenceInfo = ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"ReferenceProject",
"ReferenceProject",
LanguageNames.VisualBasic,
metadataReferences: ImmutableArray.Create <MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)));
var referenceProject = ws.AddProject(referenceInfo);
var projectInfo = ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"TestProject",
"TestProject",
LanguageNames.CSharp,
projectReferences: ImmutableArray.Create <ProjectReference>(new ProjectReference(referenceInfo.Id)),
metadataReferences: ImmutableArray.Create <MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)));
var project = ws.AddProject(projectInfo);
// get original references
var compilation1 = await project.GetCompilationAsync();
var references1 = compilation1.ExternalReferences;
// just some arbitrary action to create new snpahost that doesnt affect references
var info = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "code.cs");
var document = ws.AddDocument(info);
// get new compilation
var compilation2 = await document.Project.GetCompilationAsync();
var references2 = compilation2.ExternalReferences;
Assert.Equal(references1, references2);
}
public async Task UpdaterService()
{
var hostServices = s_composition.GetHostServices();
using var workspace = new AdhocWorkspace(hostServices);
var options = workspace.CurrentSolution.Options.WithChangedOption(
RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS,
1
);
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(options));
var listenerProvider = (
(IMefHostExportProvider)hostServices
).GetExportedValue <AsynchronousOperationListenerProvider>();
var checksumUpdater = new SolutionChecksumUpdater(
workspace,
listenerProvider,
CancellationToken.None
);
var service = workspace.Services.GetRequiredService <IRemoteHostClientProvider>();
// make sure client is ready
using var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);
// add solution, change document
workspace.AddSolution(
SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default)
);
var project = workspace.AddProject("proj", LanguageNames.CSharp);
var document = workspace.AddDocument(project.Id, "doc.cs", SourceText.From("code"));
workspace.ApplyTextChanges(
document.Id,
new[] { new TextChange(new TextSpan(0, 1), "abc") },
CancellationToken.None
);
// wait for listener
var workspaceListener = listenerProvider.GetWaiter(FeatureAttribute.Workspace);
await workspaceListener.ExpeditedWaitAsync();
var listener = listenerProvider.GetWaiter(FeatureAttribute.SolutionChecksumUpdater);
await listener.ExpeditedWaitAsync();
// checksum should already exist
Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out _));
checksumUpdater.Shutdown();
}
public void LinkedFiles()
{
// We want to assert that if the open document is linked into multiple projects, we
// update all documents at the same time with the changed text. Otherwise things will get
// out of sync.
var exportProvider = TestExportProvider.MinimumExportProviderFactoryWithCSharpAndVisualBasic.CreateExportProvider();
using var workspace = new AdhocWorkspace();
var textBufferFactoryService = exportProvider.GetExportedValue <ITextBufferFactoryService>();
var buffer = textBufferFactoryService.CreateTextBuffer("Hello", textBufferFactoryService.TextContentType);
var sourceTextContainer = buffer.AsTextContainer();
// We're going to add two projects that both consume the same file
const string FilePath = "Z:\\Foo.cs";
var documentIds = new List <DocumentId>();
for (var i = 0; i < 2; i++)
{
var projectId = workspace.AddProject($"Project{i}", LanguageNames.CSharp).Id;
var documentId = DocumentId.CreateNewId(projectId);
workspace.AddDocument(DocumentInfo.Create(documentId, "Foo.cs", filePath: FilePath));
workspace.OnDocumentOpened(documentId, sourceTextContainer);
documentIds.Add(documentId);
}
// Confirm the files have been linked by file path. This isn't the core part of this test but without it
// nothing else will work.
Assert.Equal(documentIds, workspace.CurrentSolution.GetDocumentIdsWithFilePath(FilePath));
Assert.Equal(new[] { documentIds.Last() }, workspace.CurrentSolution.GetDocument(documentIds.First()).GetLinkedDocumentIds());
// Now the core test: first, if we make a modified version of the source text, and attempt to get the document for it,
// both copies should be updated.
var originalSnapshot = buffer.CurrentSnapshot;
buffer.Insert(5, ", World!");
var newDocumentWithChanges = buffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges();
// Since we're calling this on the current snapshot and we observed the text edit synchronously,
// no forking actually should have happened.
Assert.Same(workspace.CurrentSolution, newDocumentWithChanges.Project.Solution);
Assert.Equal("Hello, World!", newDocumentWithChanges.GetTextSynchronously(CancellationToken.None).ToString());
Assert.Equal("Hello, World!", newDocumentWithChanges.GetLinkedDocuments().Single().GetTextSynchronously(CancellationToken.None).ToString());
// Now let's fetch back for the original snapshot. Both linked copies should be updated.
var originalDocumentWithChanges = originalSnapshot.GetOpenDocumentInCurrentContextWithChanges();
Assert.NotSame(workspace.CurrentSolution, originalDocumentWithChanges.Project.Solution);
Assert.Equal("Hello", originalDocumentWithChanges.GetTextSynchronously(CancellationToken.None).ToString());
Assert.Equal("Hello", originalDocumentWithChanges.GetLinkedDocuments().Single().GetTextSynchronously(CancellationToken.None).ToString());
}
public static Workspace Create(string text, string language = LanguageNames.CSharp)
{
var workspace = new AdhocWorkspace();
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "TestProject", "TestProject", language,
filePath: "D:\\Test.proj",
metadataReferences: new[] { s_corlibReference, s_systemCoreReference, s_systemReference });
Project project = workspace.AddProject(projectInfo);
workspace.AddDocument(project.Id, "TestDocument", SourceText.From(text));
return(workspace);
}
private async Task HighlightCSharpishAsync(RichTextBox rtf, string code)
{
code = code.Replace("\r\n", "\n");
var ws = new AdhocWorkspace();
var proj = ws.AddProject("Adhoc", "C#");
var doc = proj.AddDocument("decompiled.cs", code);
var start = 0;
var length = code.Length;
var res = await Classifier.GetClassifiedSpansAsync(doc, TextSpan.FromBounds(start, start + length));
Highlight(rtf, 0, res.ToArray());
}
public static Solution CreateSolution(string file)
{
var workspace = new AdhocWorkspace();
var project = workspace.AddProject("MethodTest", "C#");
foreach (var assembly in resolver.AndroidAssemblies)
{
project = project.AddMetadataReference(MetadataReference.CreateFromFile(assembly.Location));
}
var document = project.AddDocument("Class1.cs", file);
return(document.Project.Solution);
}
private static Project CreateEmptyProject()
{
var solution = new AdhocWorkspace(MefHostServices.Create(MefHostServices.DefaultAssemblies.Add(typeof(NoCompilationConstants).Assembly))).CurrentSolution;
return(solution.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject",
language: LanguageNames.CSharp,
parseOptions: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.Preview))).Projects.Single());
}
private static Document CreateDocument(string filename)
{
var workspace = new AdhocWorkspace();
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(projectId, versionStamp, "NewProject", "projName", LanguageNames.CSharp);
var newProject = workspace.AddProject(projectInfo);
var sourcePath = $@"..\..\..\{filename}";
var source = File.ReadAllText(sourcePath);
var sourceText = SourceText.From(source);
return(workspace.AddDocument(newProject.Id, filename, sourceText));
}
public TestHelper(string source)
{
Workspace = new AdhocWorkspace();
string projName = "NewProject";
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(projectId, versionStamp, projName, projName, LanguageNames.CSharp);
var newProject = Workspace.AddProject(projectInfo);
var sourceText = SourceText.From(source);
Document = Workspace.AddDocument(newProject.Id, "NewFile.cs", sourceText);
}
public static void InitWorkspace(AdhocWorkspace workspace, string code, int position)
{
string projName = "NewProject";
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var systemCore = MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location);
var references = new[] { mscorlib, systemCore };
var projectInfo = ProjectInfo.Create(projectId, versionStamp, projName, projName, LanguageNames.CSharp, metadataReferences: references);
var newProject = workspace.AddProject(projectInfo);
var sourceText = SourceText.From(code);
var newDocument = workspace.AddDocument(newProject.Id, "NewFile.cs", sourceText);
}
public static async Task ScanHardcodedFromText(string documentName, string text, Action <SyntaxNodeOrToken, string> scannedFunction)
{
if (text == null)
{
throw new ArgumentNullException("text");
}
AdhocWorkspace ws = new AdhocWorkspace();
var project = ws.AddProject(documentName + "Project", LanguageNames.CSharp);
ws.AddDocument(project.Id, documentName, SourceText.From(text));
await ScanHardcoded(ws, scannedFunction);
}
public async Task TestAddDocument_NameAndTextAsync()
{
using (var ws = new AdhocWorkspace())
{
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, (await doc.GetTextAsync()).ToString());
}
}
public void TestAddDocument_NameAndText()
{
using (var ws = new AdhocWorkspace())
{
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 static (Workspace workspace, Project project) CreateWorkspaceAndProject(string language)
{
var workspace = new AdhocWorkspace(ProxyGenerator.CreateHost());
var project = workspace.AddProject("code", language)
.WithCompilationOptions(language == LanguageNames.CSharp ?
(CompilationOptions) new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) :
(CompilationOptions) new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.WithMetadataReferences(ReferencePaths.Paths
.Select(path => MetadataReference.CreateFromFile(path)))
.AddMetadataReference(MetadataReference.CreateFromFile(Assembly.GetExecutingAssembly().ManifestModule.FullyQualifiedName));
return(workspace, project);
}
Microsoft.CodeAnalysis.Document GetAnalysisDocument(string text)
{
var workspace = new AdhocWorkspace();
string projectName = "TestProject";
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(projectId, versionStamp, projectName, projectName, LanguageNames.CSharp);
var sourceText = SourceText.From(text);
var project = workspace.AddProject(projectInfo);
return(workspace.AddDocument(project.Id, "Program.cs", sourceText));
}
private void Given_the_solution_has_projects()
{
// TODO: Generate random data.
_projs = new[] {
ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Default, "ProjectName", "ProjectName", "C#"),
ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Default, "ProjectName2", "ProjectName2", "C#")
};
foreach (var proj in _projs)
{
_workspace.AddProject(proj);
}
_sln = _workspace.CurrentSolution;
}
private static Document CreateDocumentWithoutText()
{
var project = ProjectInfo
.Create(ProjectId.CreateNewId(), VersionStamp.Default, "TestProject", "TestAssembly", LanguageNames.CSharp)
.WithFilePath("/TestProject.csproj");
var workspace = new AdhocWorkspace();
workspace.AddProject(project);
var documentInfo = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "Test.cshtml");
var document = workspace.AddDocument(documentInfo);
return(document);
}
public async Task does_not_trigger_completion(string code)
{
var hostServices = MefHostServices.Create(MefHostServices.DefaultAssemblies.Concat(
new[]
{
typeof(CompletionService).Assembly,
typeof(ResourceCompletionProvider).Assembly,
}));
var workspace = new AdhocWorkspace(hostServices);
var document = workspace
.AddProject("TestProject", LanguageNames.CSharp)
.WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.WithMetadataReferences(Directory
.EnumerateFiles("MonoAndroid", "*.dll")
.Select(dll => MetadataReference.CreateFromFile(dll)))
.AddDocument("Resource.designer.cs", @"[assembly: global::Android.Runtime.ResourceDesignerAttribute(""MyApp.Resource"", IsApplication=true)]
namespace MyApp
{
[System.CodeDom.Compiler.GeneratedCodeAttribute(""Xamarin.Android.Build.Tasks"", ""1.0.0.0"")]
public partial class Resource
{
public partial class String
{
public const int app_name = 2130968578;
public const int app_title = 2130968579;
}
public partial class Style
{
public const int AppTheme = 2131034114;
}
}
}")
.Project
.AddDocument("TestDocument.cs", code.Replace("`", ""));
var service = CompletionService.GetService(document);
Assert.NotNull(service);
var caret = code.IndexOf('`');
Assert.NotEqual(-1, caret);
var completions = await service.GetCompletionsAsync(document, caret);
if (completions != null)
{
Assert.DoesNotContain(completions.Items, x => x.Tags.Contains("Xamarin"));
}
}
public async Task <CompletionResult> CompleteAsync(string sourceCode, int position, char?triggerChar)
{
_CancellationTokenSource?.Cancel();
_CancellationTokenSource?.Dispose();
_CancellationTokenSource = new CancellationTokenSource();
try
{
var workspace = new AdhocWorkspace(_Host);
var projectInfo = ProjectInfo
.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "Project", "Project", LanguageNames.CSharp)
.WithMetadataReferences(new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) });
var project = workspace.AddProject(projectInfo);
var document = workspace.AddDocument(project.Id, "File.cs", SourceText.From(sourceCode));
var completionService = CompletionService.GetService(document);
var completionTrigger = GetCompletionTrigger(triggerChar);
var data = await completionService.GetCompletionsAsync(document, position, completionTrigger, null, null, _CancellationTokenSource.Token)
.ConfigureAwait(false);
if (data == null || data.Items == null)
{
return(new CompletionResult(Array.Empty <CompleteData>()));
}
var helper = CompletionHelper.GetHelper(document);
var text = await document.GetTextAsync(_CancellationTokenSource.Token).ConfigureAwait(false);
var textSpanToText = new Dictionary <TextSpan, string>();
var items =
data.Items
.Where(item => MatchesFilterText(helper, item, text, textSpanToText))
.OrderBy(x => x.DisplayText)
.Distinct(x => x.DisplayText)
.Select(x =>
new CompleteData(
x,
completionService,
document)
).ToArray();
return(new CompletionResult(items));
}
catch (OperationCanceledException)
{
return(new CompletionResult(Array.Empty <CompleteData>()));
}
}
public void InitialiseProject()
{
var host = MefHostServices.Create(MefHostServices.DefaultAssemblies);
Workspace = new AdhocWorkspace(host);
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "MyProject",
"MyProject",
LanguageNames.CSharp)
//isSubmission: true)
.WithCompilationOptions(new CSharpCompilationOptions(OutputKind.ConsoleApplication))
.WithMetadataReferences(AssemblyCache.Current.GetAllMetadataReferences());
Project = Workspace.AddProject(projectInfo);
}
public async Task TestStrongNameProviderEmpty()
{
using var workspace = new AdhocWorkspace();
using var remoteWorkspace = CreateRemoteWorkspace();
var filePath = "testLocation";
workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"test",
"test.dll",
LanguageNames.CSharp,
filePath: filePath,
outputFilePath: filePath
)
);
var assetProvider = await GetAssetProviderAsync(
workspace,
remoteWorkspace,
workspace.CurrentSolution
);
var solutionChecksum = await workspace.CurrentSolution.State.GetChecksumAsync(
CancellationToken.None
);
var solution = await remoteWorkspace.GetSolutionAsync(
assetProvider,
solutionChecksum,
fromPrimaryBranch : false,
workspaceVersion : -1,
CancellationToken.None
);
var compilationOptions = solution.Projects.First().CompilationOptions;
Assert.True(compilationOptions.StrongNameProvider is DesktopStrongNameProvider);
Assert.True(compilationOptions.XmlReferenceResolver is XmlFileResolver);
var array = new string[] { };
Assert.Equal(
Hash.CombineValues(array, StringComparer.Ordinal),
compilationOptions.StrongNameProvider.GetHashCode()
);
Assert.Null(((XmlFileResolver)compilationOptions.XmlReferenceResolver).BaseDirectory);
}
private Project CreateProject(AdhocWorkspace workspace, List <IDocumentExtender> documentExtenders)
{
var projectInfo = CommandLineProject.CreateProjectInfo(CscArgs.OutputFileName, "C#", Environment.CommandLine, _precompilationCommandLineArgs.BaseDirectory, workspace);
projectInfo = projectInfo
.WithCompilationOptions(CscArgs.CompilationOptions
.WithSourceReferenceResolver(new SourceFileResolver(CscArgs.SourcePaths, CscArgs.BaseDirectory, CscArgs.PathMap))) // required for path mapping support
.WithDocuments(
projectInfo
.Documents
.Select(d => documentExtenders.Aggregate(d, (doc, ex) => ex.Extend(doc))));
return(workspace.AddProject(projectInfo));
}
CreateAdHocLibraryProjectWorkspace(string classFileContets,
params MetadataReference[] references)
{
var referencesCopy = references.ToArray();
var resultWorkspace = new AdhocWorkspace();
Document document = resultWorkspace
.AddProject(ProjectName, LanguageNames.CSharp)
.AddMetadataReferences(references)
.AddDocument(ClassFileName, classFileContets);
return(resultWorkspace, document);
}
private Project CreateProject(AdhocWorkspace workspace)
{
var projectInfo = CommandLineProject.CreateProjectInfo(CscArgs.OutputFileName, "C#", Environment.CommandLine, _precompilationCommandLineArgs.BaseDirectory, workspace);
projectInfo = projectInfo
.WithDocuments(
projectInfo
.Documents
.Select(d => Path.GetExtension(d.FilePath) == ".cshtml"
? d.WithTextLoader(new RazorParser(this, d.TextLoader, workspace))
: d));
return(workspace.AddProject(projectInfo));
}
private static Document GetDocument(string code)
{
var ws = new AdhocWorkspace();
var emptyProject = ws.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Default,
"test",
"test.dll",
LanguageNames.CSharp,
metadataReferences: new[] { TestReferences.NetFx.v4_0_30319.mscorlib }));
return(emptyProject.AddDocument("test.cs", code));
}
public static List <SimplifiedClassificationSpan> GetClassifications(
string path, Project project, IReadOnlyList <SimplifiedClassificationInfo> infos = null)
{
using (var logger = LogManager.GetLogger("Test execution"))
{
path = Path.Combine(project.ProjectPath.GetDirectoryName(), path);
if (!File.Exists(path))
{
logger.Warn("File {0} doesn't exist.", path);
return(_empty);
}
var compilationUnits = ExtractCompilationUnits(project);
SemanticModel semanticModel = null;
ProgrammingLanguage language = default;
foreach (var unit in compilationUnits)
{
var roslynCompilation = unit.Compilation;
var syntaxTree = roslynCompilation.SyntaxTrees.FirstOrDefault(x => x.FilePath.EqualsNoCase(path));
if (!(syntaxTree is null))
{
semanticModel = roslynCompilation.GetSemanticModel(syntaxTree, true);
language = unit.Language;
break;
}
}
if (semanticModel is null)
{
logger.Warn("Project {0} doesn't have the file {1}. Check that it's included.", project.ProjectPath, path);
return(_empty);
}
List <ClassificationSpan> actualSpans = null;
// TODO: cache workspaces by project
using (var workspace = new AdhocWorkspace())
{
var buffer = new TextBuffer(GetContentType(language), new StringOperand(semanticModel.SyntaxTree.ToString()));
var snapshotSpan = new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length);
var newProject = workspace.AddProject(project.ProjectName, LanguageNames.CSharp);
var newDocument = workspace.AddDocument(newProject.Id, Path.GetFileName(path), snapshotSpan.Snapshot.AsText());
var classifier = GetClassifier(language, infos);
actualSpans = classifier.GetClassificationSpans(workspace, semanticModel, snapshotSpan);
}
return(actualSpans.Select(x => new SimplifiedClassificationSpan(x.Span.Span, x.ClassificationType)).ToList());
}
}
public async Task PublicOptions()
{
using var workspace = new AdhocWorkspace();
var csProject = workspace.AddProject("CS", LanguageNames.CSharp);
var vbProject = workspace.AddProject("VB", LanguageNames.VisualBasic);
var csDocument = workspace.AddDocument(csProject.Id, "File.cs", SourceText.From("class C { }"));
var vbDocument = workspace.AddDocument(vbProject.Id, "File.vb", SourceText.From("Class C : End Class"));
var updatedOptions = GetOptionSetWithChangedPublicOptions(workspace.CurrentSolution.Options);
// Validate that options are read from specified OptionSet:
ValidateCSharpOptions((CSharpSyntaxFormattingOptions)(await Formatter.GetOptionsAsync(csDocument, updatedOptions, CancellationToken.None)).Syntax !);
ValidateVisualBasicOptions((VisualBasicSyntaxFormattingOptions)(await Formatter.GetOptionsAsync(vbDocument, updatedOptions, CancellationToken.None)).Syntax !);
// Validate that options are read from solution snapshot as a fallback (we have no editorconfig file, so all options should fall back):
var solutionWithUpdatedOptions = workspace.CurrentSolution.WithOptions(updatedOptions);
var csDocumentWithUpdatedOptions = solutionWithUpdatedOptions.GetRequiredDocument(csDocument.Id);
var vbDocumentWithUpdatedOptions = solutionWithUpdatedOptions.GetRequiredDocument(vbDocument.Id);
ValidateCSharpOptions((CSharpSyntaxFormattingOptions)(await Formatter.GetOptionsAsync(csDocumentWithUpdatedOptions, optionSet: null, CancellationToken.None)).Syntax !);
ValidateVisualBasicOptions((VisualBasicSyntaxFormattingOptions)(await Formatter.GetOptionsAsync(vbDocumentWithUpdatedOptions, optionSet: null, CancellationToken.None)).Syntax !);
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));
}
static ValidateHelper()
{
//we have to build the trees of namespaces and classes for easy access for searching
var host = MefHostServices.Create(MefHostServices.DefaultAssemblies);
workspace = new AdhocWorkspace(host);
/*
* var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "MyProject", "MyProject", LanguageNames.CSharp);
* var project = workspace.AddProject(projectInfo);
* var document = workspace.AddDocument(project.Id, "MyFile.cs", SourceText.From(""));
*/
//var scriptCode = "Guid.N";
var compilationOptions = new CSharpCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
usings: new[] { "System", "System.Collections.Generic", "System.Text" });
var scriptProjectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "Script", "Script", LanguageNames.CSharp, isSubmission: false)
.WithMetadataReferences(new[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location)
})
.WithCompilationOptions(compilationOptions);
var scriptProject = workspace.AddProject(scriptProjectInfo);
project = scriptProject.Id;
/*
* scriptDocumentInfo = DocumentInfo.Create(
* DocumentId.CreateNewId(scriptProject.Id), "Script",
* sourceCodeKind: SourceCodeKind.Script,
* loader: TextLoader.From(TextAndVersion.Create(SourceText.From(scriptCode), VersionStamp.Create())));
* scriptDocument = workspace.AddDocument(scriptDocumentInfo);
*/
// cursor position is at the end
//var position = scriptCode.Length - 1;
//var completionService = CompletionService.GetService(scriptDocument);
//service = CompletionService.GetService(scriptDocument);
//var results = await completionService.GetCompletionsAsync(scriptDocument, position);
}
static void Main(string[] args)
{
#if DEBUG
args = new string[] { Directory.GetParent(Directory.GetParent(Directory.GetParent(Environment.CurrentDirectory).FullName).FullName).FullName };
args = new string[] { @"C:\Users\DvdKhl\Source\Repos\AVDump3" };
#endif
if (args.Length != 1 || !Directory.Exists(args[0]))
{
Console.WriteLine(args.Length == 1 ? "Directory not found" : "Argumentcount needs to be 1");
return;
}
var basePath = args[0];
if (basePath.EndsWith(Path.DirectorySeparatorChar.ToString()) || basePath.EndsWith(Path.AltDirectorySeparatorChar.ToString()))
{
basePath = basePath.Substring(0, basePath.Length - 1);
}
foreach (var filePath in Directory.EnumerateFiles(basePath, "*.cs", SearchOption.AllDirectories))
{
var fileContent = File.ReadAllText(filePath);
AdhocWorkspace workspace = new AdhocWorkspace();
Project project = workspace.AddProject(nameof(NamespaceDirectorySync), LanguageNames.CSharp);
Document document = project.AddDocument(Path.GetFileName(filePath), SourceText.From(fileContent));
var tree = document.GetSyntaxTreeAsync().Result;
var namespaces = tree.GetRoot().DescendantNodes().OfType <NamespaceDeclarationSyntax>().ToArray();
if (namespaces.Length != 1)
{
continue;
}
var destNamespace = Path.GetDirectoryName(filePath).Substring(basePath.Length)
.Replace(Path.DirectorySeparatorChar, '.').Replace(Path.AltDirectorySeparatorChar, '.');
if (destNamespace.StartsWith("."))
{
destNamespace = destNamespace.Substring(1);
}
fileContent = fileContent.Remove(namespaces[0].Name.SpanStart, namespaces[0].Name.Span.Length).Insert(namespaces[0].Name.SpanStart, destNamespace);
Console.WriteLine(filePath);
File.WriteAllText(filePath, fileContent);
}
}
/// <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="languageVersionCSharp">C# language version used for compiling the test project, required unless you inform the VB language version.</param>
/// <param name="languageVersionVB">VB language version used for compiling the test project, required unless you inform the C# language version.</param>
/// <returns>A Project created out of the Douments created from the source strings</returns>
public static Project CreateProject(string[] sources,
string language,
LanguageVersion languageVersionCSharp,
Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB)
{
var fileNamePrefix = DefaultFilePathPrefix;
string fileExt;
ParseOptions parseOptions;
if (language == LanguageNames.CSharp)
{
fileExt = CSharpDefaultFileExt;
parseOptions = new CSharpParseOptions(languageVersionCSharp);
}
else
{
fileExt = VisualBasicDefaultExt;
parseOptions = new Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions(languageVersionVB);
}
var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
#pragma warning disable CC0022
var workspace = new AdhocWorkspace();
#pragma warning restore CC0022
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), TestProjectName,
TestProjectName, language,
parseOptions: parseOptions,
metadataReferences: ImmutableList.Create(
CorlibReference, SystemCoreReference, RegexReference,
CSharpSymbolsReference, CodeAnalysisReference, JsonNetReference));
workspace.AddProject(projectInfo);
var count = 0;
foreach (var source in sources)
{
var newFileName = fileNamePrefix + count + "." + fileExt;
workspace.AddDocument(projectId, newFileName, SourceText.From(source));
count++;
}
var project = workspace.CurrentSolution.GetProject(projectId);
var newCompilationOptions = project.CompilationOptions.WithSpecificDiagnosticOptions(diagOptions);
var newSolution = workspace.CurrentSolution.WithProjectCompilationOptions(projectId, newCompilationOptions);
var newProject = newSolution.GetProject(projectId);
return(newProject);
}
private Solution GetSolution(params string[] sources)
{
var ws = new AdhocWorkspace();
var pid = ProjectId.CreateNewId();
var docs = sources.Select((s, i) =>
DocumentInfo.Create(
DocumentId.CreateNewId(pid),
name: "code" + i,
loader: TextLoader.From(TextAndVersion.Create(SourceText.From(s), VersionStamp.Default)))).ToList();
var proj = ProjectInfo.Create(pid, VersionStamp.Default, "test", "test.dll", LanguageNames.CSharp, documents: docs,
metadataReferences: new[] { TestReferences.NetFx.v4_0_30319.mscorlib });
return ws.AddProject(proj).Solution;
}
public async Task CreateSolutionSnapshotId_Project()
{
var solution = new AdhocWorkspace().CurrentSolution;
var project = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
var snapshotService = (new SolutionChecksumServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionChecksumService;
using (var snapshot = await snapshotService.CreateChecksumAsync(project.Solution, CancellationToken.None).ConfigureAwait(false))
{
var solutionId = snapshot.SolutionChecksum;
VerifyChecksumObjectInService(snapshotService, solutionId);
VerifyChecksumInService(snapshotService, solutionId.Info, WellKnownChecksumObjects.SolutionChecksumObjectInfo);
VerifyChecksumObjectInService(snapshotService, solutionId.Projects);
Assert.Equal(solutionId.Projects.Count, 1);
VerifySnapshotInService(snapshotService, solutionId.Projects.ToProjectObjects(snapshotService)[0], 0, 0, 0, 0, 0);
}
}
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 AdhocWorkspace())
{
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 AcquireCompletionService()
{
var hostServices = MefHostServices.Create(
MefHostServices.DefaultAssemblies.Concat(
new[]
{
typeof(CompletionService).Assembly,
typeof(CSharpCompletionService).Assembly
}));
var workspace = new AdhocWorkspace(hostServices);
var document = workspace
.AddProject("TestProject", LanguageNames.CSharp)
.AddDocument("TestDocument.cs", "");
var service = CompletionService.GetService(document);
Assert.NotNull(service);
}
public void TestUpdatedDocumentHasTextVersion()
{
var pid = ProjectId.CreateNewId();
var text = SourceText.From("public class C { }");
var version = VersionStamp.Create();
var docInfo = DocumentInfo.Create(DocumentId.CreateNewId(pid), "c.cs", loader: TextLoader.From(TextAndVersion.Create(text, version)));
var projInfo = ProjectInfo.Create(
pid,
version: VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject.dll",
language: LanguageNames.CSharp,
documents: new[] { docInfo });
using (var ws = new AdhocWorkspace())
{
ws.AddProject(projInfo);
SourceText currentText;
VersionStamp currentVersion;
var doc = ws.CurrentSolution.GetDocument(docInfo.Id);
Assert.Equal(false, doc.TryGetText(out currentText));
Assert.Equal(false, doc.TryGetTextVersion(out currentVersion));
// cause text to load and show that TryGet now works for text and version
currentText = doc.GetTextAsync().Result;
Assert.Equal(true, doc.TryGetText(out currentText));
Assert.Equal(true, doc.TryGetTextVersion(out currentVersion));
Assert.Equal(version, currentVersion);
// change document
var root = doc.GetSyntaxRootAsync().Result;
var newRoot = root.WithAdditionalAnnotations(new SyntaxAnnotation());
Assert.NotSame(root, newRoot);
var newDoc = doc.WithSyntaxRoot(newRoot);
Assert.NotSame(doc, newDoc);
// text is now unavailable since it must be constructed from tree
Assert.Equal(false, newDoc.TryGetText(out currentText));
// version is available because it is cached
Assert.Equal(true, newDoc.TryGetTextVersion(out currentVersion));
// access it the hard way
var actualVersion = newDoc.GetTextVersionAsync().Result;
// version is the same
Assert.Equal(currentVersion, actualVersion);
// accessing text version did not cause text to be constructed.
Assert.Equal(false, newDoc.TryGetText(out currentText));
// now access text directly (force it to be constructed)
var actualText = newDoc.GetTextAsync().Result;
actualVersion = newDoc.GetTextVersionAsync().Result;
// prove constructing text did not introduce a new version
Assert.Equal(currentVersion, actualVersion);
}
}
private static Document CreateDocument(string code, string language)
{
var solution = new AdhocWorkspace().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));
}
public async Task TestUpdateCSharpLanguageVersionAsync()
{
using (var ws = new AdhocWorkspace())
{
var projid = ws.AddProject("TestProject", LanguageNames.CSharp).Id;
var docid1 = ws.AddDocument(projid, "A.cs", SourceText.From("public class A { }")).Id;
var docid2 = ws.AddDocument(projid, "B.cs", SourceText.From("public class B { }")).Id;
var pws = new WorkspaceWithPartialSemantics(ws.CurrentSolution);
var proj = pws.CurrentSolution.GetProject(projid);
var comp = await proj.GetCompilationAsync();
// change language version
var parseOptions = proj.ParseOptions as CS.CSharpParseOptions;
pws.SetParseOptions(projid, parseOptions.WithLanguageVersion(CS.LanguageVersion.CSharp3));
// get partial semantics doc
var frozen = await pws.CurrentSolution.GetDocument(docid1).WithFrozenPartialSemanticsAsync(CancellationToken.None);
}
}
public async Task TestOpenFileOnlyAnalyzerDiagnostics()
{
var workspace = new AdhocWorkspace();
var project = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"CSharpProject",
"CSharpProject",
LanguageNames.CSharp));
var document = workspace.AddDocument(project.Id, "Empty.cs", SourceText.From(""));
// create listener/service/analyzer
var listener = new AsynchronousOperationListener();
var service = new MyDiagnosticAnalyzerService(new OpenFileOnlyAnalyzer(), listener);
var analyzer = service.CreateIncrementalAnalyzer(workspace);
// listen to events
service.DiagnosticsUpdated += (s, a) =>
{
if (workspace.IsDocumentOpen(a.DocumentId))
{
// check the diagnostics are reported
Assert.Equal(document.Id, a.DocumentId);
Assert.Equal(1, a.Diagnostics.Length);
Assert.Equal(OpenFileOnlyAnalyzer.s_syntaxRule.Id, a.Diagnostics[0].Id);
}
if (a.DocumentId == document.Id && !workspace.IsDocumentOpen(a.DocumentId))
{
// check the diagnostics reported are cleared
Assert.Equal(0, a.Diagnostics.Length);
}
};
// open document
workspace.OpenDocument(document.Id);
await analyzer.DocumentOpenAsync(document, CancellationToken.None).ConfigureAwait(false);
// cause analysis
await RunAllAnalysisAsync(analyzer, document).ConfigureAwait(false);
// close document
workspace.CloseDocument(document.Id);
await analyzer.DocumentCloseAsync(document, CancellationToken.None).ConfigureAwait(false);
await RunAllAnalysisAsync(analyzer, document).ConfigureAwait(false);
// wait for all events to raised
await listener.CreateWaitTask().ConfigureAwait(false);
}
private Document GetDocument(string code)
{
var ws = new AdhocWorkspace();
var project = ws.AddProject("project", LanguageNames.CSharp);
return project.AddDocument("code", SourceText.From(code));
}
public void TestOpenCloseAdditionalDocument()
{
var pid = ProjectId.CreateNewId();
var text = SourceText.From("public class C { }");
var version = VersionStamp.Create();
var docInfo = DocumentInfo.Create(DocumentId.CreateNewId(pid), "c.cs", loader: TextLoader.From(TextAndVersion.Create(text, version)));
var projInfo = ProjectInfo.Create(
pid,
version: VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject.dll",
language: LanguageNames.CSharp,
additionalDocuments: new[] { docInfo });
using (var ws = new AdhocWorkspace())
{
ws.AddProject(projInfo);
SourceText currentText;
VersionStamp currentVersion;
var doc = ws.CurrentSolution.GetAdditionalDocument(docInfo.Id);
Assert.Equal(false, doc.TryGetText(out currentText));
ws.OpenAdditionalDocument(docInfo.Id);
doc = ws.CurrentSolution.GetAdditionalDocument(docInfo.Id);
Assert.Equal(true, doc.TryGetText(out currentText));
Assert.Equal(true, doc.TryGetTextVersion(out currentVersion));
Assert.Same(text, currentText);
Assert.Equal(version, currentVersion);
ws.CloseAdditionalDocument(docInfo.Id);
doc = ws.CurrentSolution.GetAdditionalDocument(docInfo.Id);
Assert.Equal(false, doc.TryGetText(out currentText));
}
}
public void TestRemoveProject_TryApplyChanges()
{
var pid = ProjectId.CreateNewId();
var info = ProjectInfo.Create(
pid,
version: VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject.dll",
language: LanguageNames.CSharp);
using (var ws = new AdhocWorkspace())
{
ws.AddProject(info);
Assert.Equal(1, ws.CurrentSolution.Projects.Count());
var newSolution = ws.CurrentSolution.RemoveProject(pid);
Assert.Equal(0, newSolution.Projects.Count());
var result = ws.TryApplyChanges(newSolution);
Assert.Equal(true, result);
Assert.Equal(0, ws.CurrentSolution.Projects.Count());
}
}
private static Document GetDocumentFromIncompleteProject(AdhocWorkspace workspace)
{
var project = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"CSharpProject",
"CSharpProject",
LanguageNames.CSharp).WithHasAllInformation(hasAllInformation: false));
return workspace.AddDocument(project.Id, "Empty.cs", SourceText.From(""));
}
public async Task SnapshotWithMissingReferencesTest()
{
var hostServices = MefHostServices.Create(
MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly));
var solution = new AdhocWorkspace(hostServices).CurrentSolution;
var project1 = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
var metadata = new MissingMetadataReference();
var analyzer = new AnalyzerFileReference("missing_reference", new MissingAnalyzerLoader());
project1 = project1.AddMetadataReference(metadata);
project1 = project1.AddAnalyzerReference(analyzer);
var snapshotService = (new SolutionChecksumServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionChecksumService;
using (var snapshot = await snapshotService.CreateChecksumAsync(project1.Solution, CancellationToken.None).ConfigureAwait(false))
{
// this shouldn't throw
var recovered = await GetSolutionAsync(snapshotService, snapshot).ConfigureAwait(false);
}
}
public async Task UnknownLanguageTest()
{
var hostServices = MefHostServices.Create(MefHostServices.DefaultAssemblies.Add(typeof(NullLanguageService).Assembly));
var solution = new AdhocWorkspace(hostServices).CurrentSolution;
var project1 = solution.AddProject("Project", "Project.dll", NullLanguageService.TestLanguage);
var snapshotService = (new SolutionChecksumServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionChecksumService;
using (var snapshot = await snapshotService.CreateChecksumAsync(project1.Solution, CancellationToken.None).ConfigureAwait(false))
{
// this shouldn't throw
var recovered = await GetSolutionAsync(snapshotService, snapshot).ConfigureAwait(false);
}
}
public async Task CheckPEReferencesNotSameAfterReferenceChangedTest()
{
using (var ws = new AdhocWorkspace())
{
var projectInfo = ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"TestProject",
"TestProject",
LanguageNames.CSharp,
metadataReferences: ImmutableArray.Create<MetadataReference>(PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location)));
var project = ws.AddProject(projectInfo);
// get original references
var compilation1 = await project.GetCompilationAsync();
var references1 = compilation1.ExternalReferences;
// explicitly change references
var forkedProject = project.WithMetadataReferences(ImmutableArray.Create<MetadataReference>(
PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location),
PortableExecutableReference.CreateFromFile(typeof(Workspace).Assembly.Location)));
// get new compilation
var compilation2 = await forkedProject.GetCompilationAsync();
var references2 = compilation2.ExternalReferences;
Assert.NotEqual(references1, references2);
}
}
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 AdhocWorkspace())
{
var info = CommandLineProject.CreateProjectInfo("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;
}
}
public void CheckUpdatedDocumentTextIsObservablyConstant(AdhocWorkspace ws)
{
var pid = ProjectId.CreateNewId();
var text = SourceText.From("public class C { }");
var version = VersionStamp.Create();
var docInfo = DocumentInfo.Create(DocumentId.CreateNewId(pid), "c.cs", loader: TextLoader.From(TextAndVersion.Create(text, version)));
var projInfo = ProjectInfo.Create(
pid,
version: VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject.dll",
language: LanguageNames.CSharp,
documents: new[] { docInfo });
ws.AddProject(projInfo);
var doc = ws.CurrentSolution.GetDocument(docInfo.Id);
// change document
var root = doc.GetSyntaxRootAsync().Result;
var newRoot = root.WithAdditionalAnnotations(new SyntaxAnnotation());
Assert.NotSame(root, newRoot);
var newDoc = doc.Project.Solution.WithDocumentSyntaxRoot(doc.Id, newRoot).GetDocument(doc.Id);
Assert.NotSame(doc, newDoc);
var newDocText = newDoc.GetTextAsync().Result;
var sameText = newDoc.GetTextAsync().Result;
Assert.Same(newDocText, sameText);
var newDocTree = newDoc.GetSyntaxTreeAsync().Result;
var treeText = newDocTree.GetText();
Assert.Same(newDocText, treeText);
}
public async Task ExtractMethod_Argument2()
{
var solution = new AdhocWorkspace().CurrentSolution;
var projectId = ProjectId.CreateNewId();
var project = solution.AddProject(projectId, "Project", "Project.dll", LanguageNames.CSharp).GetProject(projectId);
var document = project.AddMetadataReference(TestReferences.NetFx.v4_0_30319.mscorlib)
.AddDocument("Document", SourceText.From(""));
var service = new CSharpExtractMethodService() as IExtractMethodService;
await service.ExtractMethodAsync(document, default(TextSpan));
}