public void TestCycle2() { var a = CreateExtension(name: "a", after: new[] { "b" }); var b = CreateExtension(name: "b", after: new[] { "c" }); var c = CreateExtension(name: "c", after: new[] { "d" }); var d = CreateExtension(name: "d", after: new[] { "e" }); var e = CreateExtension(name: "e", after: new[] { "a" }); var extensions = new List <Lazy <Extension, OrderableMetadata> >() { a, b, c, d, e }; // ExtensionOrderer.TestAccessor.CheckForCycles() will throw ArgumentException when cycle is detected. Assert.Throws <ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions)); var order = ExtensionOrderer.Order(extensions); VerifyOrder("edcba", order); }
public AsyncCompletionService( IThreadingContext threadingContext, IEditorOperationsFactoryService editorOperationsFactoryService, ITextUndoHistoryRegistry undoHistoryRegistry, IInlineRenameService inlineRenameService, IAsynchronousOperationListenerProvider listenerProvider, [ImportMany] IEnumerable <Lazy <IIntelliSensePresenter <ICompletionPresenterSession, ICompletionSession>, OrderableMetadata> > completionPresenters, [ImportMany] IEnumerable <Lazy <IBraceCompletionSessionProvider, BraceCompletionMetadata> > autoBraceCompletionChars) : base(threadingContext) { _editorOperationsFactoryService = editorOperationsFactoryService; _undoHistoryRegistry = undoHistoryRegistry; _inlineRenameService = inlineRenameService; _completionPresenter = ExtensionOrderer.Order(completionPresenters).Select(lazy => lazy.Value).FirstOrDefault(); _listener = listenerProvider.GetListener(FeatureAttribute.CompletionSet); _autoBraceCompletionChars = autoBraceCompletionChars; _autoBraceCompletionCharSet = new Dictionary <IContentType, ImmutableHashSet <char> >(); }
public void TestNoCycle3() { var a = CreateExtension(name: "a", before: new[] { "b", "c", "d", "e" }); var b = CreateExtension(name: "b", before: new[] { "c", "d", "e" }, after: new[] { "a" }); var c = CreateExtension(name: "c", before: new[] { "d", "e" }, after: new[] { "b", "a" }); var d = CreateExtension(name: "d", before: new[] { "e" }, after: new[] { "c", "b", "a" }); var e = CreateExtension(name: "e", after: new[] { "d", "c", "b", "a" }); var extensions = new List <Lazy <Extension, ExtensionMetadata> >() { d, b, a, c, e }; // ExtensionOrderer.CheckForCycles() will throw ArgumentException if cycle is detected. Assert.DoesNotThrow(() => ExtensionOrderer.CheckForCycles(extensions)); var order = ExtensionOrderer.Order(extensions); VerifyOrder("abcde", order); }
public void TestNoCycle1() { var a = CreateExtension(name: "a", before: new[] { "b" }); var b = CreateExtension(name: "b", before: new[] { "c" }); var c = CreateExtension(name: "c", before: new[] { "d" }); var d = CreateExtension(name: "d", before: new[] { "e" }); var e = CreateExtension(name: "e"); var extensions = new List <Lazy <Extension, OrderableMetadata> >() { d, b, a, c, e }; // ExtensionOrderer.TestAccessor.CheckForCycles() will throw ArgumentException if cycle is detected. ExtensionOrderer.TestAccessor.CheckForCycles(extensions); var order = ExtensionOrderer.Order(extensions); VerifyOrder("abcde", order); }
public void TestNoCyclesInSuppressionProviders() { // This test will fail if a cycle is detected in the ordering of our suppression fix providers. // If this test fails, you can break the cycle by inspecting and fixing up the contents of // any [ExtensionOrder()] attributes present on our suppression fix providers. var providers = ExportProvider.GetExports < IConfigurationFixProvider, CodeChangeProviderMetadata >(); var providersPerLanguage = providers.ToPerLanguageMapWithMultipleLanguages(); TestCore(LanguageNames.CSharp); TestCore(LanguageNames.VisualBasic); return; // Local functions. void TestCore(string language) { var providers = providersPerLanguage[language]; // ExtensionOrderer.TestAccessor.CheckForCycles() will throw ArgumentException if cycle is detected. ExtensionOrderer.TestAccessor.CheckForCycles(providers); // ExtensionOrderer.Order() will not throw even if cycle is detected. However, it will // break the cycle and the resulting order will end up being unpredictable. var actualOrder = ExtensionOrderer.Order(providers).ToArray(); Assert.Equal(3, actualOrder.Length); Assert.Equal( PredefinedConfigurationFixProviderNames.Suppression, actualOrder[0].Metadata.Name ); Assert.Equal( PredefinedConfigurationFixProviderNames.ConfigureCodeStyleOption, actualOrder[1].Metadata.Name ); Assert.Equal( PredefinedConfigurationFixProviderNames.ConfigureSeverity, actualOrder[2].Metadata.Name ); } }
public SuggestedActionsSourceProvider( ICodeRefactoringService codeRefactoringService, IDiagnosticAnalyzerService diagnosticService, ICodeFixService codeFixService, ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, [ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners, [ImportMany] IEnumerable <Lazy <IImageMonikerService, OrderableMetadata> > imageMonikerServices, [ImportMany] IEnumerable <Lazy <ISuggestedActionCallback> > actionCallbacks) { _codeRefactoringService = codeRefactoringService; _diagnosticService = diagnosticService; _codeFixService = codeFixService; ActionCallbacks = actionCallbacks.ToImmutableArray(); EditHandler = editHandler; WaitIndicator = waitIndicator; OperationListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.LightBulb); ImageMonikerServices = ExtensionOrderer.Order(imageMonikerServices).ToImmutableArray(); }
public AsyncCompletionService( IEditorOperationsFactoryService editorOperationsFactoryService, ITextUndoHistoryRegistry undoHistoryRegistry, IInlineRenameService inlineRenameService, IIntelliSensePresenter <ICompletionPresenterSession, ICompletionSession> completionPresenter, IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners, IEnumerable <Lazy <ICompletionRules, OrderableLanguageMetadata> > allCompletionRules, IEnumerable <Lazy <ICompletionProvider, OrderableLanguageMetadata> > allCompletionProviders, IEnumerable <Lazy <IBraceCompletionSessionProvider, IBraceCompletionMetadata> > autoBraceCompletionChars) { _editorOperationsFactoryService = editorOperationsFactoryService; _undoHistoryRegistry = undoHistoryRegistry; _inlineRenameService = inlineRenameService; _completionPresenter = completionPresenter; _asyncListeners = asyncListeners; _allCompletionRules = ExtensionOrderer.Order(allCompletionRules); _allCompletionProviders = ExtensionOrderer.Order(allCompletionProviders); _autoBraceCompletionChars = autoBraceCompletionChars; _autoBraceCompletionCharSet = new Dictionary <IContentType, ImmutableHashSet <char> >(); }
private ImmutableArray <QuickInfoProvider> GetProviders() { if (_providers.IsDefault) { var mefExporter = (IMefHostExportProvider)_workspace.Services.HostServices; var providers = ExtensionOrderer .Order( mefExporter .GetExports <QuickInfoProvider, QuickInfoProviderMetadata>() .Where(lz => lz.Metadata.Language == _language) ) .Select(lz => lz.Value) .ToImmutableArray(); ImmutableInterlocked.InterlockedCompareExchange(ref _providers, providers, default); } return(_providers); }
public void TestCycle8() { var a = CreateExtension(name: "a", before: new[] { "b" }); var b = CreateExtension(name: "b", before: new[] { "c" }); var c = CreateExtension(name: "c", before: new[] { "d" }); var d = CreateExtension(name: "d", before: new[] { "e", "c" }); var e = CreateExtension(name: "e", before: new[] { "f" }); var f = CreateExtension(name: "f", before: new[] { "a" }); var extensions = new List <Lazy <Extension, ExtensionMetadata> >() { a, b, c, d, e, f }; // ExtensionOrderer.CheckForCycles() will throw ArgumentException when cycle is detected. Assert.Throws <ArgumentException>(() => ExtensionOrderer.CheckForCycles(extensions)); var order = ExtensionOrderer.Order(extensions); VerifyOrder("bcdefa", order); }
public SuggestedActionsSourceProvider( IThreadingContext threadingContext, ICodeRefactoringService codeRefactoringService, ICodeFixService codeFixService, ICodeActionEditHandlerService editHandler, IUIThreadOperationExecutor uiThreadOperationExecutor, ISuggestedActionCategoryRegistryService suggestedActionCategoryRegistry, IAsynchronousOperationListenerProvider listenerProvider, IGlobalOptionService globalOptions, [ImportMany] IEnumerable <Lazy <IImageIdService, OrderableMetadata> > imageIdServices) { _threadingContext = threadingContext; _codeRefactoringService = codeRefactoringService; _codeFixService = codeFixService; _suggestedActionCategoryRegistry = suggestedActionCategoryRegistry; _globalOptions = globalOptions; EditHandler = editHandler; UIThreadOperationExecutor = uiThreadOperationExecutor; OperationListener = listenerProvider.GetListener(FeatureAttribute.LightBulb); ImageIdServices = ExtensionOrderer.Order(imageIdServices).ToImmutableArray(); }
public void TestCompletionProviderOrderMetadata() { var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider(); var completionProviderExports = exportProvider.GetExports <CompletionProvider, CompletionProviderMetadata>(); var orderedCSharpCompletionProviders = ExtensionOrderer.Order(completionProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp)); for (var i = 0; i < orderedCSharpCompletionProviders.Count; i++) { if (i == 0) { Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped); Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.AfterTyped); } else if (i == orderedCSharpCompletionProviders.Count - 1) // last one { // The last one isn't before anything else Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped); // The last completion marker should be last; this is ensured by either the last "real" provider saying it comes before the // marker, or the last completion marker comes after the last "real" provider. if (!orderedCSharpCompletionProviders[i].Metadata.AfterTyped.Contains(orderedCSharpCompletionProviders[i - 1].Metadata.Name)) { // Make sure the last built-in provider comes before the marker Assert.Contains(orderedCSharpCompletionProviders[i].Metadata.Name, orderedCSharpCompletionProviders[i - 1].Metadata.BeforeTyped); } } else { if (orderedCSharpCompletionProviders[i].Metadata.BeforeTyped.Any()) { Assert.Equal(orderedCSharpCompletionProviders.Last().Metadata.Name, Assert.Single(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped)); } var after = Assert.Single(orderedCSharpCompletionProviders[i].Metadata.AfterTyped); Assert.Equal(orderedCSharpCompletionProviders[i - 1].Metadata.Name, after); } } }
public SuggestedActionsSourceProvider( IThreadingContext threadingContext, ICodeRefactoringService codeRefactoringService, IDiagnosticAnalyzerService diagnosticService, ICodeFixService codeFixService, ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, ISuggestedActionCategoryRegistryService suggestedActionCategoryRegistry, IAsynchronousOperationListenerProvider listenerProvider, [ImportMany] IEnumerable <Lazy <IImageMonikerService, OrderableMetadata> > imageMonikerServices, [ImportMany] IEnumerable <Lazy <ISuggestedActionCallback> > actionCallbacks) { _threadingContext = threadingContext; _codeRefactoringService = codeRefactoringService; _diagnosticService = diagnosticService; _codeFixService = codeFixService; _suggestedActionCategoryRegistry = suggestedActionCategoryRegistry; ActionCallbacks = actionCallbacks.ToImmutableArray(); EditHandler = editHandler; WaitIndicator = waitIndicator; OperationListener = listenerProvider.GetListener(FeatureAttribute.LightBulb); ImageMonikerServices = ExtensionOrderer.Order(imageMonikerServices).ToImmutableArray(); }
private static ImmutableDictionary<LanguageKind, Lazy<ImmutableDictionary<CodeFixProvider, int>>> GetFixerPriorityPerLanguageMap( Dictionary<LanguageKind, List<Lazy<CodeFixProvider, CodeChangeProviderMetadata>>> fixersPerLanguage) { var languageMap = ImmutableDictionary.CreateBuilder<LanguageKind, Lazy<ImmutableDictionary<CodeFixProvider, int>>>(); foreach (var languageAndFixers in fixersPerLanguage) { var lazyMap = new Lazy<ImmutableDictionary<CodeFixProvider, int>>(() => { var priorityMap = ImmutableDictionary.CreateBuilder<CodeFixProvider, int>(); var fixers = ExtensionOrderer.Order(languageAndFixers.Value); for (var i = 0; i < fixers.Count; i++) { priorityMap.Add(fixers[i].Value, i); } return priorityMap.ToImmutable(); }, isThreadSafe: true); languageMap.Add(languageAndFixers.Key, lazyMap); } return languageMap.ToImmutable(); }
public void TestArgumentProviderOrder() { var exportProvider = EditorTestCompositions.EditorFeaturesWpf.ExportProviderFactory.CreateExportProvider(); var argumentProviderExports = exportProvider.GetExports <ArgumentProvider, CompletionProviderMetadata>(); var orderedCSharpArgumentProviders = ExtensionOrderer.Order(argumentProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp)); var actualOrder = orderedCSharpArgumentProviders.Select(x => x.Value.GetType()).ToArray(); var expectedOrder = new[] { // Marker for start of built-in argument providers typeof(FirstBuiltInArgumentProvider), // Built-in providers typeof(ContextVariableArgumentProvider), typeof(DefaultArgumentProvider), // Marker for end of built-in argument providers typeof(LastBuiltInArgumentProvider), }; AssertEx.EqualOrDiff( string.Join(Environment.NewLine, expectedOrder.Select(x => x.FullName)), string.Join(Environment.NewLine, actualOrder.Select(x => x.FullName))); }
private List <CodeRefactoringProvider> GetSortedCodeRefactoringProviders() { var providerList = this.Providers.SelectMany(provider => provider.CodeRefactoringProviders); return(ExtensionOrderer.GetOrderedOrUnorderedList <CodeRefactoringProvider, ExportCodeFixProviderAttribute>(providerList, attribute => attribute.Name).ToList()); }
public CodeRefactoringService( [ImportMany] IEnumerable <Lazy <CodeRefactoringProvider, CodeChangeProviderMetadata> > providers) { // convert set of all code refactoring providers into a map from language to a lazy initialized list of ordered providers. _lazyLanguageToProvidersMap = new Lazy <ImmutableDictionary <string, Lazy <IEnumerable <CodeRefactoringProvider> > > >( () => ImmutableDictionary.CreateRange( DistributeLanguages(providers) .GroupBy(lz => lz.Metadata.Language) .Select(grp => new KeyValuePair <string, Lazy <IEnumerable <CodeRefactoringProvider> > >( grp.Key, new Lazy <IEnumerable <CodeRefactoringProvider> >(() => ExtensionOrderer.Order(grp).Select(lz => lz.Value)))))); }
private List <CodeFixProvider> GetSortedCodeFixProviders(Document document) { return(ExtensionOrderer.GetOrderedOrUnorderedList <CodeFixProvider, ExportCodeFixProviderAttribute>(_codeFixesForProject.GetAllCodeFixesForProject(document.Project), attribute => attribute.Name).ToList()); }
protected QuickInfoService(Lazy <IQuickInfoProvider, OrderableLanguageMetadata>[] quickInfoProviders) { this.quickInfoProviders = ExtensionOrderer.Order(quickInfoProviders).Select(a => a.Value).ToArray(); }
public SignatureHelpService( [ImportMany] IEnumerable <Lazy <ISignatureHelpProvider, OrderableLanguageMetadata> > signatureHelpProviders) { _signatureHelpProviders = ExtensionOrderer.Order(signatureHelpProviders); }
public QuickInfoProviderCoordinatorFactory( [ImportMany] IEnumerable <Lazy <IQuickInfoProvider, OrderableLanguageMetadata> > providers) { _providers = ExtensionOrderer.Order(providers); }
public CSharpCodeRefactoringService( [ImportMany] IEnumerable <Lazy <CodeRefactoringProvider, OrderableLanguageMetadata> > codeRefactoringProviders) { this.lazyCodeRefactoringProviders = ExtensionOrderer.Order(codeRefactoringProviders.Where(p => p.Metadata.Language == LanguageNames.CSharp)).ToImmutableList(); }
protected SignatureHelpService(Lazy <ISignatureHelpProvider, OrderableLanguageMetadata>[] signatureHelpProviders) { this.signatureHelpProviders = ExtensionOrderer.Order(signatureHelpProviders).Select(a => a.Value).ToArray(); }
/// <summary> /// Returns a collection of ICommandHandlers that match the appropriate content type of the given buffer. /// </summary> internal CommandHandlerService CreateCollectionForBuffer(ITextBuffer subjectBuffer) { var handlers = ExtensionOrderer.Order(_commandHandlers.SelectMatchingExtensions(subjectBuffer.ContentType)); return(new CommandHandlerService(handlers)); }
public void TestCompletionProviderOrder() { var exportProvider = EditorTestCompositions.EditorFeaturesWpf.ExportProviderFactory.CreateExportProvider(); var completionProviderExports = exportProvider.GetExports < CompletionProvider, CompletionProviderMetadata >(); var orderedCSharpCompletionProviders = ExtensionOrderer.Order( completionProviderExports.Where( export => export.Metadata.Language == LanguageNames.CSharp ) ); var actualOrder = orderedCSharpCompletionProviders .Select(x => x.Value.GetType()) .ToArray(); var expectedOrder = new[] { // Marker for start of built-in completion providers typeof(FirstBuiltInCompletionProvider), // Built-in providers typeof(AttributeNamedParameterCompletionProvider), typeof(NamedParameterCompletionProvider), typeof(KeywordCompletionProvider), typeof(SpeculativeTCompletionProvider), typeof(SymbolCompletionProvider), typeof(UnnamedSymbolCompletionProvider), typeof(ExplicitInterfaceMemberCompletionProvider), typeof(ExplicitInterfaceTypeCompletionProvider), typeof(ObjectCreationCompletionProvider), typeof(ObjectAndWithInitializerCompletionProvider), typeof(CSharpSuggestionModeCompletionProvider), typeof(EnumAndCompletionListTagCompletionProvider), typeof(CrefCompletionProvider), typeof(SnippetCompletionProvider), typeof(ExternAliasCompletionProvider), typeof(PreprocessorCompletionProvider), typeof(OverrideCompletionProvider), typeof(PartialMethodCompletionProvider), typeof(PartialTypeCompletionProvider), typeof(XmlDocCommentCompletionProvider), typeof(TupleNameCompletionProvider), typeof(DeclarationNameCompletionProvider), typeof(InternalsVisibleToCompletionProvider), typeof(PropertySubpatternCompletionProvider), typeof(TypeImportCompletionProvider), typeof(ExtensionMethodImportCompletionProvider), typeof(EmbeddedLanguageCompletionProvider), typeof(FunctionPointerUnmanagedCallingConventionCompletionProvider), // Built-in interactive providers typeof(LoadDirectiveCompletionProvider), typeof(ReferenceDirectiveCompletionProvider), // Marker for end of built-in completion providers typeof(LastBuiltInCompletionProvider), }; AssertEx.EqualOrDiff( string.Join(Environment.NewLine, expectedOrder.Select(x => x.FullName)), string.Join(Environment.NewLine, actualOrder.Select(x => x.FullName)) ); }