static WorkspaceServices() { if (Environment.GetEnvironmentVariable("DEBUG_AVATAR") == "1") Debugger.Break(); HostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Concat(new[] { // Avatar.dll typeof(IAvatar).Assembly, // Avatar.CodeAnalysis.dll typeof(NamingConvention).Assembly, // Avatar.StaticProxy.dll typeof(AvatarGenerator).Assembly, })); }
public async Task CreateSolutionSnapshotId_Full_Asset_Serialization_Desktop() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); using var workspace = new AdhocWorkspace(hostServices); var solution = CreateFullSolution(workspace); var validator = new SerializationValidator(workspace.Services); using var snapshot = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false); var solutionObject = await validator.GetValueAsync <SolutionStateChecksums>(snapshot.SolutionChecksum); await validator.VerifyAssetAsync(solutionObject).ConfigureAwait(false); }
public async Task RoundTrip_Analyzer_Serailization_Desktop_Test() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); var workspace = new AdhocWorkspace(hostServices); var serializer = new Serializer(workspace); var reference = new AnalyzerFileReference(typeof(object).Assembly.Location, new MockShadowCopyAnalyzerAssemblyLoader()); // make sure this doesn't throw var assetFromFile = SolutionAsset.Create(serializer.CreateChecksum(reference, CancellationToken.None), reference, serializer); var assetFromStorage = await CloneAssetAsync(serializer, assetFromFile).ConfigureAwait(false); var assetFromStorage2 = await CloneAssetAsync(serializer, assetFromStorage).ConfigureAwait(false); }
public async Task Missing_Analyzer_Serailization_Desktop_Test() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); var workspace = new AdhocWorkspace(hostServices); var serializer = workspace.Services.GetService <ISerializerService>(); var reference = new AnalyzerFileReference("missing_reference", new MissingAnalyzerLoader()); // make sure this doesn't throw var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference, serializer); var assetFromStorage = await CloneAssetAsync(serializer, assetFromFile).ConfigureAwait(false); await CloneAssetAsync(serializer, assetFromStorage).ConfigureAwait(false); }
protected void CoreInit() { StaticInit(); CompositionHost compositionContext = new ContainerConfiguration() .WithAssemblies(MefHostServices.DefaultAssemblies) .CreateContainer(); _host = MefHostServices.Create(compositionContext); TheWorkspace = new RoslynWorkspaceBase(_host, "Generated"); TheProjId = ProjectId.CreateNewId(ProjName); AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve; }
static WorkspaceHacks() { var assemblyNames = new[] { "Microsoft.CodeAnalysis.Workspaces", "Microsoft.CodeAnalysis.Workspaces.Desktop", "Microsoft.CodeAnalysis.CSharp.Workspaces", "Microsoft.CodeAnalysis.VisualBasic.Workspaces", "Microsoft.CodeAnalysis.Features", "Microsoft.CodeAnalysis.CSharp.Features", "Microsoft.CodeAnalysis.VisualBasic.Features" }; var assemblies = assemblyNames .Select(n => Assembly.Load(n)); Pack = MefHostServices.Create(assemblies); }
static MefHostServices CreateDefaultServices() { var asms = new HashSet <Assembly>(MefHostServices.DefaultAssemblies); var version = typeof(Compilation).Assembly.GetName().Version; foreach (var asmNameTmp in otherAssemblies) { var asmName = string.Format(asmNameTmp, version); try { asms.Add(Assembly.Load(asmName)); } catch { Debug.Fail($"Couldn't load Roslyn MEF assembly: {asmName}"); } } return(MefHostServices.Create(asms)); }
private async Task <EmitResult> WhenTheSourceCodeIsCompiled( string sourceCode, string outputAssembly, [CallerMemberName] string compilationAssemblyName = "TestCompilation") { var host = MefHostServices.Create(MefHostServices.DefaultAssemblies); var frameworkLocation = Path.GetDirectoryName(typeof(object).Assembly.Location) !; var projectInfo = ProjectInfo.Create( ProjectId.CreateNewId(), VersionStamp.Create(), compilationAssemblyName, compilationAssemblyName, LanguageNames.CSharp ) .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) .WithNullableContextOptions(NullableContextOptions.Enable)) .WithParseOptions(new CSharpParseOptions(LanguageVersion.Latest)) .WithMetadataReferences(new[] { //framework assemblies MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(Path.Combine(frameworkLocation, "netstandard.dll")), MetadataReference.CreateFromFile(Path.Combine(frameworkLocation, "System.Runtime.dll")), //project dependencies assemblies MetadataReference.CreateFromFile(typeof(DataContractAttribute).Assembly.Location), MetadataReference.CreateFromFile(typeof(Cache <,>).Assembly.Location) }) .WithAnalyzerReferences(new[] { //our generator new AnalyzerFileReference( typeof(DbQueryGenerator).Assembly.Location, new DbQueryGeneratorAnalyzerLoader()) }); var compilation = await new AdhocWorkspace(host) .CurrentSolution .AddProject(projectInfo) .AddDocument( documentId: DocumentId.CreateNewId(projectInfo.Id, compilationAssemblyName + ".cs"), name: compilationAssemblyName + ".cs", text: SourceText.From(sourceCode, Encoding.UTF8)) .GetProject(projectInfo.Id) ! .GetCompilationAsync(); return(compilation !.Emit(outputAssembly)); }
public RoslynHost(NuGetConfiguration nuGetConfiguration = null, IEnumerable <Assembly> additionalAssemblies = null) { _nuGetConfiguration = nuGetConfiguration; _workspaces = new ConcurrentDictionary <DocumentId, RoslynWorkspace>(); _diagnosticsUpdatedNotifiers = new ConcurrentDictionary <DocumentId, Action <DiagnosticsUpdatedArgs> >(); var assemblies = new[] { Assembly.Load("Microsoft.CodeAnalysis"), Assembly.Load("Microsoft.CodeAnalysis.CSharp"), Assembly.Load("Microsoft.CodeAnalysis.Features"), Assembly.Load("Microsoft.CodeAnalysis.CSharp.Features"), typeof(RoslynHost).Assembly, }; if (additionalAssemblies != null) { assemblies = assemblies.Concat(additionalAssemblies).ToArray(); } var partTypes = MefHostServices.DefaultAssemblies.Concat(assemblies) .Distinct() .SelectMany(x => x.GetTypes()) .Concat(new[] { typeof(Microsoft.CodeAnalysis.CodeFixes.CodeFixService) }) .Concat(new[] { typeof(DocumentationProviderServiceFactory) }) .ToArray(); _compositionContext = new ContainerConfiguration() .WithParts(partTypes) .WithDefaultConventions(new AttributeFilterProvider()) .CreateContainer(); _host = MefHostServices.Create(_compositionContext); _parseOptions = new CSharpParseOptions(kind: SourceCodeKind.Script, preprocessorSymbols: PreprocessorSymbols); _referenceAssembliesPath = GetReferenceAssembliesPath(); _documentationProviderService = new DocumentationProviderServiceFactory.DocumentationProviderService(); DefaultReferences = _defaultReferenceAssemblies.Select(t => CreateMetadataReference(t.Location)).ToImmutableArray(); DefaultImports = _defaultReferenceAssemblyTypes.Select(x => x.Namespace).Distinct().ToImmutableArray(); GetService <IDiagnosticService>().DiagnosticsUpdated += OnDiagnosticsUpdated; }
public async Task <CompletionList> GetCompletions(string code, IEnumerable <string> imports) { // not sure why but adding extra character at end fixes auto completion when tab complete after '.' var extraChar = code.LastOrDefault(); var modifiedCode = $"{code}{extraChar}"; // based on: https://www.strathweb.com/2018/12/using-roslyn-c-completion-service-programmatically/ var host = MefHostServices.Create(MefHostServices.DefaultAssemblies); var workspace = new AdhocWorkspace(host); var compilationOptions = new CSharpCompilationOptions( OutputKind.DynamicallyLinkedLibrary, usings: imports); var scriptProjectInfo = ProjectInfo.Create( ProjectId.CreateNewId(), VersionStamp.Create(), "Script", "Script", LanguageNames.CSharp, isSubmission: true) .WithMetadataReferences(new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) }) .WithCompilationOptions(compilationOptions); var scriptProject = workspace.AddProject(scriptProjectInfo); var scriptDocumentInfo = DocumentInfo.Create( DocumentId.CreateNewId(scriptProject.Id), "Script", sourceCodeKind: SourceCodeKind.Script, loader: TextLoader.From(TextAndVersion.Create(SourceText.From(modifiedCode), VersionStamp.Create()))); var scriptDocument = workspace.AddDocument(scriptDocumentInfo); var position = modifiedCode.Length - 1; var completionService = CompletionService.GetService(scriptDocument); var results = await completionService.GetCompletionsAsync(scriptDocument, position); return(results ?? CompletionList.Empty); }
public async Task MetadataReference_RoundTrip_Test() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); var workspace = new AdhocWorkspace(hostServices); var reference = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var serializer = new Serializer(workspace.Services); var trees = new ChecksumTreeCollection(); var assetBuilder = new AssetBuilder(trees.CreateRootTreeNode(workspace.CurrentSolution.State)); var assetFromFile = assetBuilder.Build(reference, CancellationToken.None); var assetFromStorage = await CloneAssetAsync(serializer, assetBuilder, assetFromFile).ConfigureAwait(false); var assetFromStorage2 = await CloneAssetAsync(serializer, assetBuilder, assetFromStorage).ConfigureAwait(false); }
public async Task ShadowCopied_Analyzer_Serailization_Desktop_Test() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); using var tempRoot = new TempRoot(); using var workspace = new AdhocWorkspace(hostServices); var reference = CreateShadowCopiedAnalyzerReference(tempRoot); var serializer = workspace.Services.GetService <ISerializerService>(); // make sure this doesn't throw var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference, serializer); // this will verify serialized analyzer reference return same checksum as the original one var assetFromStorage = await CloneAssetAsync(serializer, assetFromFile).ConfigureAwait(false); }
protected RoslynLanguageBase( string name, string featuresAssemblyName, string workspacesAssemblyName, IRoslynLanguageOptions options ) { Name = name; _hostServices = CreateHostServices(featuresAssemblyName, workspacesAssemblyName); _options = options; _codeFixProvidersIndexedByDiagnosticIds = CreateDefaultCodeFixProvidersSlow(); _analyzers = ImmutableArray.CreateRange( _options.AnalyzerReferences.SelectMany(r => r.GetAnalyzers(Name)) ); _defaultSignatureHelpProviders = CreateDefaultSignatureHelpProvidersSlow(); }
static async Task Main(string[] args) { var host = MefHostServices.Create(MefHostServices.DefaultAssemblies); var workspace = new AdhocWorkspace(host); var code = @"using System; public class MyClass { public static void MyMethod(int value) { Guid. } }"; var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "MyProject", "MyProject", LanguageNames.CSharp). WithMetadataReferences(new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) }); var project = workspace.AddProject(projectInfo); var document = workspace.AddDocument(project.Id, "MyFile.cs", SourceText.From(code)); var position = code.LastIndexOf("Guid.") + 5; var completionService = CompletionService.GetService(document); var results = await completionService.GetCompletionsAsync(document, position); foreach (var i in results.Items) { Console.WriteLine(i.DisplayText); foreach (var prop in i.Properties) { Console.Write($"{prop.Key}:{prop.Value} "); } Console.WriteLine(); foreach (var tag in i.Tags) { Console.Write($"{tag} "); } Console.WriteLine(); Console.WriteLine(); } }
public static async Task <List <string> > Run(string script, int position) { var assemblies = new[] { Assembly.Load("Microsoft.CodeAnalysis"), Assembly.Load("Microsoft.CodeAnalysis.CSharp"), Assembly.Load("Microsoft.CodeAnalysis.Features"), Assembly.Load("Microsoft.CodeAnalysis.CSharp.Features"), }; var parts = MefHostServices.DefaultAssemblies.Concat(assemblies) .Distinct() .SelectMany(x => x.GetTypes()) .ToArray(); var ctx = new ContainerConfiguration() .WithParts(parts) .CreateContainer(); var host = MefHostServices.Create(ctx); var workspace = new AdhocWorkspace(host); var compilationOptions = new CSharpCompilationOptions( OutputKind.DynamicallyLinkedLibrary, usings: new[] { "System", "CoreFunctions", "Microsoft.AspNetCore.Http", "System.Net" }); var scriptProjectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "Script", "Script", LanguageNames.CSharp, isSubmission: true) .WithMetadataReferences(new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) }) .WithCompilationOptions(compilationOptions); var scriptProject = workspace.AddProject(scriptProjectInfo); var scriptDocumentInfo = DocumentInfo.Create( DocumentId.CreateNewId(scriptProject.Id), "Script", sourceCodeKind: SourceCodeKind.Script, loader: TextLoader.From( TextAndVersion.Create(SourceText.From(script), VersionStamp.Create()))); var scriptDocument = workspace.AddDocument(scriptDocumentInfo); var compiler = CompletionService.GetService(scriptDocument); return((await compiler.GetCompletionsAsync(scriptDocument, position)) .Items .Select(c => c.DisplayText).ToList()); }
public void TestEncodingSerialization() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); var workspace = new AdhocWorkspace(hostServices); var serializer = new Serializer(workspace); // test with right serializable encoding var sourceText = SourceText.From("Hello", Encoding.UTF8); using (var stream = SerializableBytes.CreateWritableStream()) { using (var objectWriter = new ObjectWriter(stream)) { serializer.Serialize(sourceText, objectWriter, CancellationToken.None); } stream.Position = 0; using (var objectReader = ObjectReader.TryGetReader(stream)) { var newText = serializer.Deserialize <SourceText>(sourceText.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None); Assert.Equal(sourceText.ToString(), newText.ToString()); } } // test with wrong encoding that doesn't support serialization sourceText = SourceText.From("Hello", new NotSerializableEncoding()); using (var stream = SerializableBytes.CreateWritableStream()) { using (var objectWriter = new ObjectWriter(stream)) { serializer.Serialize(sourceText, objectWriter, CancellationToken.None); } stream.Position = 0; using (var objectReader = ObjectReader.TryGetReader(stream)) { var newText = serializer.Deserialize <SourceText>(sourceText.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None); Assert.Equal(sourceText.ToString(), newText.ToString()); } } }
async static Task Main(string[] args) { var code = @"using System; public class MyClass { public static void MyMethod(int value) { } }"; var host = MefHostServices.Create(MefHostServices.DefaultAssemblies); var workspace = new AdhocWorkspace(host); var souceText = SourceText.From(code); // with a project var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "MyProject", "MyProject", LanguageNames.CSharp). WithMetadataReferences(new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) }); var project = workspace.AddProject(projectInfo); var document = workspace.AddDocument(project.Id, "MyFile.cs", souceText); var classifiedSpans = await Classifier.GetClassifiedSpansAsync(document, new TextSpan(0, code.Length)); foreach (var classifiedSpan in classifiedSpans.Where(s => !ClassificationTypeNames.AdditiveTypeNames.Contains(s.ClassificationType))) { var position = souceText.Lines.GetLinePositionSpan(classifiedSpan.TextSpan); Console.WriteLine($"{souceText.ToString(classifiedSpan.TextSpan)} - {classifiedSpan.ClassificationType} - {position.Start}:{position.End}"); } // with semantic model var syntaxTree = CSharpSyntaxTree.ParseText(souceText); var compilation = CSharpCompilation.Create("Dummy").AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)).AddSyntaxTrees(syntaxTree); var semanticModel = compilation.GetSemanticModel(syntaxTree); classifiedSpans = Classifier.GetClassifiedSpans(semanticModel, new TextSpan(0, code.Length), workspace); foreach (var classifiedSpan in classifiedSpans.Where(s => !ClassificationTypeNames.AdditiveTypeNames.Contains(s.ClassificationType))) { var position = souceText.Lines.GetLinePositionSpan(classifiedSpan.TextSpan); Console.WriteLine($"{souceText.ToString(classifiedSpan.TextSpan)} - {classifiedSpan.ClassificationType} - {position.Start}:{position.End}"); } Console.ReadLine(); }
public CompletionProvider(ScriptCs.ScriptServices service, ICSharpCode.AvalonEdit.Document.TextDocument text) { _simp = new SimpleCompletionProvider(service, text); var currentPath = Assembly.GetExecutingAssembly().Location; currentPath = Path.GetDirectoryName(currentPath); var f1 = Path.Combine(currentPath, "Microsoft.CodeAnalysis.Features.dll"); var f2 = Path.Combine(currentPath, "Microsoft.CodeAnalysis.CSharp.Features"); var f3 = Path.Combine(currentPath, "Microsoft.CodeAnalysis.Workspaces.Desktop"); if (!File.Exists(f1)) { File.WriteAllBytes(f1, Resources.Microsoft_CodeAnalysis_Features); } if (!File.Exists(f2)) { File.WriteAllBytes(f2, Resources.Microsoft_CodeAnalysis_CSharp_Features); } if (!File.Exists(f3)) { File.WriteAllBytes(f3, Resources.Microsoft_CodeAnalysis_Workspaces_Desktop); } _host = MefHostServices.Create(MefHostServices.DefaultAssemblies.Concat(new[] { Assembly.LoadFrom(f1), Assembly.LoadFrom(f2) })); _ws = new InteractiveWorkspace(_host); _parseOptions = new CSharpParseOptions(kind: SourceCodeKind.Interactive); _references = _assemblyTypes.Select(t => MetadataReference.CreateFromAssembly(t.Assembly)).ToArray(); _compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, usings: _assemblyTypes.Select(x => x.Namespace).ToImmutableArray()); var container = new CompositionContainer(new AssemblyCatalog(typeof(ISignatureHelpProvider).Assembly), CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe); _signatureHelpProviders = container.GetExportedValues <ISignatureHelpProvider>().ToArray(); }
public async Task Missing_Analyzer_Serailization_Desktop_Test() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); var workspace = new AdhocWorkspace(hostServices); var reference = new AnalyzerFileReference("missing_reference", new MissingAnalyzerLoader()); var serializer = new Serializer(workspace.Services); var trees = new ChecksumTreeCollection(); var assetBuilder = new AssetBuilder(trees.CreateRootTreeNode(workspace.CurrentSolution.State)); // make sure this doesn't throw var assetFromFile = assetBuilder.Build(reference, CancellationToken.None); var assetFromStorage = await CloneAssetAsync(serializer, assetBuilder, assetFromFile).ConfigureAwait(false); var assetFromStorage2 = await CloneAssetAsync(serializer, assetBuilder, assetFromStorage).ConfigureAwait(false); }
static WorkspaceServices() { if (Environment.GetEnvironmentVariable("DEBUG_MOQ") == "1") { Debugger.Break(); } HostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Concat(new[] { // Moq.Sdk.dll typeof(IMock).Assembly, // Moq.CodeAnalysis.dll typeof(MockNamingConvention).Assembly, // Moq.dll typeof(IMoq).Assembly, })); }
// Re-run this method with TD.NET AdHoc runner to regenerate CodeFixNames.g.cs as needed. public void GenerateCodeFixNames() { var host = MefHostServices.Create(MefHostServices.DefaultAssemblies.Concat(new[] { typeof(CodeFixNamesGenerator).Assembly })); var codeFixProviders = host.GetExports <CodeFixProvider, IDictionary <string, object> >().Select(x => x.Metadata); var refactoringProviders = MefHostServices.DefaultAssemblies.Select(asm => asm.GetTypes()) .SelectMany(types => types.Select(type => type.GetCustomAttribute <ExportCodeRefactoringProviderAttribute>())) .Where(attr => attr != null) .Select(attr => new Dictionary <string, object> { { nameof(ExportCodeRefactoringProviderAttribute.Name), attr.Name }, { nameof(ExportCodeRefactoringProviderAttribute.Languages), attr.Languages }, }); var allFixes = new HashSet <string>(); var codeFixes = new Dictionary <string, HashSet <string> > { { "All", allFixes } }; var allRefactorings = new HashSet <string>(); var codeRefactorings = new Dictionary <string, HashSet <string> > { { "All", allFixes } }; GroupActions(codeFixProviders, allFixes, codeFixes); GroupActions(refactoringProviders, allRefactorings, codeRefactorings); var ns = NamespaceDeclaration(ParseName("Avatars.CodeActions")) .AddMembers(GetConstants("CodeFixes", codeFixes)) .AddMembers(GetConstants("CodeRefactorings", codeRefactorings)); var file = Path.GetFullPath(@$ "{ThisAssembly.Project.MSBuildProjectDirectory}\..\Avatar.StaticProxy\CodeActions.g.cs"); using (var output = new StreamWriter(file, false)) { output.WriteLine("#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member"); ns.NormalizeWhitespace().WriteTo(output); output.WriteLine(); output.WriteLine("#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member"); } Console.WriteLine(file); }
public async Task Workspace_RoundTrip_Test_Desktop() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); using var workspace = new AdhocWorkspace(hostServices); var solution = CreateFullSolution(workspace); var validator = new SerializationValidator(workspace.Services); using var snapshot1 = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false); // recover solution from given snapshot var recovered = await validator.GetSolutionAsync(snapshot1).ConfigureAwait(false); var solutionObject1 = await validator.GetValueAsync <SolutionStateChecksums>(snapshot1.SolutionChecksum).ConfigureAwait(false); // create new snapshot from recovered solution using var snapshot2 = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(recovered, CancellationToken.None).ConfigureAwait(false); // verify asset created by recovered solution is good var solutionObject2 = await validator.GetValueAsync <SolutionStateChecksums>(snapshot2.SolutionChecksum).ConfigureAwait(false); await validator.VerifyAssetAsync(solutionObject2).ConfigureAwait(false); // verify snapshots created from original solution and recovered solution are same validator.SolutionStateEqual(solutionObject1, solutionObject2); snapshot1.Dispose(); // recover new solution from recovered solution var roundtrip = await validator.GetSolutionAsync(snapshot2).ConfigureAwait(false); // create new snapshot from round tripped solution using var snapshot3 = await validator.RemotableDataService.CreatePinnedRemotableDataScopeAsync(roundtrip, CancellationToken.None).ConfigureAwait(false); // verify asset created by rount trip solution is good var solutionObject3 = await validator.GetValueAsync <SolutionStateChecksums>(snapshot3.SolutionChecksum).ConfigureAwait(false); await validator.VerifyAssetAsync(solutionObject3).ConfigureAwait(false); // verify snapshots created from original solution and round trip solution are same. validator.SolutionStateEqual(solutionObject2, solutionObject3); snapshot2.Dispose(); }
public static RoslynWorkspace GetWorkspace(AvalonStudio.Projects.ISolution solution) { if (!s_solutionWorkspaces.ContainsKey(solution)) { //await PackageManager.EnsurePackage("AvalonStudio.Languages.CSharp", IoC.Get<IConsole>()); //var dotnetDirectory = Path.Combine(PackageManager.GetPackageDirectory("AvalonStudio.Languages.CSharp"), "content"); var currentDir = AvalonStudio.Platforms.Platform.ExecutionPath; var loadedAssemblies = System.AppDomain.CurrentDomain.GetAssemblies(); var assemblies = new[] { // Microsoft.CodeAnalysis.Workspaces typeof(WorkspacesResources).GetTypeInfo().Assembly, // Microsoft.CodeAnalysis.CSharp.Workspaces typeof(CSharpWorkspaceResources).GetTypeInfo().Assembly, // Microsoft.CodeAnalysis.Features typeof(FeaturesResources).GetTypeInfo().Assembly, // Microsoft.CodeAnalysis.CSharp.Features typeof(CSharpFeaturesResources).GetTypeInfo().Assembly, typeof(RoslynWorkspace).Assembly, }; var partTypes = MefHostServices.DefaultAssemblies.Concat(assemblies) .Distinct() .SelectMany(x => x.GetTypes()) .ToArray(); var compositionContext = new ContainerConfiguration() .WithParts(partTypes) .CreateContainer(); var host = MefHostServices.Create(compositionContext); var workspace = new RoslynWorkspace(host, null, compositionContext, DotNetCliService.Instance.Info.Executable, DotNetCliService.Instance.Info.BasePath); workspace.RegisterWorkspace(solution); } return(s_solutionWorkspaces[solution]); }
static ImmutableHashSet <IOption> ComputeSerializableOptionsFromProviders(ImmutableArray <Lazy <IOptionProvider, LanguageMetadata> > lazyProvidersAndMetadata) { var builder = ImmutableHashSet.CreateBuilder <IOption>(); foreach (var lazyProviderAndMetadata in lazyProvidersAndMetadata) { // We only consider the options defined in the the DefaultAssemblies (Workspaces and Features) as serializable. // This is due to the fact that other layers above are VS specific and do not execute in OOP. var provider = lazyProviderAndMetadata.Value; if (!MefHostServices.IsDefaultAssembly(provider.GetType().Assembly)) { continue; } builder.AddRange(provider.Options); } return(builder.ToImmutable()); }
public RoslynSession( SourceText sourceText, ProjectInfo projectInfo, MefHostServices hostServices, ImmutableArray <DiagnosticAnalyzer> analyzers, ImmutableDictionary <string, ImmutableArray <CodeFixProvider> > codeFixProviders, ImmutableArray <ISignatureHelpProviderWrapper> signatureHelpProviders ) { _workspace = new CustomWorkspace(hostServices); _sourceText = sourceText; _document = CreateProjectAndOpenNewDocument(_workspace, projectInfo, sourceText); QuickInfoService = QuickInfoService.GetService(_document); _completionService = CompletionService.GetService(_document); Analyzers = analyzers; SignatureHelpProviders = signatureHelpProviders; CodeFixProviders = codeFixProviders; }
public async Task SnapshotWithMissingReferencesTest() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); var project = new AdhocWorkspace(hostServices).CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp); var metadata = new MissingMetadataReference(); var analyzer = new AnalyzerFileReference("missing_reference", new MissingAnalyzerLoader()); project = project.AddMetadataReference(metadata); project = project.AddAnalyzerReference(analyzer); var snapshotService = (new RemotableDataServiceFactory()).CreateService(project.Solution.Workspace.Services) as IRemotableDataService; using var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(project.Solution, CancellationToken.None).ConfigureAwait(false); // this shouldn't throw var recovered = await GetSolutionAsync(snapshotService, snapshot).ConfigureAwait(false); }
public void WorkspaceAnalyzer_Serialization_Desktop_Test() { var hostServices = MefHostServices.Create( MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly)); using var tempRoot = new TempRoot(); using var workspace = new AdhocWorkspace(hostServices); var reference = CreateShadowCopiedAnalyzerReference(tempRoot); var serializer = workspace.Services.GetService <ISerializerService>(); var asset = WorkspaceAnalyzerReferenceAsset.Create(reference, serializer, CancellationToken.None); // verify checksum from custom asset builder uses different checksum than regular one var expectedChecksum = Checksum.Create( WellKnownSynchronizationKind.AnalyzerReference, serializer.CreateChecksum(reference, CancellationToken.None)); Assert.Equal(expectedChecksum, asset.Checksum); }
static MefHostServices CreateDefaultServices() { var asms = new HashSet <Assembly>(MefHostServices.DefaultAssemblies); var version = typeof(Compilation).Assembly.GetName().Version; foreach (var asmNameTmp in otherAssemblies) { var asmName = string.Format(asmNameTmp, version); try { asms.Add(Assembly.Load(asmName)); } catch { Debug.Fail($"Couldn't load Roslyn MEF assembly: {asmName}"); } } // dnSpy.Roslyn.Internal exports some stuff too asms.Add(typeof(SignatureHelpService).Assembly); asms.Add(typeof(Microsoft.CodeAnalysis.Editor.VisualBasic.QuickInfo.SemanticQuickInfoProvider).Assembly); return(MefHostServices.Create(asms)); }
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 RoslynHost(IEnumerable <Assembly> additionalAssemblies = null, RoslynHostReferences references = null, ImmutableArray <string>?disabledDiagnostics = null) { if (references == null) { references = RoslynHostReferences.Empty; } _workspaces = new ConcurrentDictionary <DocumentId, RoslynWorkspace>(); _diagnosticsUpdatedNotifiers = new ConcurrentDictionary <DocumentId, Action <DiagnosticsUpdatedArgs> >(); // ReSharper disable once VirtualMemberCallInConstructor var assemblies = GetDefaultCompositionAssemblies(); if (additionalAssemblies != null) { assemblies = assemblies.Concat(additionalAssemblies); } var partTypes = assemblies .SelectMany(x => x.DefinedTypes) .Select(x => x.AsType()); _compositionContext = new ContainerConfiguration() .WithParts(partTypes) .CreateContainer(); HostServices = MefHostServices.Create(_compositionContext); // ReSharper disable once VirtualMemberCallInConstructor _parseOptions = CreateDefaultParseOptions(); _documentationProviderService = GetService <IDocumentationProviderService>(); DefaultReferences = references.GetReferences(DocumentationProviderFactory); DefaultImports = references.Imports; DisabledDiagnostics = disabledDiagnostics ?? ImmutableArray <string> .Empty; GetService <IDiagnosticService>().DiagnosticsUpdated += OnDiagnosticsUpdated; }
public OmnisharpWorkspace(MefHostServices hostServices) : base(hostServices, "Custom") { BufferManager = new BufferManager(this); }