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))
);
}
