private static void AddCodeActions(
            Workspace workspace,
            IDictionary <CodeFixGroupKey, IList <UnifiedSuggestedAction> > map,
            ArrayBuilder <CodeFixGroupKey> order,
            CodeFixCollection fixCollection,
            Func <CodeAction, UnifiedSuggestedActionSet?> getFixAllSuggestedActionSet,
            ImmutableArray <CodeFix> codeFixes
            )
        {
            foreach (var fix in codeFixes)
            {
                var unifiedSuggestedAction = GetUnifiedSuggestedAction(fix.Action, fix);
                AddFix(fix, unifiedSuggestedAction, map, order);
            }

            return;

            // Local functions
            UnifiedSuggestedAction GetUnifiedSuggestedAction(CodeAction action, CodeFix fix)
            {
                if (action.NestedCodeActions.Length > 0)
                {
                    var nestedActions = action.NestedCodeActions.SelectAsArray(
                        nestedAction => GetUnifiedSuggestedAction(nestedAction, fix)
                        );

                    var set = new UnifiedSuggestedActionSet(
                        categoryName: null,
                        actions: nestedActions,
                        title: null,
                        priority: GetUnifiedSuggestedActionSetPriority(action.Priority),
                        applicableToSpan: fix.PrimaryDiagnostic.Location.SourceSpan
                        );

                    return(new UnifiedSuggestedActionWithNestedActions(
                               workspace,
                               action,
                               action.Priority,
                               fixCollection.Provider,
                               ImmutableArray.Create(set)
                               ));
                }
                else
                {
                    return(new UnifiedCodeFixSuggestedAction(
                               workspace,
                               action,
                               action.Priority,
                               fix,
                               fixCollection.Provider,
                               getFixAllSuggestedActionSet(action)
                               ));
                }
            }
        }
Esempio n. 2
0
        private static async Task AddCodeActionsAsync(
            Workspace workspace,
            Solution originalSolution,
            IDictionary <CodeFixGroupKey, IList <IUnifiedSuggestedAction> > map,
            ArrayBuilder <CodeFixGroupKey> order,
            CodeFixCollection fixCollection,
            Func <CodeAction, Task <UnifiedSuggestedActionSet?> > getFixAllSuggestedActionSetAsync,
            ImmutableArray <CodeFix> codeFixes)
        {
            foreach (var fix in codeFixes)
            {
                var unifiedSuggestedAction = await GetUnifiedSuggestedActionAsync(originalSolution, fix.Action, fix).ConfigureAwait(false);

                AddFix(fix, unifiedSuggestedAction, map, order);
            }

            return;

            // Local functions
            async Task <IUnifiedSuggestedAction> GetUnifiedSuggestedActionAsync(Solution originalSolution, CodeAction action, CodeFix fix)
            {
                if (action.NestedCodeActions.Length > 0)
                {
                    using var _ = ArrayBuilder <IUnifiedSuggestedAction> .GetInstance(action.NestedCodeActions.Length, out var unifiedNestedActions);

                    foreach (var nestedAction in action.NestedCodeActions)
                    {
                        var unifiedNestedAction = await GetUnifiedSuggestedActionAsync(originalSolution, nestedAction, fix).ConfigureAwait(false);

                        unifiedNestedActions.Add(unifiedNestedAction);
                    }

                    var set = new UnifiedSuggestedActionSet(
                        originalSolution,
                        categoryName: null,
                        actions: unifiedNestedActions.ToImmutable(),
                        title: null,
                        priority: GetUnifiedSuggestedActionSetPriority(action.Priority),
                        applicableToSpan: fix.PrimaryDiagnostic.Location.SourceSpan);

                    return(new UnifiedSuggestedActionWithNestedActions(
                               workspace, action, action.Priority, fixCollection.Provider, ImmutableArray.Create(set)));
                }
                else
                {
                    return(new UnifiedCodeFixSuggestedAction(
                               workspace, action, action.Priority, fix, fixCollection.Provider,
                               await getFixAllSuggestedActionSetAsync(action).ConfigureAwait(false)));
                }
            }
        }