Add

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (6)

81actions.Add(CodeAction.Create( 87actions.Add(CodeAction.Create( 97actions.Add(result.RequiredParameterActions.Single()); 100actions.Add(result.OptionalParameterActions.Single()); 117requiredParametersActions.Add(new AddConstructorParametersCodeAction( 121optionalParametersActions.Add(GetOptionalConstructorParametersCodeAction(

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (1)

90applicableConstructors.Add(new(

AddImport\AbstractAddImportFeatureService.cs (2)

342result.Add((p, peReference)); 572fixes.Add(fixesForDiagnostic.Fixes[0]);

AddImport\CodeActions\InstallPackageAndAddImportCodeAction.cs (1)

58result.Add(_installOperation);

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (1)

105result.Add(_syntaxFacts.GetIdentifierOfIdentifierName(rootNode).ValueText);

AddImport\SymbolReferenceFinder.cs (11)

AddMissingReference\AbstractAddMissingReferenceCodeFixProvider.cs (1)

51result.Add(codeAction);

AddPackage\AbstractAddPackageCodeFixProvider.cs (1)

63codeActions.Add(new InstallPackageParentCodeAction(

AddPackage\ParentInstallPackageCodeAction.cs (2)

98codeActions.Add(CreateCodeAction( 103codeActions.Add(new InstallWithPackageManagerCodeAction(installerService, fixData.PackageName));

BracePairs\IBracePairsService.cs (1)

80bracePairs.Add(new BracePairData(current.Span, sibling.Span));

CallHierarchy\AbstractCallHierarchyService.cs (13)

ChangeSignature\AbstractChangeSignatureService.cs (18)

526newArguments.Add(argument.WithName(param.Name).WithAdditionalAnnotations(Formatter.Annotation)); 531newArguments.Add(argument); 549newArguments.Add(paramsArrayArgument.WithName(param.Name).WithAdditionalAnnotations(Formatter.Annotation)); 554newArguments.Add(paramsArrayArgument); 569newArguments.Add(arguments[i]); 625parametersToPermute.Add(match); 637parametersToPermute.Add(originalParameters[position]); 835fullList.Add(argument); 836separators.Add(CommaTokenWithElasticSpace()); 851fullList.Add(newArgument); 857fullList.Add(newArgument); 876separators.Add(newArguments.GetSeparator(indexInListOfPreexistingArguments)); 886fullList.Add(newArgument); 900separators.Add(newArguments.GetSeparator(indexInListOfPreexistingArguments)); 903fullList.Add(newArguments[indexInListOfPreexistingArguments++]); 1000updatedNodeList.Add(content); 1007updatedNodeList.Add(permutedParamNodes[index].WithLeadingTrivia(content.GetLeadingTrivia()).WithTrailingTrivia(content.GetTrailingTrivia())); 1025extraNodeList.Add(permutedParamNodes[index]);

ChangeSignature\DelegateInvokeMethodReferenceFinder.cs (1)

50result.Add(beginInvoke);

ChangeSignature\ParameterConfiguration.cs (3)

54(seenDefaultValues ? remainingReorderableParameters : parametersWithoutDefaultValues).Add(param); 69list.Add(ThisParameter); 77list.Add(ParamsParameter);

CodeFixes\Configuration\ConfigureCodeStyle\ConfigureCodeStyleOptionCodeFixProvider.cs (3)

83nestedActions.Add(topLevelAction); 94result.Add(new CodeFix(resultCodeAction, [diagnostic])); 148nestedActions.Add(

CodeFixes\Configuration\ConfigureSeverity\ConfigureSeverityLevelCodeFixProvider.cs (6)

63nestedActions.Add( 71result.Add(new CodeFix(codeAction, [diagnostic])); 80diagnosticsForCategory.Add(diagnostic); 83analyzerDiagnostics.Add(diagnostic); 104nestedActions.Add( 114result.Add(new CodeFix(codeAction, diagnostics));

CodeFixes\Service\CodeFixService.cs (2)

684fixes.Add(new CodeFix(action, applicableDiagnostics)); 727newApplicableDiagnostics.Add(diagnostic);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs (1)

226uniqueDiagnostics.Add(diagnostic);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaWarningBatchFixAllProvider.cs (2)

47pragmaActionsBuilder.Add(pragmaSuppression); 48pragmaDiagnosticsBuilder.Add(diagnostic);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.BatchFixer.cs (2)

60pragmaActionsBuilder.Add(pragmaRemoveAction); 61pragmaDiagnosticsBuilder.Add(diagnostic);

CodeFixesAndRefactorings\AbstractFixAllGetFixesService.cs (2)

213result.Add(new ApplyChangesOperation(newSolution)); 218result.Add(operation);

CodeLens\CodeLensReferencesService.cs (2)

230list.Add(descriptor); 266list.Add(new ReferenceLocationDescriptor(

CodeRefactorings\CodeRefactoringService.cs (1)

266actions.Add((action, applicableToSpan));

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (6)

114actions.Add(GetCodeAction(fileName, operationKind: MoveTypeOperationKind.MoveType)); 122actions.Add(GetCodeAction(fileName, operationKind: MoveTypeOperationKind.RenameFile)); 127actions.Add(GetCodeAction( 226suggestedFileNames.Add(typeName + fileExtension); 228suggestedFileNames.Add($"{typeName}`{arity}{fileExtension}"); 251suggestedFileNames.Add(parts.Join(separator) + fileExtension);

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (4)

303containers.Add((document.Id, container)); 394builder.Add(string.Join(".", parts.Take(i))); 397builder.Add(newNamespace); 816documentsToProcess.Add(document);

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.MoveFileCodeAction.cs (1)

118builder.Add(defaultPathBasedOnCurrentFolder);

Common\AbstractProjectExtensionProvider.cs (1)

73builder.Add(extension);

Common\GlyphExtensions.cs (1)

27builder.Add(glyph);

Completion\CompletionService_GetCompletions.cs (1)

176additionalAugmentingProviders.Add(provider);

Completion\FileSystemCompletionHelper.cs (3)

150result.Add(CreateLogicalDriveItem(drive.TrimEnd(s_windowsDirectorySeparator))); 153result.Add(CreateNetworkRoot()); 202result.Add(CreateLogicalDriveItem(directoryPath));

Completion\Providers\AbstractAwaitCompletionProvider.cs (4)

208builder.Add(asyncChange); 221builder.Add(new TextChange(TextSpan.FromBounds(item.Span.Start, currentSpanEnd), _awaitKeyword)); 233builder.Add(new TextChange(new TextSpan(expr.SpanStart, 0), _awaitKeyword + " ")); 240builder.Add(new TextChange(TextSpan.FromBounds(dotToken.Value.SpanStart, currentSpanEnd), replacementText));

Completion\Providers\AbstractDocCommentCompletionProvider.cs (2)

242items.Add(GetItem(ValueElementName)); 248items.Add(GetItem(ReturnsElementName));

Completion\Providers\AbstractSymbolCompletionProvider.cs (2)

228itemListBuilder.Add(item); 492missingSymbols.GetOrAdd(symbol, m => ArrayBuilder<ProjectId>.GetInstance()).Add(documentId.ProjectId);

Completion\Providers\ImportCompletionProvider\AbstractImportCompletionProvider.cs (2)

107usingsBuilder.Add(@namespace.ToDisplayString(SymbolDisplayFormats.NameFormat)); 169builder.Add(new TextChange(completionItem.Span, insertText));

Completion\Providers\ImportCompletionProvider\AbstractTypeImportCompletionService.cs (5)

98projectsBuilder.Add(currentProject); 111resultBuilder.Add(upToDateCacheEntry); 115resultBuilder.Add(UpdateCacheWithCommitBehavior(s_projectItemsCache, project.Id, cacheEntry, commitBehavior)); 137resultBuilder.Add(upToDateCacheEntry); 142resultBuilder.Add(UpdateCacheWithCommitBehavior(s_metadataItemsCache, metadataId, cacheEntry, commitBehavior));

Completion\Providers\ImportCompletionProvider\ExtensionMemberImportCompletionHelper.SymbolComputer.cs (1)

119symbols.Add(member);

Completion\Providers\ImportCompletionProvider\ImportCompletionItem.cs (6)

53builder.Add(KeyValuePair.Create(MethodKey, extensionMethodData.Value.methodSymbolKey)); 54builder.Add(KeyValuePair.Create(ReceiverKey, extensionMethodData.Value.receiverTypeSymbolKey)); 58builder.Add(KeyValuePair.Create(OverloadCountKey, extensionMethodData.Value.overloadCount.ToString())); 66builder.Add(KeyValuePair.Create(TypeAritySuffixName, ArityUtilities.GetMetadataAritySuffix(arity))); 74builder.Add(KeyValuePair.Create(CommitBehaviorKey, nameof(ImportCompletionCommitBehavior.NeverAddImport))); 77builder.Add(KeyValuePair.Create(CommitBehaviorKey, nameof(ImportCompletionCommitBehavior.OnlyAddImportIfExplicitlyCompleted)));

Completion\Providers\ImportCompletionProvider\TypeImportCompletionCacheEntry.cs (2)

142builder.Add(item); 225_itemsBuilder.Add(new TypeImportCompletionItemInfo(item, isPublic, isGeneric, isAttribute, isEditorBrowsableStateAdvanced, isEnumBaseType));

Completion\Providers\Scripting\AbstractReferenceDirectiveCompletionProvider.cs (5)

30builder.Add('"'); 34builder.Add('/'); 38builder.Add('/'); 39builder.Add('\\'); 44builder.Add(',');

Completion\Providers\Scripting\GlobalAssemblyCacheCompletionHelper.cs (2)

43result.Add(CommonCompletionItem.Create( 52result.Add(CommonCompletionItem.Create(

Completion\Providers\SymbolCompletionItem.cs (11)

54builder.Add(KeyValuePair.Create(InsertionTextProperty, insertionText)); 83=> properties.Add(KeyValuePair.Create("Symbols", EncodeSymbols(symbols))); 89properties.Add(KeyValuePair.Create("SymbolKind", SmallNumberFormatter.ToString((int)symbol.Kind))); 90properties.Add(KeyValuePair.Create("SymbolName", symbol.Name)); 93properties.Add(KeyValuePair.Create("IsGeneric", isGeneric.ToString())); 179symbols.Add(symbol); // add symbol to the results 247properties.Add(KeyValuePair.Create("ContextPosition", contextPositionString)); 254properties.Add(KeyValuePair.Create("InvalidProjects", string.Join(";", supportedPlatforms.InvalidProjects.Select(id => id.Id)))); 255properties.Add(KeyValuePair.Create("CandidateProjects", string.Join(";", supportedPlatforms.CandidateProjects.Select(id => id.Id)))); 287builder.Add(ProjectId.CreateFromSerialized(projectGuid)); 299builder.Add(ProjectId.CreateFromSerialized(projectGuid));

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (4)

273members.Add(constructor); 303members.Add(constructor); 304members.Add(equalsMethod); 305members.Add(getHashCodeMethod);

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Analyzer.cs (4)

83sections.Add(new AnalyzedSwitchSection(labels: default, defaultBodyOpt, defaultBodyOpt.Syntax)); 165sections.Add(section); 225labels.Add(label); 326guards.Add(node);

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (5)

176content.Add(generator.InterpolatedStringText(generator.InterpolatedStringTextToken(textWithoutQuotes, valueTextWithEscapedBraces))); 200content.Add(contentPart); 217content.Add(generator.Interpolation(converted.WithoutTrivia())); 274pieces.Add(node); 281pieces.Add(right);

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

396builder.Add(convertedType is null

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (8)

499result.Add(new DocumentToUpdate(document, nodesToUpdate: default)); 536result.Add(new DocumentToUpdate(document, nodes)); 836members.Add(constructor); 841members.Add(equalsMethod); 842members.Add(getHashCodeMethod); 843members.Add(GenerateDeconstructMethod(semanticModel, generator, tupleType, constructor)); 896members.Add(CodeGenerationSymbolFactory.CreateConversionSymbol( 901members.Add(CodeGenerationSymbolFactory.CreateConversionSymbol(

Copilot\CopilotUtilities.cs (1)

64builder.Add(textChange);

Copilot\IProposalAdjusterService.cs (7)

148adjustmentResults.Add(new(adjusterName, AdjustmentTime: timer.Elapsed)); 239result.Add(changed ? new TextChange(span, newText) : change); 267result.Add(change); 322result.Add(new TextChange(beforeSpan, beforeText)); 327result.Add(new TextChange(afterSpan, afterText)); 335result.Add(new TextChange( 345result.Add(new TextChange(

DesignerAttribute\DesignerAttributeDiscoveryService.cs (1)

261results.Add((data, projectVersion));

Diagnostics\Service\DiagnosticAnalyzerService_CoreAnalyze.cs (2)

155document, documentAnalysisScope.Span, diagnosticsBuilder.Add, cancellationToken).ConfigureAwait(false); 181document, span: null, diagnosticsBuilder.Add, cancellationToken).ConfigureAwait(false);

Diagnostics\Service\DiagnosticAnalyzerService_GetDiagnosticsForSpan.cs (5)

120syntaxAnalyzers.Add(analyzer); 129semanticSpanBasedAnalyzers.Add(analyzer); 135semanticSpanBasedAnalyzers.Add(analyzer); 139semanticDocumentBasedAnalyzers.Add(analyzer); 235filteredAnalyzers.Add(analyzer);

Diagnostics\Service\DiagnosticAnalyzerService_ProduceProjectDiagnostics.cs (1)

162builder.Add(diagnostic);

Diagnostics\Service\DiagnosticAnalyzerService.cs (1)

138builder.Add(analyzer);

Diagnostics\Service\DiagnosticAnalyzerService.HostAnalyzerInfo.cs (2)

142projectAnalyzerCollection.Add(analyzers); 146hostAnalyzerCollection.Add(analyzers);

Diagnostics\Service\DiagnosticAnalyzerService.IncrementalMemberEditAnalyzer.cs (2)

97spanBasedAnalyzers.Add(analyzer); 104documentBasedAnalyzers.Add(analyzer);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (35)

EditAndContinue\ActiveStatementsMap.cs (2)

85documentInfos.Add((debugInfo, new SourceFileSpan(documentName, baseSpan), new ActiveStatementId(ordinal++))); 199builder.Add(new UnmappedActiveStatement(unmappedSpan, activeStatement, exceptionRegions));

EditAndContinue\DebuggingSession.cs (1)

427diagnostics.Add(Diagnostic.Create(descriptor, Location.None, [fileBeingRead, e.Message]));

EditAndContinue\EditAndContinueCapabilities.cs (9)

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (1)

169activeStatementSpansBuilder.Add(new ActiveStatementLineSpan(newMappedDocumentActiveSpan.Id, unmappedSpan));

EditAndContinue\EditSession.cs (31)

168diagnostics.Add(Diagnostic.Create(descriptor, location, messageArgs)); 366differences.ChangedOrAddedDocuments.Add(document); 382differences.ChangedOrAddedDocuments.Add(document); 398differences.DeletedDocuments.Add(document); 525documentDifferences.ChangedOrAddedDocuments.Add(newProject.GetOrCreateSourceGeneratedDocument(newState)); 536documentDifferences.ChangedOrAddedDocuments.Add(newProject.GetOrCreateSourceGeneratedDocument(newState)); 547documentDifferences.DeletedDocuments.Add(oldProject.GetOrCreateSourceGeneratedDocument(oldState)); 634diagnostics.Add(Diagnostic.Create(descriptor, Location.Create(newDocument.FilePath!, textSpan: default, lineSpan: default), [newDocument.FilePath])); 648documents.Add((oldDocument, newDocument)); 658documents.Add((oldDocument, newDocument: null)); 682diagnostics.Add(Diagnostic.Create( 744diagnostics.Add(diagnostic); 771projectDiagnostics.Add(Diagnostic.Create( 781projectDiagnostics.Add(Diagnostic.Create( 840activeStatementsInChangedDocuments.Add(new(oldActiveStatements, analysis.ActiveStatements, analysis.ExceptionRegions)); 887mergedEditsBuilder.Add(new SemanticEdit( 984mergedEditsBuilder.Add(new SemanticEdit(edit.Kind, oldSymbol, newSymbol, syntaxMaps.matchingNodes, syntaxMaps.runtimeRudeEdits)); 1029resolvedSymbols.Add((oldResolution.Symbol, newResolution.Symbol)); 1190projectDiagnostics.Add(mvidReadError); 1200addedUnbuiltProjects.Add(newProject.Id); 1311projectDiagnostics.Add(rudeEdit.ToDiagnostic(tree)); 1356projectsToRedeploy.Add(newProject.Id); 1422projectDiagnostics.Add(emitDiagnostic); 1442projectDiagnostics.Add(unsupportedChangesDiagnostic); 1474deltas.Add(delta); 1476nonRemappableRegions.Add((mvid, moduleNonRemappableRegions)); 1477newProjectBaselines.Add(new ProjectBaseline(mvid, projectBaseline.ProjectId, emitResult.Baseline, projectBaseline.InitiallyReferencedAssemblies, projectBaseline.Generation + 1)); 1667activeStatementsInUpdatedMethodsBuilder.Add(new ManagedActiveStatementUpdate(methodId, instructionId.ILOffset, newActiveStatement.Span.ToSourceSpan())); 1686nonRemappableRegionsBuilder.Add((methodId, new NonRemappableRegion(oldSpan, newSpan, isExceptionRegion))); 1698nonRemappableRegionsBuilder.Add((methodId, new NonRemappableRegion(oldSpan, oldSpan, isExceptionRegion: false))); 1771nonRemappableRegionsBuilder.Add((methodInstance.Method, newRegion));

EditAndContinue\EmitSolutionUpdateResults.cs (7)

59builder.Add(diagnostic.ToHotReloadDiagnostic(severity)); 70builder.Add(new ManagedHotReloadDiagnostic( 342updatedProjectsToRemove.Add(updatedProjectId); 415result.Add(SyntaxError); 433result.Add((projectId, transientDiagnostics)); 453result.Add(diagnostic); 460result.Add(SyntaxError);

EditAndContinue\ProjectDiagnostics.cs (1)

28result.Add(data);

EditAndContinue\RudeEditDiagnosticsBuilder.cs (2)

36DeferredDiagnostics.Add((diagnostic, deferredReportingCondition.Value)); 40Diagnostics.Add(diagnostic);

EditAndContinue\Utilities\Extensions.cs (1)

295childIndices.Add(GetChildIndex(parent, node));

EmbeddedLanguages\DateAndTime\DateAndTimeEmbeddedCompletionProvider.cs (5)

113properties.Add(new(StartKey, textChange.Span.Start.ToString())); 114properties.Add(new(LengthKey, textChange.Span.Length.ToString())); 115properties.Add(new(NewTextKey, textChange.NewText!)); 116properties.Add(new(DescriptionKey, embeddedItem.FullDescription)); 117properties.Add(new(AbstractAggregateEmbeddedLanguageCompletionProvider.EmbeddedProviderName, Name));

EmbeddedLanguages\DateAndTime\EmbeddedCompletionContext.cs (2)

118examples.Add(example); 142_items.Add(new DateAndTimeItem(

EmbeddedLanguages\Json\JsonLexer.cs (3)

203result.Add(comment.Value); 210result.Add(endOfLine.Value); 225result.Add(whitespace.Value);

EmbeddedLanguages\Json\JsonParser.cs (3)

322result.Add(ParseValue()); 349result.Add(value); 356result.Add(ConsumeToken(JsonKind.CommaToken, allProperties ? s_commaExpected : null));

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexEmbeddedCompletionProvider.cs (6)

100properties.Add(KeyValuePair.Create(StartKey, textChange.Span.Start.ToString())); 101properties.Add(KeyValuePair.Create(LengthKey, textChange.Span.Length.ToString())); 102properties.Add(KeyValuePair.Create(NewTextKey, textChange.NewText)); 103properties.Add(KeyValuePair.Create(DescriptionKey, embeddedItem.FullDescription)); 104properties.Add(KeyValuePair.Create(AbstractAggregateEmbeddedLanguageCompletionProvider.EmbeddedProviderName, Name)); 108properties.Add(new KeyValuePair<string, string>(NewPositionKey, change.NewPosition.ToString()));

EmbeddedLanguages\RegularExpressions\RegexLexer.cs (2)

111result.Add(comment.Value); 118result.Add(whitespace.Value);

EmbeddedLanguages\RegularExpressions\RegexParser.CaptureInfoAnalyzer.cs (1)

204list?.Add(val);

EmbeddedLanguages\RegularExpressions\RegexParser.cs (13)

232to.Add(diagnostic); 265builder.Add(ParseSequence(consumeCloseParen)); 280builder.Add(barToken); 281builder.Add(ParseSequence(consumeCloseParen)); 293builder.Add(ParsePrimaryExpressionAndQuantifiers(last)); 317final.Add(current); 362final.Add(startTextNode); 382final.Add(new RegexTextNode(CreateToken( 1303components.Add(left); 1314components.Add(left); 1315components.Add(ParseCharacterClassSubtractionNode(minusToken)); 1334components.Add(new RegexCharacterClassRangeNode(left, minusToken, right)); 1339components.Add(left);

EmbeddedLanguages\StackFrame\StackFrameLexer.cs (1)

437builder.Add(trivia.Value);

EmbeddedLanguages\StackFrame\StackFrameParser.cs (6)

419builder.Add(new StackFrameIdentifierNameNode(currentIdentifier.Value)); 431builder.Add(commaToken); 480builder.Add(parameterNode); 487builder.Add(commaToken); 555commaBuilder.Add(commaToken); 563builder.Add(new StackFrameArrayRankSpecifier(openBracket, closeBracket, commaBuilder.ToImmutableAndClear()));

Extensions\ExtensionFolder.cs (1)

192result.Add(handler);

ExternalAccess\UnitTesting\API\UnitTestingSearchHelpers.cs (1)

160result.Add(item);

ExtractClass\ExtractClassWithDialogCodeAction.cs (2)

195pullMembersBuilder.Add((currentSymbol, memberAnalysis.MakeAbstract)); 196resultsToRemove.Add(memberAnalysis);

ExtractInterface\AbstractExtractInterfaceService.cs (3)

376interfaceMembers.Add(CodeGenerationSymbolFactory.CreateEventSymbol( 385interfaceMembers.Add(CodeGenerationSymbolFactory.CreateMethodSymbol( 405interfaceMembers.Add(CodeGenerationSymbolFactory.CreatePropertySymbol(

ExtractMethod\MethodExtractor.Analyzer.cs (1)

891names.Add(field.Name ?? string.Empty);

ExtractMethod\MethodExtractor.CodeGenerator.cs (4)

349list.Add(CreateDeclarationStatement( 414typeParameters.Add(parameter); 418typeParameters.Add(CodeGenerationSymbolFactory.CreateTypeParameter( 436parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(

FullyQualify\AbstractFullyQualifyService.cs (1)

213fixes.Add(new FullyQualifyIndividualFixData(title, [.. textChanges]));

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (3)

86missingComparableTypes.Add(iface); 108nestedActions.Add(CodeAction.Create( 192operators.Add(CreateOperatorSymbol(

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (2)

86(singleAction, applicableToSpan) => actions.Add(singleAction), 254pickMemberOptions.Add(new PickMembersOption(

GenerateEqualsAndGetHashCodeFromMembers\AbstractGenerateEqualsAndGetHashCodeService.cs (5)

77expressions.Add( 80expressions.Add( 90expressions.Add(generator.IsTypeExpression(objName, containingType)); 91expressions.Add( 102expressions.Add(

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeAction.cs (5)

53methods.Add(await CreateEqualsMethodAsync(cancellationToken).ConfigureAwait(false)); 60methods.Add(await CreateIEquatableEqualsMethodAsync(constructedTypeToImplement, cancellationToken).ConfigureAwait(false)); 65methods.Add(await CreateGetHashCodeMethodAsync(cancellationToken).ConfigureAwait(false)); 137members.Add(CreateEqualityOperator(compilation, generator, generatorInternal, parameters)); 138members.Add(CreateInequalityOperator(compilation, generator, parameters));

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (6)

214tasks.Add(CreateCodeActionAsync( 217tasks.Add(CreateCodeActionAsync( 223tasks.Add(CreateCodeActionAsync( 229tasks.Add(CreateCodeActionAsync( 273pickMembersOptions.Add(new PickMembersOption( 283pickMembersOptions.Add(new PickMembersOption(

GenerateFromMembers\GenerateFromMembersHelpers.cs (1)

102parameters.Add((CodeGenerationSymbolFactory.CreateParameterSymbol(

GenerateType\AbstractGenerateTypeService.cs (6)

207isFixed.Add(!names.Contains(name)); 208names.Add(name); 209typeParameters.Add(typeParameter); 213isFixed.Add(false); 214names.Add("T"); 215typeParameters.Add(null);

GenerateType\AbstractGenerateTypeService.GenerateNamedType.cs (3)

163members.Add(factory.CreateBaseDelegatingConstructor(delegatedConstructor, DetermineName())); 180members.Add(generatedProperty); 210parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(

GoToDefinition\GoToDefinitionFeatureHelpers.cs (1)

96definitions.Add(definitionItem);

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (7)

121builder.Add((mappingResult.Symbol, 243targetItems.Add(new InheritanceTargetItem( 248items.Add(new InheritanceMarginItem( 271targetItems.Add(new InheritanceTargetItem( 280items.Add(new InheritanceMarginItem( 678builder.Add(overriddenMember.OriginalDefinition); 742builder.Add(item.Value);

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (4)

990content.Add(InterpolatedStringText(generator, escapedText, messageTemplate)); 994content.Add(InterpolatedStringText(generator, escapedTextParts.pre!, textParts.pre)); 995content.Add(generator.Interpolation(parameterNameOfExpression)); 996content.Add(InterpolatedStringText(generator, escapedTextParts.post!, textParts.post!));

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (9)

125allActions.Add(fieldAction); 126allActions.Add(propertyAction); 130allActions.Add(propertyAction); 131allActions.Add(fieldAction); 141allActions.Add(allFieldsAction); 142allActions.Add(allPropertiesAction); 146allActions.Add(allPropertiesAction); 147allActions.Add(allFieldsAction); 230result.Add(parameter);

InitializeParameter\AbstractInitializeParameterCodeRefactoringProvider.cs (1)

113listOfPotentiallyValidParametersNodes.Add(parameterNode);

InlineHints\AbstractInlineParameterNameHintsService.cs (1)

113result.Add(new InlineHint(

InlineHints\AbstractInlineTypeHintsService.cs (3)

95result.Add(new InlineHint( 123finalParts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Text, symbol: null, "...")); 128finalParts.Add(part);

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (1)

453builder.Add(argument);

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (1)

395localVariables.Add(declaredVariable);

IntroduceVariable\AbstractIntroduceVariableService.cs (20)

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (1)

517builder.Add(new StatementRange(nextStatement, GetStatements(node).Last()));

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.cs (2)

56result.Add(part); 206result.Add(namedType);

LanguageServices\SymbolDisplayService\AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs (2)

219commentsAndNewLines.Add(GetTrivia(startIndex)); 220commentsAndNewLines.Add(GetTrivia(startIndex + 1));

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (18)

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)

376tasks.Add(Task.Run(async () =>

MoveToNamespace\MoveToNamespaceCodeAction.cs (2)

65operations.Add(new ApplyChangesOperation(moveToNamespaceResult.UpdatedSolution)); 76operations.Add(symbolRenameCodeActionOperationFactory.CreateSymbolRenamedOperation(

NavigateTo\AbstractNavigateToSearchService.cs (2)

47results.Add(result); 78normalItems.Add(item);

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (1)

114linkedIndices.Add((linkedIndex, linkedDocumentId.ProjectId));

NavigateTo\NavigateToSearcher.cs (3)

334result.Add(_activeDocument); 339result.Add(doc); 399nonDuplicates.Add(result);

NavigateTo\RoslynNavigateToItem.cs (6)

151flavors.Add(firstProjectFlavor!); 161flavors.Add(projectFlavor!); 217parts.Add(ComputeFolderDistance().ToString("X4")); 219parts.Add(_item.DeclaredSymbolInfo.ParameterCount.ToString("X4")); 220parts.Add(_item.DeclaredSymbolInfo.TypeParameterCount.ToString("X4")); 221parts.Add(_item.DeclaredSymbolInfo.Name);

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (2)

343documents.Add(sourceDocumentInfo.DocumentInfo); 356documents.Add(documentInfo);

QuickInfo\CommonSemanticQuickInfoProvider.cs (2)

118invalidProjects.Add(docId.ProjectId); 328filteredSymbols.Add(symbol);

QuickInfo\QuickInfoUtilities.cs (1)

167=> sections.Add(QuickInfoSection.Create(kind, taggedParts));

Rename\SymbolicRenameInfo.cs (1)

239documentSpans.Add(new DocumentSpan(sourceDocument, location.SourceSpan));

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)

419result.Add(new GetAndSetMethods(getMethod, setMethod, getMethodDeclaration, setMethodDeclaration));

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)

409result.Add((property, declaration));

Shared\Utilities\ExtractTypeHelpers.cs (1)

194directlyReferencedTypeParameters.Add(typeParameter);

SignatureHelp\AbstractSignatureHelpProvider.cs (2)

286invalidProjectsForCurrentSymbol.Add(relatedDocument.Project.Id); 311builder.Add(relatedDocument);

Snippets\AbstractSnippetService.cs (2)

45arrayBuilder.Add(new(provider.Identifier, provider.Description, provider.AdditionalFilterTexts)); 63arrayBuilder.Add(providerData);

SpellCheck\AbstractSpellCheckSpanService.cs (1)

61_spans.Add(span);

src\roslyn\src\Analyzers\Core\Analyzers\Helpers\HashCodeAnalyzer\HashCodeAnalyzer.OperationDeconstructor.cs (1)

196_hashedSymbols.Add(member);

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (10)

260idsBuilder.Add(id); 285sortedPragmasWithIds.Add((trivia, idsBuilder.ToImmutable(), isDisable)); 378categoryBuilder.Add(trimmedPart); 382idBuilder.Add(trimmedPart); 410analyzersBuilder.Add(analyzer); 435unhandledIds.Add(descriptor.Id); 441analyzersBuilder.Add(analyzer); 499reportedDiagnostics.Add(diagnostic); 656diagnosticsBuilder.Add(diagnostic); 671diagnosticsBuilder.Add(diagnostic);

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

62builder.Add((propertyReference.Property.Name, simpleAssignment.Value));

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (2)

904builder.Add(value); 916builder.Add(namedValue);

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerAnalyzer.cs (1)

152postMatches.Add(match.Value);

src\roslyn\src\Analyzers\Core\Analyzers\UseObjectInitializer\UseNamedMemberInitializerAnalyzer.cs (1)

171postMatches.Add(new Match<TExpressionSyntax, TStatementSyntax, TMemberAccessExpressionSyntax, TAssignmentStatementSyntax>(

src\roslyn\src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

189validPotentialConversionTypes.Add((targetNode, targetNodeConversionType));

src\roslyn\src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (6)

53candidateSymbols.Add(symbolInfo.Symbol); 68mutablePotentialConversionTypes.Add((argumentExpression, targetArgumentConversionType)); 149newArguments.Add(arguments[i]); 158newArguments.Add(GenerateNewArgument(arguments[i], paramsType.ElementType)); 164newArguments.Add(GenerateNewArgument(arguments[i], parameterType)); 181newArguments.Add(arguments[i]);

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

226methodsAndArgumentToAdd.Add(new ArgumentInsertPositionData<TArgumentSyntax>(

src\roslyn\src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (1)

57actions.Add(CodeAction.Create(

src\roslyn\src\Analyzers\Core\CodeFixes\ConflictMarkerResolution\AbstractConflictMarkerCodeFixProvider.cs (8)

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (1)

166parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.cs (2)

51result.Add(new GenerateDefaultConstructorsCodeAction( 62result.Add(new GenerateDefaultConstructorsCodeAction(document, state, CodeFixesResources.Generate_all, state.UnimplementedConstructors));

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (2)

238names.Add(new ParameterName(typeLocalName, isFixed: false).BestNameForParameter); 239isFixed.Add(false);

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.cs (4)

41result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: false, generateProperty: false)); 51result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: true, generateProperty: false)); 66result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: false, generateProperty: true)); 69result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: true, generateProperty: true));

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (8)

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (1)

293result.Add((member, canDelegateAllMembers: accessibleCount == allUnimplementedMembers.Length));

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceService.cs (3)

100trivia.Add(this.SyntaxGeneratorInternal.SingleLineComment(" " + comment)); 101trivia.Add(this.SyntaxGeneratorInternal.ElasticCarriageReturnLineFeed); 163codeActions.Add(CodeAction.Create(

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (1)

54result.Add(parameter);

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (2)

194statements.Add(this.Service.AddComment( 205statements.Add(g.ExpressionStatement(

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (2)

137implementedMembers.Add(member); 140implementedVisibleMembers.Add(member);

src\roslyn\src\Analyzers\Core\CodeFixes\NewLines\MultipleBlankLines\AbstractMultipleBlankLinesCodeFixProvider.cs (2)

71builder.Add(trivia); 123builder.Add(triviaList[currentStart + 1]);

src\roslyn\src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (2)

230replacementNodes.Add(newWhenTrueStatement); 232replacementNodes.Add(nullAssignmentOpt.WithAdditionalAnnotations(Formatter.Annotation));

src\roslyn\src\Compilers\Core\AnalyzerDriver\DeclarationComputer.cs (1)

44builder.Add(executableCodeBlock);

src\roslyn\src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (6)

192results.Add(method); 233results.Add(singleResult); 326builder.Add(parameter.Value); 671builder.Add(type.Value); 759builder.Add(methodSymbol); 767builder.Add(methodSymbol);

src\roslyn\src\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoReader.cs (11)

135builder.Add(ReadInt16(bytes, ref offset)); 197builder.Add(new StateMachineHoistedLocalScope(startOffset, endOffset)); 262flagsBuilder.Add(ReadByte(bytes, ref offset) != 0); 288builder.Add(new DynamicLocalInfo(flagsBuilder.ToImmutable(), slotId, nameBuilder.ToString())); 309builder.Add(DecodeTupleElementNamesInfo(bytes, ref offset)); 322builder.Add(string.IsNullOrEmpty(value) ? null : value); 406externAliasBuilder.Add(importString); 443groupBuilder.Add(importString); 446resultBuilder.Add(groupBuilder.ToImmutable()); 463groupBuilder.Add(importString); 864builder.Add(b);

StackTraceExplorer\StackTraceAnalyzer.cs (1)

62builder.Add(parsedFrame);

StackTraceExplorer\StackTraceExplorerUtilities.cs (1)

70candidateProjects.Add(project);

TaskList\AbstractTaskListService.cs (1)

112items.Add(new TaskListItem(

Testing\AbstractTestMethodFinder.cs (1)

96testMethods.Add(method);

Wrapping\BinaryExpression\AbstractBinaryExpressionWrapper.cs (1)

123result.Add(currentNodeOrToken);

Wrapping\BinaryExpression\BinaryExpressionCodeActionComputer.cs (4)

106result.Add(Edit.UpdateBetween(left, _newlineBeforeOperatorTrivia, indentationTrivia, opToken)); 107result.Add(Edit.UpdateBetween(opToken, SingleWhitespaceTrivia, NoTrivia, right)); 116result.Add(Edit.UpdateBetween(left, SingleWhitespaceTrivia, NoTrivia, opToken)); 117result.Add(Edit.UpdateBetween(opToken, NewLineTrivia, indentationTrivia, right));

Wrapping\ChainedExpression\AbstractChainedExpressionWrapper.cs (4)

180chunks.Add(GetSubRange(pieces, currentChunkStart, end: pieces.Count)); 186chunks.Add(GetSubRange(pieces, currentChunkStart, end: nextChunkStart)); 284pieces.Add(nodeOrToken.AsToken()); 293pieces.Add(currentNode);

Wrapping\ChainedExpression\ChainedExpressionCodeActionComputer.cs (7)

108actions.Add(await TryCreateCodeActionAsync( 111actions.Add(await TryCreateCodeActionAsync( 117=> actions.Add(await TryCreateCodeActionAsync(GetUnwrapEdits(), FeaturesResources.Wrapping, FeaturesResources.Unwrap_call_chain, cancellationToken).ConfigureAwait(false)); 121actions.Add(await TryCreateCodeActionAsync( 124actions.Add(await TryCreateCodeActionAsync( 159result.Add(Edit.UpdateBetween( 194result.Add(Edit.DeleteBetween(chunk[i - 1], chunk[i]));

Wrapping\SeparatedSyntaxList\SeparatedSyntaxListCodeActionComputer.cs (19)