Add

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (6)

85actions.Add(CodeAction.Create( 91actions.Add(CodeAction.Create( 101actions.Add(result.RequiredParameterActions.Single()); 104actions.Add(result.OptionalParameterActions.Single()); 121requiredParametersActions.Add(new AddConstructorParametersCodeAction( 130optionalParametersActions.Add(GetOptionalContructorParametersCodeAction(

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (3)

91applicableConstructors.Add(CreateConstructorCandidate(parametersForSelectedMembers, selectedMembers, constructor)); 135missingParametersBuilder.Add(parameter); 136missingMembersBuilder.Add(selectedMember);

AddImport\AbstractAddImportFeatureService.cs (2)

340result.Add((p, peReference)); 596fixes.Add(fixesForDiagnostic.Fixes[0]);

AddImport\CodeActions\InstallPackageAndAddImportCodeAction.cs (1)

58result.Add(_installOperation);

AddImport\SymbolReferenceFinder.cs (11)

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (1)

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

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

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(project, resultCodeAction, diagnostic)); 148nestedActions.Add(

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

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

CodeFixes\Service\CodeFixService.cs (2)

657fixes.Add(new CodeFix(document.Project, action, applicableDiagnostics)); 700newApplicableDiagnostics.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);

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); 817documentsToProcess.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)

167additionalAugmentingProviders.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)

202builder.Add(asyncChange); 208builder.Add(new TextChange(item.Span, _awaitKeyword)); 220builder.Add(new TextChange(new TextSpan(expr.SpanStart, 0), _awaitKeyword + " ")); 227builder.Add(new TextChange(TextSpan.FromBounds(dotToken.Value.SpanStart, item.Span.End), replacementText));

Completion\Providers\AbstractDocCommentCompletionProvider.cs (2)

230items.Add(GetItem(ValueElementName)); 236items.Add(GetItem(ReturnsElementName));

Completion\Providers\AbstractSymbolCompletionProvider.cs (2)

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

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

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

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

96projectsBuilder.Add(currentProject); 109resultBuilder.Add(upToDateCacheEntry); 113resultBuilder.Add(cacheEntry); 135resultBuilder.Add(upToDateCacheEntry); 140resultBuilder.Add(cacheEntry);

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

50builder.Add(KeyValuePair.Create(MethodKey, extensionMethodData.Value.methodSymbolKey)); 51builder.Add(KeyValuePair.Create(ReceiverKey, extensionMethodData.Value.receiverTypeSymbolKey)); 55builder.Add(KeyValuePair.Create(OverloadCountKey, extensionMethodData.Value.overloadCount.ToString())); 62builder.Add(KeyValuePair.Create(TypeAritySuffixName, ArityUtilities.GetMetadataAritySuffix(arity)));

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

129builder.Add(item); 209_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)

52builder.Add(KeyValuePair.Create(InsertionTextProperty, insertionText)); 54builder.Add(KeyValuePair.Create("ContextPosition", contextPosition.ToString())); 81=> properties.Add(KeyValuePair.Create("Symbols", EncodeSymbols(symbols))); 87properties.Add(KeyValuePair.Create("SymbolKind", SmallNumberFormatter.ToString((int)symbol.Kind))); 88properties.Add(KeyValuePair.Create("SymbolName", symbol.Name)); 91properties.Add(KeyValuePair.Create("IsGeneric", isGeneric.ToString())); 171symbols.Add(symbol); // add symbol to the results 226properties.Add(KeyValuePair.Create("InvalidProjects", string.Join(";", supportedPlatforms.InvalidProjects.Select(id => id.Id)))); 227properties.Add(KeyValuePair.Create("CandidateProjects", string.Join(";", supportedPlatforms.CandidateProjects.Select(id => id.Id)))); 259builder.Add(ProjectId.CreateFromSerialized(projectGuid)); 271builder.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)

82sections.Add(new AnalyzedSwitchSection(labels: default, defaultBodyOpt, defaultBodyOpt.Syntax)); 164sections.Add(section); 224labels.Add(label); 325guards.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)

383builder.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\CopilotChangeAnalysisUtilities.cs (1)

67builder.Add(textChange);

Copilot\ICopilotChangeAnalysisService.cs (1)

109newSpans.Add(new TextSpan(change.Span.Start + totalDelta, newTextLength));

DesignerAttribute\DesignerAttributeDiscoveryService.cs (1)

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

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.HostAnalyzerInfo.cs (2)

57projectAnalyzerCollection.Add(analyzers); 61hostAnalyzerCollection.Add(analyzers);

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.IncrementalMemberEditAnalyzer.cs (2)

91spanBasedAnalyzers.Add(analyzer); 98documentBasedAnalyzers.Add(analyzer);

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnostics.cs (1)

104builder.Add(diagnostic);

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs (5)

130syntaxAnalyzers.Add(analyzer); 139semanticSpanBasedAnalyzers.Add(analyzer); 145semanticSpanBasedAnalyzers.Add(analyzer); 149semanticDocumentBasedAnalyzers.Add(analyzer); 219filteredAnalyzers.Add(analyzer);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (36)

EditAndContinue\ActiveStatementsMap.cs (2)

85documentInfos.Add((debugInfo, new SourceFileSpan(documentName, baseSpan), new ActiveStatementId(ordinal++))); 205builder.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 (29)

169diagnostics.Add(Diagnostic.Create(descriptor, location, messageArgs)); 369differences.ChangedOrAddedDocuments.Add(document); 385differences.ChangedOrAddedDocuments.Add(document); 401differences.DeletedDocuments.Add(document); 521documentDifferences.ChangedOrAddedDocuments.Add(newProject.GetOrCreateSourceGeneratedDocument(newState)); 532documentDifferences.ChangedOrAddedDocuments.Add(newProject.GetOrCreateSourceGeneratedDocument(newState)); 543documentDifferences.DeletedDocuments.Add(oldProject.GetOrCreateSourceGeneratedDocument(oldState)); 629diagnostics.Add(Diagnostic.Create(descriptor, Location.Create(newDocument.FilePath!, textSpan: default, lineSpan: default), [newDocument.FilePath])); 643documents.Add((oldDocument, newDocument)); 653documents.Add((oldDocument, newDocument: null)); 712diagnostics.Add(diagnostic); 739projectDiagnostics.Add(Diagnostic.Create( 749projectDiagnostics.Add(Diagnostic.Create( 808activeStatementsInChangedDocuments.Add(new(oldActiveStatements, analysis.ActiveStatements, analysis.ExceptionRegions)); 869resolvedSymbols.Add((oldResolution.Symbol, newResolution.Symbol)); 886mergedEditsBuilder.Add(new SemanticEdit( 947mergedEditsBuilder.Add(new SemanticEdit(edit.Kind, oldSymbol, newSymbol, syntaxMaps.matchingNodes, syntaxMaps.runtimeRudeEdits)); 1052projectDiagnostics.Add(mvidReadError); 1062addedUnbuiltProjects.Add(newProject.Id); 1164projectDiagnostics.Add(rudeEdit.ToDiagnostic(tree)); 1209projectsToRedeploy.Add(newProject.Id); 1295projectDiagnostics.Add(unsupportedChangesDiagnostic); 1327deltas.Add(delta); 1329nonRemappableRegions.Add((mvid, moduleNonRemappableRegions)); 1330newProjectBaselines.Add(new ProjectBaseline(mvid, projectBaseline.ProjectId, emitResult.Baseline, projectBaseline.InitiallyReferencedAssemblies, projectBaseline.Generation + 1)); 1506activeStatementsInUpdatedMethodsBuilder.Add(new ManagedActiveStatementUpdate(methodId, instructionId.ILOffset, newActiveStatement.Span.ToSourceSpan())); 1527nonRemappableRegionsBuilder.Add((methodId, new NonRemappableRegion(oldSpan, newSpan, isExceptionRegion))); 1539nonRemappableRegionsBuilder.Add((methodId, new NonRemappableRegion(oldSpan, oldSpan, isExceptionRegion: false))); 1612nonRemappableRegionsBuilder.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);

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 (12)

232to.Add(diagnostic); 265builder.Add(ParseSequence(consumeCloseParen)); 280builder.Add(barToken); 281builder.Add(ParseSequence(consumeCloseParen)); 293builder.Add(ParsePrimaryExpressionAndQuantifiers(last)); 316final.Add(current); 357final.Add(startTextNode == lastTextNode 1282components.Add(left); 1293components.Add(left); 1294components.Add(ParseCharacterClassSubtractionNode(minusToken)); 1313components.Add(new RegexCharacterClassRangeNode(left, minusToken, right)); 1318components.Add(left);

EmbeddedLanguages\StackFrame\StackFrameLexer.cs (1)

430builder.Add(trivia.Value);

EmbeddedLanguages\StackFrame\StackFrameParser.cs (6)

381builder.Add(new StackFrameIdentifierNameNode(currentIdentifier.Value)); 393builder.Add(commaToken); 442builder.Add(parameterNode); 449builder.Add(commaToken); 517commaBuilder.Add(commaToken); 525builder.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)

192pullMembersBuilder.Add((currentSymbol, memberAnalysis.MakeAbstract)); 193resultsToRemove.Add(memberAnalysis);

ExtractInterface\AbstractExtractInterfaceService.cs (3)

373interfaceMembers.Add(CodeGenerationSymbolFactory.CreateEventSymbol( 382interfaceMembers.Add(CodeGenerationSymbolFactory.CreateMethodSymbol( 402interfaceMembers.Add(CodeGenerationSymbolFactory.CreatePropertySymbol(

ExtractMethod\MethodExtractor.Analyzer.cs (1)

887names.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)

214fixes.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)

215tasks.Add(CreateCodeActionAsync( 218tasks.Add(CreateCodeActionAsync( 224tasks.Add(CreateCodeActionAsync( 230tasks.Add(CreateCodeActionAsync( 274pickMembersOptions.Add(new PickMembersOption( 284pickMembersOptions.Add(new PickMembersOption(

GenerateFromMembers\GenerateFromMembersHelpers.cs (1)

104parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(

GenerateType\AbstractGenerateTypeService.cs (6)

205isFixed.Add(!names.Contains(name)); 206names.Add(name); 207typeParameters.Add(typeParameter); 211isFixed.Add(false); 212names.Add("T"); 213typeParameters.Add(null);

GenerateType\AbstractGenerateTypeService.GenerateNamedType.cs (3)

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

GoToDefinition\GoToDefinitionFeatureHelpers.cs (1)

95definitions.Add(definitionItem);

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (7)

114builder.Add((mappingResult.Symbol, 236targetItems.Add(new InheritanceTargetItem( 241items.Add(new InheritanceMarginItem( 264targetItems.Add(new InheritanceTargetItem( 273items.Add(new InheritanceMarginItem( 669builder.Add(overriddenMember.OriginalDefinition); 763builder.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)

116result.Add(new InlineHint(

InlineHints\AbstractInlineTypeHintsService.cs (3)

96result.Add(new InlineHint( 126finalParts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Text, symbol: null, "...")); 131finalParts.Add(part);

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (1)

455builder.Add(argument);

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (1)

395localVariables.Add(declaredVariable);

IntroduceVariable\AbstractIntroduceVariableService.cs (20)

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (1)

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

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.cs (2)

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

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

212commentsAndNewLines.Add(GetTrivia(startIndex)); 213commentsAndNewLines.Add(GetTrivia(startIndex + 1));

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (18)

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)

356tasks.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)

61linkedIndices.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!); 216parts.Add(ComputeFolderDistance().ToString("X4")); 218parts.Add(_item.DeclaredSymbolInfo.ParameterCount.ToString("X4")); 219parts.Add(_item.DeclaredSymbolInfo.TypeParameterCount.ToString("X4")); 220parts.Add(_item.DeclaredSymbolInfo.Name);

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (2)

340documents.Add(sourceDocumentInfo.DocumentInfo); 353documents.Add(documentInfo);

QuickInfo\CommonSemanticQuickInfoProvider.cs (2)

129invalidProjects.Add(docId.ProjectId); 336filteredSymbols.Add(symbol);

QuickInfo\QuickInfoUtilities.cs (1)

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

Rename\SymbolicRenameInfo.cs (1)

242documentSpans.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)

289invalidProjectsForCurrentSymbol.Add(relatedDocument.Project.Id); 314builder.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\Analyzers\Core\Analyzers\Helpers\HashCodeAnalyzer\HashCodeAnalyzer.OperationDeconstructor.cs (1)

196_hashedSymbols.Add(member);

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\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

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

src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

779builder.Add(value);

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

135postMatches.Add(match.Value);

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

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

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

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

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\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

226methodsAndArgumentToAdd.Add(new ArgumentInsertPositionData<TArgumentSyntax>(

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

58actions.Add(CodeAction.Create(

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

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

166parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(

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

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

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

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

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

39result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: false, generateProperty: false)); 49result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: true, generateProperty: false)); 63result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: false, generateProperty: true)); 66result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: true, generateProperty: true));

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

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

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

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

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

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

57result.Add(parameter);

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

136implementedMembers.Add(member); 139implementedVisibleMembers.Add(member);

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

192statements.Add(this.Service.AddComment( 203statements.Add(g.ExpressionStatement(

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

72builder.Add(trivia); 124builder.Add(triviaList[currentStart + 1]);

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

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

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\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoReader.cs (11)

134builder.Add(ReadInt16(bytes, ref offset)); 196builder.Add(new StateMachineHoistedLocalScope(startOffset, endOffset)); 261flagsBuilder.Add(ReadByte(bytes, ref offset) != 0); 287builder.Add(new DynamicLocalInfo(flagsBuilder.ToImmutable(), slotId, nameBuilder.ToString())); 308builder.Add(DecodeTupleElementNamesInfo(bytes, ref offset)); 321builder.Add(string.IsNullOrEmpty(value) ? null : value); 405externAliasBuilder.Add(importString); 442groupBuilder.Add(importString); 445resultBuilder.Add(groupBuilder.ToImmutable()); 462groupBuilder.Add(importString); 863builder.Add(b);

StackTraceExplorer\StackTraceAnalyzer.cs (1)

62builder.Add(parsedFrame);

StackTraceExplorer\StackTraceExplorerUtilities.cs (1)

72candidateProjects.Add(project);

SymbolSearch\Windows\SymbolSearchUpdateEngine.cs (1)

205result.Add(new PackageWithAssemblyResult(

TaskList\AbstractTaskListService.cs (1)

114items.Add(new TaskListItem(

Testing\AbstractTestMethodFinder.cs (1)

96testMethods.Add(method);

Workspace\CompileTimeSolutionProvider.cs (2)

112configIdsToRemove.Add(configState.Id); 123documentIdsToRemove.Add(documentState.Id);

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)