Length

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (3)

112var useSubMenu = state.ConstructorCandidates.Length > 1; 133=> parameters.Length == 0 || !parameters.Last().IsOptional; 168var results = new FixedSizeArrayBuilder<IntentProcessorResult>(actions.Length);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (2)

103if (constructorParams.Length == 2) 120=> constructorParams.Length != 0 &&

AddFileBanner\AbstractAddFileBannerCodeRefactoringProvider.cs (3)

77if (siblingBanner.Length > 0 && !siblingDocument.IsGeneratedCode(cancellationToken)) 95return banner.Length > 0; 164Debug.Assert(banner.Length > 0);

AddFileBanner\AddFileBannerHelpers.cs (2)

40sourceBanner.Concat(firstToken.LeadingTrivia.Skip(destinationBanner.Length)))); 59var result = new FixedSizeArrayBuilder<SyntaxTrivia>(banner.Length);

AddImport\AbstractAddImportFeatureService.cs (3)

155if (exactReferences.Length > 0) 499var result = new FixedSizeArrayBuilder<(Diagnostic, ImmutableArray<AddImportFixData>)>(diagnostics.Length); 571if (fixesForDiagnostic.Fixes.Length == 1)

AddImport\SearchScopes\SearchScope.cs (2)

54if (symbols.Length > 0) 80var results = new FixedSizeArrayBuilder<SymbolResult<ISymbol>>(symbols.Length);

AddImport\SymbolReferenceFinder.cs (1)

248if (looksGeneric && symbol.GetTypeArguments().Length == 0)

BraceMatching\AbstractDirectiveTriviaBraceMatcher.cs (2)

48if (matchingDirectives.Length > 0) 49matchingDirective = matchingDirectives[(matchingDirectives.IndexOf(directive) + 1) % matchingDirectives.Length];

ChangeSignature\AbstractChangeSignatureService.cs (21)

262var declaredSymbolParametersCount = GetParameters(declaredSymbol).Length; 325if (methodSymbol.Parameters.Length != declaredSymbolParametersCount) 479var argumentsToPermute = arguments.Take(declarationParametersToPermute.Length).ToList(); 485for (var i = 0; i < declarationParametersToPermute.Length; i++) 560for (var i = declarationParametersToPermute.Length; i < arguments.Length; i++) 562if (!arguments[i].IsNamed && removedParams && i >= updatedSignature.UpdatedConfiguration.ToListOfParameters().Length) 584if (realParameters.Length > updatedSignature.OriginalConfiguration.ToListOfParameters().Length) 589var bonusParameters = realParameters.Skip(originalConfigurationParameters.Length); 632if (position >= originalParameters.Length) 694for (var index = 0; index < reorderedParameters.Length; index++) 734var numSeparatorsToSkip = originalParameters.Length - reorderedParameters.Length; 736if (originalParameters.Length == 0) 787for (var i = 0; i < updatedParameters.Length; i++) 840if (indexInListOfPreexistingArguments == parameters.Length - 1 && 1005if (index < permutedParamNodes.Length) 1023while (index < permutedParamNodes.Length) 1047if (argumentCount > methodSymbol.Parameters.Length) 1052if (argumentCount == methodSymbol.Parameters.Length)

ChangeSignature\SignatureChange.cs (4)

30for (var i = 0; i < originalParameterList.Length; i++) 49if (parameterIndex >= OriginalConfiguration.ToListOfParameters().Length) 66numOriginalParameters: originalListOfParameters.Length, 110for (var i = 0; i < originalListWithoutRemovedOrAdded.Length; i++)

CodeFixes\Configuration\ConfigurationUpdater.cs (1)

352var builder = new FixedSizeArrayBuilder<(string optionName, string currentOptionValue, bool isPerLanguage)>(codeStyleOptions.Length);

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

77var hasMultipleOptions = codeStyleOptions.Length > 1;

CodeFixes\Service\CodeFixService.cs (1)

730return newApplicableDiagnostics.Count == applicableDiagnostics.Length

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (7)

59if (diagnosticsAndCodeActions.Length > 0) 64FixAllLogger.LogFixesToMergeStats(functionId, fixAllState.CorrelationId, diagnosticsAndCodeActions.Length); 93progressTracker.AddItems(source.Length); 160if (result.Length > 0) 165FixAllLogger.LogFixesToMergeStats(functionId, fixAllState.CorrelationId, result.Length); 309if (orderedDocuments.Length == 1) 319Debug.Assert(orderedDocuments.Length > 1);

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

57for (var i = 0; i < pragmaActions.Length; i++)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaHelpers.cs (4)

78var index = isStartToken ? triviaList.Length - 1 : 0; 79while (index >= 0 && index < triviaList.Length) 95triviaAtIndex = index >= 0 && index < triviaList.Length 177if (index < trivia.Length)

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

161var builder = new FixedSizeArrayBuilder<SyntaxNode>(attributeRemoveFixes.Length);

CodeFixesAndRefactorings\AbstractFixAllGetFixesService.cs (1)

202using var _ = ArrayBuilder<CodeActionOperation>.GetInstance(operations.Length, out var result);

CodeLens\CodeLensReferencesService.cs (2)

407for (var index = 0; index < parts.Length; index++) 412index < parts.Length - 1)

CodeRefactorings\AddAwait\AbstractAddAwaitCodeRefactoringProvider.cs (1)

46for (var i = expressions.Length - 1; i >= 0; i--)

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (1)

204if (operations.Length == 0)

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

187if (typeNameParts.Length != fileNameParts.Length) 192for (int i = 0, n = typeNameParts.Length; i < n; i++)

CodeRefactorings\MoveType\AbstractMoveTypeService.MoveTypeNamespaceScopeEditor.cs (2)

99var result = new FixedSizeArrayBuilder<SyntaxNode>(syntaxNodes.Length); 100for (int i = 0, n = syntaxNodes.Length; i < n; i++)

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (12)

139if (originalNamespaceDeclarations.Length == 0) 149for (var i = 0; i < originalNamespaceDeclarations.Length; i++) 163Debug.Assert(namespaces.Length == originalNamespaceDeclarations.Length); 281using var _1 = ArrayBuilder<(DocumentId, SyntaxNode)>.GetInstance(ids.Length, out var containers); 337&& typeSymbol.DeclaringSyntaxReferences.Length > 1 392for (var i = 1; i <= parts.Length; ++i) 405var builder = new FixedSizeArrayBuilder<SyntaxNode>(names.Length); 406for (var i = 0; i < names.Length; ++i) 476if (refLocationsInSolution.Length != refLocationsInOtherDocuments.Count) 596Debug.Assert(containersToAddImports.Length > 0); 864if (containers.Length > 1)

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

32=> _newfolders.Length > 0 91var candidates = Enumerable.Range(1, parts.Length) 102var newParts = index >= parts.Length 104: ImmutableArray.Create(parts, index, parts.Length - index);

Completion\CommonCompletionItem.cs (1)

55if (!description.IsDefault && description.Length > 0)

Completion\CommonCompletionUtilities.cs (1)

157return CreateDescriptionAsync(workspaceServices, semanticModel, position, symbol, overloadCount: symbols.Length - 1, options, supportedPlatforms, cancellationToken);

Completion\CompletionItem.cs (1)

201if (_properties.Length > 10)

Completion\CompletionService_GetCompletions.cs (1)

155var additionalAugmentingProviders = ArrayBuilder<CompletionProvider>.GetInstance(triggeredProviders.Length);

Completion\FileSystemCompletionHelper.cs (1)

239if (_allowableExtensions.Length != 0 &&

Completion\Providers\AbstractCrefCompletionProvider.cs (1)

32if (symbols.Length == 0)

Completion\Providers\AbstractOverrideCompletionProvider.cs (1)

46methodSymbol.Parameters.Length == 0)

Completion\Providers\AbstractOverrideCompletionProvider.ItemGetter.cs (1)

108return overridableMembers.Length > 0;

Completion\Providers\AbstractSymbolCompletionProvider.cs (5)

108for (var i = 0; i < syntaxContext.InferredTypes.Length; i++) 162capacity: symbols.Length, 189var noMerge = symbolLists.Length > 1; 265for (index = 0; index < symbolList.Length; ++index) 273return index < symbolList.Length;

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

155bestSymbol = currentValue.bestSymbol.GetParameters().Length > symbol.GetParameters().Length ? symbol : currentValue.bestSymbol;

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

113using var _ = ArrayBuilder<ISymbol>.GetInstance(results[0].Length + results[1].Length, out var symbols); 509else if (symbol is IMethodSymbol { IsExtensionMethod: true, Parameters.Length: > 0 } method)

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

101var builder = new FixedSizeArrayBuilder<KeyValuePair<string, string>>(attributeItems.Length + 1);

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

79builder.EnsureCapacity(ItemInfos.Length);

Completion\Providers\SymbolCompletionItem.cs (5)

115if (symbols.Length > 1) 119else if (symbols.Length == 1) 151if (linkedIds.Length > 0) 199if (symbols.Length == 0) 400if (symbols.Length != 0)

Completion\Providers\UnionCompletionItemComparer.cs (1)

24=> Hash.Combine(obj.DisplayText.GetHashCode(), obj.Tags.Length);

Completion\Utilities.cs (2)

20if (changes.Length == 0) 24else if (changes.Length == 1)

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

232var classNameNode = classSymbol.TypeParameters.Length == 0 330for (var i = 0; i < originalProperties.Length; i++)

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

153if (model.GetOperation(foreachStatement, cancellationToken) is not IForEachLoopOperation operation || operation.Locals.Length != 1)

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

88if (semanticModel.GetOperation(forStatement, cancellationToken) is not ILoopOperation { Locals.Length: 1 })

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (4)

115var labelCount = sections.Sum(section => section.Labels.IsDefault ? 1 : section.Labels.Length); 148case IBlockOperation { Operations: { Length: 1 } statements }: 166if (section.Labels.Length == 1) 169if (section.Labels.Length == 0)

ConvertLinq\AbstractConvertLinqQueryToForEachProvider.cs (1)

75if (Destinations.Length == 1)

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (2)

170if (forEachInfo.Statements.Length == 1 && 177if (forEachInfo.ConvertingExtendedNodes.Length >= 1)

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (3)

79if (stringLiterals.Length == pieces.Count) 84if (stringLiterals.Length > 0) 145using var _ = ArrayBuilder<SyntaxNode>.GetInstance(pieces.Length, out var content);

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (2)

362var namedAndUnnamedArguments = afterPlaceholderArguments.Skip(unnamedArguments.Length).ToImmutableArray(); 413index >= 0 && index < expressions.Length)

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (5)

94if (recordChildActions.Length > 0) 106if (childActions.Length > 0) 673if (fields1.Length != fields2.Length) 678for (var i = 0; i < fields1.Length; i++)

Copilot\CopilotUtilities.cs (1)

87for (int i = 1, n = textChanges.Length; i < n; i++)

Debugging\AbstractBreakpointResolver.cs (4)

166(nameAndArity.Arity == 0 || nameAndArity.Arity == typeSymbol.TypeArguments.Length); 221: members.OfType<IMethodSymbol>().Where(m => m.TypeParameters.Length == nameAndArity.Arity); 286IMethodSymbol method => method.Parameters.Length != parameterCount, 287IPropertySymbol property => property.Parameters.Length != parameterCount,

Diagnostics\Analyzers\UnboundIdentifiersDiagnosticAnalyzerBase.cs (1)

72if (info.Symbol == null && info.CandidateSymbols.Length == 0)

Diagnostics\Service\DiagnosticAnalyzerService_CompilationWithAnalyzersPair.cs (1)

139if (projectAnalyzers.Count == analyzers.Length)

Diagnostics\Service\DiagnosticAnalyzerService_ComputeDiagnosticAnalysisResults.cs (1)

96if (compilationWithAnalyzers?.Analyzers.Length > 0)

Diagnostics\Service\DiagnosticAnalyzerService_GetDiagnosticsForSpan.cs (2)

225using var _1 = ArrayBuilder<DiagnosticAnalyzer>.GetInstance(analyzers.Length, out var filteredAnalyzers); 309if (analyzers.Length == 0)

Diagnostics\Service\DocumentAnalysisExecutor.cs (4)

150Debug.Assert(diags.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diags, compilation).Count()); 151Debug.Assert(diagnostics.Length == Extensions.ConvertToLocalDiagnostics(diags, textDocument, span).Length); 358var builder = new FixedSizeArrayBuilder<DiagnosticData>(diagnostics.Length);

DocumentationComments\AbstractDocumentationCommentFormattingService.cs (1)

551if (typeArgs.Length > typeParameterIndex)

DocumentHighlighting\AbstractDocumentHighlightsService.cs (1)

221symbol.Locations.Length > 0)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (30)

EditAndContinue\ActiveStatementsMap.cs (2)

301if (start == spans.Length) 319while (end < spans.Length && startPositionComparer(spans[end], spanStart) == 0)

EditAndContinue\DebuggingSession.cs (4)

705for (var i = 0; i < documentIds.Length; i++) 782for (var i = 0; i < oldDocumentActiveStatements.Length; i++) 803spans.AddMany([], documentIds.Length); 837Debug.Assert(spans.Count == documentIds.Length);

EditAndContinue\DebuggingSessionTelemetry.cs (2)

111map["RudeEditsCount"] = editSessionData.RudeEdits.Length; 114map["EmitDeltaErrorIdCount"] = editSessionData.EmitErrorIds.Length;

EditAndContinue\DocumentActiveStatementChanges.cs (7)

21Contract.ThrowIfFalse(oldSpans.Length == newStatements.Length); 22Contract.ThrowIfFalse(oldSpans.Length == newExceptionRegions.Length); 25for (var i = 0; i < oldSpans.Length; i++) 28Debug.Assert(oldSpans[i].ExceptionRegions.Spans.Length == newExceptionRegions[i].Length);

EditAndContinue\DocumentAnalysisResults.cs (3)

153Debug.Assert(lineEditsOpt.Select(edit => edit.FileName).Distinct().Count() == lineEditsOpt.Length); 159Debug.Assert(exceptionRegionsOpt.Length == activeStatementsOpt.Length);

EditAndContinue\EditSession.cs (8)

128if (emitResult.ChangedTypes.Length == 0) 833if (analysis.ActiveStatements.Length > 0) 1652Debug.Assert(oldActiveStatements.Length == newExceptionRegions.Length); 1653Debug.Assert(newActiveStatements.Length == newExceptionRegions.Length); 1655for (var i = 0; i < newActiveStatements.Length; i++) 1713for (var j = 0; j < oldActiveStatementExceptionRegions.Spans.Length; j++)

EditAndContinue\EmitSolutionUpdateResults.cs (1)

431if (transientDiagnostics.Length > 0)

EditAndContinue\Utilities\Extensions.cs (3)

217=> method.Parameters.Length > 0 && 218method.Parameters.Length == constructor.Parameters.Length &&

EmbeddedLanguages\DateAndTime\LanguageServices\DateAndTimeLanguageDetector.cs (1)

175var parameter = argIndex < parameters.Length ? parameters[argIndex.Value] : null;

EmbeddedLanguages\EmbeddedLanguageDetector.cs (2)

195if (impl is not IMethodSymbol { Parameters.Length: >= 1 } method) 508if (attribute.ConstructorArguments.Length == 0)

EmbeddedLanguages\Json\JsonNodes.cs (8)

34internal override int ChildCount => Sequence.Length + 1; 38if (index == Sequence.Length) 107internal override int ChildCount => 2 + Sequence.NodesAndTokens.Length; 114if (index == Sequence.NodesAndTokens.Length + 1) 145internal override int ChildCount => 2 + Sequence.Length; 152if (index == Sequence.Length + 1) 298internal override int ChildCount => Sequence.Length + 4; 311if (index == Sequence.Length + 3)

EmbeddedLanguages\Json\JsonParser.cs (1)

179else if (sequence.Length >= 2)

EmbeddedLanguages\Json\JsonParser.JsonNetSyntaxChecks.cs (1)

163for (int i = 0, n = sequence.Length - 1; i < n; i++)

EmbeddedLanguages\Json\JsonParser.StrictSyntaxChecker.cs (5)

118if (!allowTrailingComma && node.Sequence.NodesAndTokens.Length != 0 && node.Sequence.NodesAndTokens.Length % 2 == 0) 132for (int i = 0, n = sequence.Length; i < n; i++) 147if (!allowTrailingComma && sequence.Length != 0 && sequence.Length % 2 == 0)

EmbeddedLanguages\Json\LanguageServices\AbstractJsonDetectionAnalyzer.cs (1)

88var properties = strictTree != null && strictTree.Diagnostics.Length == 0

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexClassifier.cs (1)

309for (var i = 1; i < node.SequenceList.NodesAndTokens.Length; i += 2)

EmbeddedLanguages\RegularExpressions\RegexNodes.cs (4)

59internal override int ChildCount => Children.Length; 585Debug.Assert(sequenceList.NodesAndTokens.Length > 0); 586for (var i = 1; i < sequenceList.NodesAndTokens.Length; i += 2) 594internal override int ChildCount => SequenceList.NodesAndTokens.Length;

EmbeddedLanguages\RegularExpressions\RegexParser.cs (6)

401if (lastTextToken.Diagnostics.Length == 0 && 402nextTextToken.Diagnostics.Length == 0 && 405nextTextToken.LeadingTrivia.Length == 0) 908if (comment.Value.Diagnostics.Length > 0) 1472token.Diagnostics.Length > 0) 1479if (trivia.Diagnostics.Length > 0)

EmbeddedLanguages\StackFrame\StackFrameNodeDefinitions.cs (4)

330internal override int ChildCount => 1 + ArrayRankSpecifiers.Length; 362internal override int ChildCount => 2 + CommaTokens.Length; 415internal override int ChildCount => TypeArguments.NodesAndTokens.Length + 2; 489internal override int ChildCount => 2 + Parameters.NodesAndTokens.Length;

EncapsulateField\AbstractEncapsulateFieldService.cs (2)

65if (fields.Length == 1) 143Contract.ThrowIfTrue(fields.Length == 0);

Extensions\ExtensionMessageHandlerService.cs (2)

209if (handlers.Length == 0) 228if (handlers.Length > 1)

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingSolutionCrawlerLogger.cs (1)

107m[AnalyzerCount] = reordered.Length;

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (2)

44if (results.Length > 0) 82if (results.Length > 0)

ExternalAccess\VSTypeScript\VSTypeScriptTaskListService.cs (1)

33if (result.Length == 0)

ExtractClass\ExtractClassWithDialogCodeAction.cs (1)

146using var _2 = ArrayBuilder<ExtractClassMemberAnalysisResult>.GetInstance(memberAnalysisResults.Length, out var remainingResults);

ExtractMethod\MethodExtractor.Analyzer.cs (5)

326var result = new FixedSizeArrayBuilder<VariableInfo>(variableInfos.Length); 358for (var i = 0; i < variableInfo.Length; i++) 835Contract.ThrowIfFalse(parameters.Length == arguments.Length); 837for (var i = 0; i < parameters.Length; i++)

ExtractMethod\MethodExtractor.CodeGenerator.cs (2)

284expressions.Length == 0 ? null : 285expressions.Length == 1 ? expressions[0] :

ExtractMethod\UniqueNameGenerator.cs (1)

25n => _semanticModel.LookupSymbols(contextNode.SpanStart, container: null, n).Length == 0);

FindUsages\DefinitionItem.cs (2)

136Contract.ThrowIfFalse(classifiedSpans.IsEmpty || sourceSpans.Length == classifiedSpans.Length);

FindUsages\DefinitionsAndReferences.cs (1)

37for (int i = 0, n = references.Length; i < n; i++)

FullyQualify\AbstractFullyQualifyCodeFixProvider.cs (2)

39if (fixData.IndividualFixData.Length == 0) 53if (codeActions.Length >= 2)

FullyQualify\AbstractFullyQualifyService.cs (1)

238if (looksGeneric && searchResult.TypeArguments.Length == 0)

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

244method.Parameters.Length >= 2 &&

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (3)

49[.. _state.Parameters.Select(t => t.parameter).Take(_state.DelegatedConstructor.Parameters.Length)]); 56for (var i = _state.DelegatedConstructor.Parameters.Length; i < _state.Parameters.Length; i++)

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (1)

227if (viableMembers.Length == 0)

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.FieldDelegatingCodeAction.cs (1)

41for (var i = 0; i < _state.Parameters.Length; i++)

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (5)

102orderby c.Parameters.Length descending 103where c.Parameters.Length > 0 && c.Parameters.Length < parameters.Length 106let symbolTypes = parameters.Take(c.Parameters.Length).Select(p => p.parameter.Type)

GenerateEqualsAndGetHashCodeFromMembers\AbstractGenerateEqualsAndGetHashCodeService.cs (2)

158if (components.Length > 0 && hashCodeType != null) 183if (components.Length >= 2 && valueTupleType != null)

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (4)

105if (viableMembers.Length == 0) 130m.Parameters.Length == 2 && 161.Any(m => m is IMethodSymbol { Parameters.Length: 1, IsStatic: false, IsImplicitlyDeclared: false }); 165.Any(m => m is IMethodSymbol { Parameters.Length: 0, IsStatic: false, IsImplicitlyDeclared: false });

GenerateFromMembers\GenerateFromMembersHelpers.cs (2)

31if (selectedDeclarations.Length > 0) 36if (selectedMembers.Length > 0)

GenerateOverrides\GenerateOverridesCodeRefactoringProvider.cs (1)

52if (overridableMembers.Length == 0)

GenerateOverrides\GenerateOverridesWithDialogCodeAction.cs (2)

54if (result.IsCanceled || result.Members.Length == 0) 62var afterThisLocation = result.Members.Length == 1

GenerateType\AbstractGenerateTypeService.cs (1)

79if (actions.Length > 1)

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

629property.Parameters.Length == 0 &&

GenerateType\AbstractGenerateTypeService.GenerateNamedType.cs (1)

248baseConstructorArguments: c.Parameters.Length == 0

GoToBase\AbstractGoToBaseService.cs (1)

45if (bases.Length == 0 && symbol is IMethodSymbol { MethodKind: MethodKind.Constructor } constructor)

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (3)

209if (nonLocalImports.Length == 0) 572var projectState = definition.SourceSpans.Length > 0 718if (locations.Length > 1)

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (5)

424var enumIsDefinedGenericMethod = (IMethodSymbol?)enumIsDefinedMembers.FirstOrDefault(m => m is IMethodSymbol { IsStatic: true, Arity: 1, Parameters.Length: 1 }); 425var enumIsDefinedNonGenericMethod = (IMethodSymbol?)enumIsDefinedMembers.FirstOrDefault(m => m is IMethodSymbol { IsStatic: true, Arity: 0, Parameters.Length: 2 }); 643var enumIsDefinedGenericMethod = enumType.GetMembers(nameof(Enum.IsDefined)).FirstOrDefault(m => m is IMethodSymbol { IsStatic: true, Arity: 1, Parameters.Length: 1 }); 723.FirstOrDefault(s => s is IMethodSymbol { IsStatic: true, Arity: 1, Parameters.Length: 2 }); 815for (var i = parameterIndex + 1; i < methodSymbol.Parameters.Length; i++)

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (7)

167if (parameters.Length < 2) 364Debug.Assert(parameters.Length >= 2); 365Debug.Assert(fieldsOrProperties.Length > 0); 366Debug.Assert(parameters.Length == fieldsOrProperties.Length); 379for (var i = 0; i < parameters.Length; i++) 591for (int i = 0, n = targetTuple.Elements.Length; i < n; i++)

InlineHints\AbstractInlineTypeHintsService.cs (2)

85var preferredParts = minimalDisplayParts.Length <= displayParts.Length ? minimalDisplayParts : displayParts;

InlineHints\InlineHint.cs (1)

46if (displayParts.Length == 0)

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

450if (allReferencedLocations.Length == 1 486return parametersWithVariableDeclarationArgument.Length == 1

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (2)

101if (actions.Value.actions.Length > 0) 110if (actions.Value.actionsAllOccurrences.Length > 0)

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (3)

110if (operation?.Declarations.Length != 1) 114if (localDeclaration.Declarators.Length != 1) 373for (var statementIndex = 0; statementIndex < statementsFromDeclarationToEnd.Length; statementIndex++)

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (4)

124if (conditionalDirectives.Length != 3) 395=> subsequentStatementRanges.Length == 1 && IsSingleStatementStatementRange(subsequentStatementRanges[0]); 459singleExitPoint = flow.ExitPoints.Length == 1 ? flow.ExitPoints[0] : null; 466return subsequentStatementRanges.Length == 1 &&

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.cs (3)

68if (directStructuralTypeReferences.Length == 0) 80if (transitiveStructuralTypeReferences.Length > 0) 86for (var i = 0; i < transitiveStructuralTypeReferences.Length; i++)

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

369Contract.ThrowIfFalse(symbolGroup.Length > 0); 378Contract.ThrowIfFalse(symbolGroup.Length > 0); 594for (var i = 0; i < typeArguments.Length; i++) 819var count = typeParameters.Length;

LanguageServices\SymbolDisplayService\AbstractSymbolDisplayService.cs (2)

23if (symbols.Length == 0) 33if (symbols.Length == 0)

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (7)

45if (parameterNames.Length > 0) 50for (var i = 0; i < parameterNames.Length; i++) 69if (typeParameterNames.Length > 0) 74for (var i = 0; i < typeParameterNames.Length; i++) 103if (exceptionTypes.Length > 0) 108for (var i = 0; i < exceptionTypes.Length; i++) 112for (var j = 0; j < rawExceptionTexts.Length; j++)

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)

89var typeArgIndices = Enumerable.Range(0, _selectedType.TypeParameters.Length)

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

67if (elements.IsDefaultOrEmpty || argumentIndex >= elements.Length)

NavigateTo\AbstractNavigateToSearchService.cs (1)

41using var _1 = ArrayBuilder<INavigateToSearchResult>.GetInstance(items.Length, out var results);

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (2)

233for (var i = s_kindPairs.Length - 1; i >= 0; i--) 323return (int)item < _lookupTable.Length

NavigateTo\NavigateToSearcher.cs (2)

241var projectCount = orderedProjects.Sum(g => g.Length); 389using var _ = ArrayBuilder<INavigateToSearchResult>.GetInstance(results.Length, out var nonDuplicates);

NavigateTo\RoslynNavigateToItem.cs (1)

139if (item.AdditionalMatchingProjects.Length > 0)

NavigationBar\AbstractNavigationBarItemService.cs (2)

54if (allReferences.Length == 0) 59if (referencesInCurrentFile.Length > 0)

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (2)

194if (sourceDocuments.Length == 0) 258if (documentInfos.Length > 0)

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (1)

58if (allDestinations.Length == 0)

QuickInfo\CommonSemanticQuickInfoProvider.cs (1)

137=> symbols.Length > 0

QuickInfo\Presentation\QuickInfoContentBuilder.cs (1)

129if (quickInfoItem.RelatedSpans.Length > 0)

QuickInfo\QuickInfoSection.cs (1)

49if (TaggedParts.Length == 0)

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (5)

115getMethod.Parameters.Length == 0 && 117getMethod.DeclaringSyntaxReferences.Length == 1 && 148setMethod.DeclaringSyntaxReferences.Length == 1; 440Debug.Assert(method.DeclaringSyntaxReferences.Length == 1); 456if (definition?.DeclaringSyntaxReferences.Length > 0)

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (4)

139.Any(m => m.Parameters.Length == 0); 149.Any(m => m.Parameters.Length == 1 && 326if (definition?.DeclaringSyntaxReferences.Length > 0) 421Debug.Assert(property.DeclaringSyntaxReferences.Length == 1);

RQName\RQNodeBuilder.cs (5)

81typeInfos.Insert(0, new RQUnconstructedTypeInfo(currentType.Name, currentType.TypeParameters.Length)); 107if (symbol.ExplicitInterfaceImplementations.Length > 1) 182if (symbol.ExplicitInterfaceImplementations.Length > 1) 227if (symbol.ExplicitInterfaceImplementations.Length > 1) 247var typeParamCount = symbol.TypeParameters.Length;

Shared\Extensions\ISymbolExtensions_2.cs (1)

215if (symbolName == WellKnownMemberNames.DelegateBeginInvokeName && parameter.Ordinal >= (methodSymbol.Parameters.Length - 2))

Shared\Extensions\ISymbolExtensions_Sorting.cs (3)

66var diff = xParameters.Length - yParameters.Length; 72var paramCount = xParameters.Length;

Shared\Utilities\ExtractTypeHelpers.cs (1)

120if (type.TypeParameters.Length == 0)

Shared\Utilities\SupportedPlatformData.cs (4)

24if (InvalidProjects.Length == 0) 49=> InvalidProjects.Length > 0 && InvalidProjects.Length != CandidateProjects.Length;

SignatureHelp\AbstractSignatureHelpProvider.cs (3)

59preferredParameterIndex >= items[selectedItemIndex.Value].Parameters.Length; 90items, applicableSpan, state, items.IndexOf(i => i.Parameters.Length >= 2), parameterIndexOverride: -1); 321if (platformParts.Length == 0)

SignatureHelp\CommonSignatureHelpUtilities.cs (2)

35var argumentCount = argumentNames.Length; 189.WhereAsArray(m => m.Parameters.Length >= 1)

Snippets\RoslynLSPSnippetConverter.cs (2)

86for (var i = 0; i < placeholders.Length; i++) 131if (placeholders.Length > 0)

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

180if (codeActions.Length > 1)

SplitOrMergeIfStatements\Consecutive\AbstractMergeConsecutiveIfStatementsCodeRefactoringProvider.cs (2)

124Debug.Assert(ifGenerator.GetElseIfAndElseClauses(firstIfOrElseIf).Length == 0); 197if (!ifGenerator.IsIfOrElseIf(firstStatement) || ifGenerator.GetElseIfAndElseClauses(firstStatement).Length > 0)

SplitOrMergeIfStatements\Consecutive\AbstractSplitIntoConsecutiveIfStatementsCodeRefactoringProvider.cs (2)

83Debug.Assert(ifGenerator.GetElseIfAndElseClauses(ifOrElseIf).Length == 0); 130if (ifGenerator.GetElseIfAndElseClauses(ifOrElseIf).Length > 0)

src\Analyzers\Core\Analyzers\ConvertTypeofToNameof\AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs (1)

72return namedType.TypeArguments.Length == 0;

src\Analyzers\Core\Analyzers\Helpers\DeserializationConstructorCheck.cs (1)

18methodSymbol.Parameters.Length == 2 &&

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (4)

119.Add(WellKnownDiagnosticTags.Unnecessary, Enumerable.Range(additionalLocations.Length, additionalUnnecessaryLocations.Length)); 190.Add(WellKnownDiagnosticTags.Unnecessary, Enumerable.Range(additionalLocations.Length, additionalUnnecessaryLocations.Length));

src\Analyzers\Core\Analyzers\Helpers\HashCodeAnalyzer\HashCodeAnalyzer.cs (6)

59if (method.Locations.Length != 1 || method.DeclaringSyntaxReferences.Length != 1) 85if (statements.Length != 1) 117if (statements.Length < 3) 128if (variables.Length != 1) 176for (var i = 1; i < statements.Length - 1; i++)

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

80invocation.Arguments.Length == 1)

src\Analyzers\Core\Analyzers\MakeFieldReadonly\AbstractMakeFieldReadonlyDiagnosticAnalyzer.cs (1)

168Locations.Length: 1,

src\Analyzers\Core\Analyzers\MatchFolderAndNamespace\AbstractMatchFolderAndNamespaceDiagnosticAnalyzer.cs (1)

182if (symbol is ITypeSymbol typeSymbol && typeSymbol.DeclaringSyntaxReferences.Length > 1)

src\Analyzers\Core\Analyzers\PopulateSwitch\PopulateSwitchStatementHelpers.cs (1)

20for (var index = switchStatement.Cases.Length - 1; index >= 0; index--)

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer.cs (1)

94if (resolvedSymbols.Length > 0 && !targetHasDocCommentIdFormat)

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (3)

697if (intersect.Length != idsForPragma.Length) 793var isPartial = symbol.Locations.Length > 1;

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

67return namedAttributeArguments.Length > 0;

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

956if (methodSymbol.Parameters.Length == 0) 964methodSymbol.Parameters.Length == 1 &&

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (5)

57var member = type?.GetMembers(name).FirstOrDefault(m => m is IMethodSymbol { IsStatic: false, Parameters.Length: 0 }); 140if (invocation.Arguments.Length == 1 141|| (invocation.Arguments.Length == 2 && UsesInvariantCultureReferenceInsideFormattableStringInvariant(invocation, formatProviderArgumentIndex: 1))) 158|| (invocation.Arguments.Length == 1 && UsesInvariantCultureReferenceInsideFormattableStringInvariant(invocation, formatProviderArgumentIndex: 0))) 277var argCount = invocation.Arguments.Length;

src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (2)

108if (method.Parameters.Length != 1) 169if (members.Length > 0)

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (6)

137DeclaringSyntaxReferences.Length: 1, 343if (property.DeclaringSyntaxReferences.Length != 1) 360if (property.Parameters.Length > 0) 370if (!CanExplicitInterfaceImplementationsBeFixed && property.ExplicitInterfaceImplementations.Length != 0) 438if (attributes.Length > 0 && !@this.SupportsFieldAttributesOnProperties) 527Field.DeclaringSyntaxReferences.Length: 1,

src\Analyzers\Core\Analyzers\UseAutoProperty\AccessedFields.cs (1)

25public int Count => (TrivialField != null ? 1 : 0) + NonTrivialFields.Length;

src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (2)

172collectionExpressionMatches.Value.matches.Length >= collectionInitializerMatches.Value.matches.Length

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

259if (method.Parameters.Length != 1)

src\Analyzers\Core\Analyzers\UseCompoundAssignment\AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs (2)

156operation.OperatorMethod.ContainingType.GetMembers(WellKnownMemberNames.IncrementOperatorName).Length > 0) 176operation.OperatorMethod.ContainingType.GetMembers(WellKnownMemberNames.DecrementOperatorName).Length > 0)

src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (1)

102if (symbolInfo.CandidateSymbols.Length > 0 ||

src\Analyzers\Core\Analyzers\UseConditionalExpression\ForReturn\UseConditionalExpressionForReturnHelpers.cs (1)

64if (ifIndex + 1 >= parentBlock.Operations.Length)

src\Analyzers\Core\Analyzers\UseIsNullCheck\AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs (1)

40m.Parameters.Length == 2);

src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer.cs (1)

88.FirstOrDefault(m => m is { DeclaredAccessibility: Accessibility.Public, Parameters.Length: 2 });

src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer_IfStatement.cs (2)

164if (trueStatements.Length is < 1 or > 2) 168if (trueStatements.Length == 2)

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

189ExplicitInterfaceImplementations.Length: > 0,

src\Analyzers\Core\Analyzers\UseSystemHashCode\UseSystemHashCodeDiagnosticAnalyzer.cs (4)

42if (context.OperationBlocks.Length != 1) 52var elementCount = (accessesBase ? 1 : 0) + (hashedMembers.IsDefaultOrEmpty ? 0 : hashedMembers.Length); 66if (elementCount == 1 && statements.Length < 2) 70Debug.Assert(elementCount >= 2 || statements.Length >= 2);

src\Analyzers\Core\Analyzers\UseThrowExpression\AbstractUseThrowExpressionDiagnosticAnalyzer.cs (2)

175for (var i = ifOperationIndex + 1; i < containingBlock.Operations.Length; i++) 277if (block.Operations.Length != 1)

src\Analyzers\Core\Analyzers\ValidateFormatString\AbstractValidateFormatStringDiagnosticAnalyzer.cs (2)

133if (parameters.Length == 0) 236if (parameterWithMatchingName.IsParams && parameters.Length != arguments.Count)

src\Analyzers\Core\CodeFixes\AddAnonymousTypeMemberName\AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

88var annotation = diagnostics.Length == 1 ? RenameAnnotation.Create() : null;

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

81if (potentialConversionTypes.Length == 1) 85else if (potentialConversionTypes.Length > 1) 198for (var j = 0; j < parameters.Length; j++) 229if (potentialConversionTypes.Length == 1)

src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (2)

121if (parameters.Length == 0) 134var parameterIndex = Math.Min(i, parameters.Length - 1);

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

68if (derivedType.Interfaces.Length != 0)

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (8)

203foreach (var method in methodCandidates.OrderBy(m => m.Parameters.Length)) 237=> method.IsParams() ? method.Parameters.Length - 1 : method.Parameters.Length; 249var fixes = codeFixData.Length <= 2 258var builder = new FixedSizeArrayBuilder<CodeAction>(codeFixData.Length); 318if (cascadingActions.Length > 0) 335var builder = new FixedSizeArrayBuilder<CodeFixData>(methodsAndArgumentsToAdd.Length); 461if (i >= method.Parameters.Length)

src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (2)

47if (method.ExplicitInterfaceImplementations.Length > 0) 65if (method.ExplicitOrImplicitInterfaceImplementations().Length > 0)

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

88for (int i = 0, n = Math.Min(t1NameSegments.Length, t2NameSegments.Length); i < n; i++) 103return t1NameSegments.Length - t2NameSegments.Length;

src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractAddDocCommentNodesCodeFixProvider.cs (1)

65for (var index = 0; index < parameterNames.Length; index++)

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

65var constructorsCount = delegatedConstructor.ContainingType.InstanceConstructors.Length;

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (6)

157var argumentCount = delegatedConstructor.Parameters.Length; 188for (var i = allParameters.Length; i > 0; i--) 249if (ctor.Parameters.Length != ParameterTypes.Length) 252for (var i = 0; i < ParameterTypes.Length; i++) 274=> _arguments.IsDefault || index >= _arguments.Length ? string.Empty : _arguments[index].Name;

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

44return constructor.Parameters.Length == parameters.Length && 87Debug.Assert(constructor.Parameters.Length == expressions.Length); 112for (var i = 0; i < constructorInCompilation.Parameters.Length; i++) 157for (var i = 0; i < parameterNames.Length; i++) 359else if (symbol is IPropertySymbol { Parameters.Length: 0 } property)

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

45m => m.Parameters.Length == 0); 61if (state.UnimplementedConstructors.Length > 1)

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.State.cs (3)

86return UnimplementedConstructors.Length > 0; 94if (classType.Constructors.Any(static c => c.Parameters.Length == 0 && c.IsImplicitlyDeclared)) 96var baseNoArgConstructor = baseType.Constructors.FirstOrDefault(c => c.Parameters.Length == 0);

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeAction.cs (1)

48var baseConstructorArguments = baseConstructor.Parameters.Length != 0

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

60if (typeParameters.Length == 0 && returnType.SpecialType != SpecialType.System_Void)

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.SignatureInfo.cs (3)

176for (var i = 0; i < typeArguments.Length; i++) 205var result = new FixedSizeArrayBuilder<IParameterSymbol>(modifiers.Length); 206for (var i = 0; i < modifiers.Length; i++)

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\TypeParameterSubstitution.cs (2)

62switch (symbol.ConstraintTypes.Length) 94for (var i = 1; i < symbol.ConstraintTypes.Length; i++)

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

204var parameterIndex = containingMethod.Parameters.Length; 206if (containingMethod.Parameters.Length > 0) 211for (var i = containingMethod.Parameters.Length - 1; i >= 0; i--)

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (1)

479if (enclosingMethodSymbol != null && enclosingMethodSymbol.TypeParameters != null && enclosingMethodSymbol.TypeParameters.Length != 0)

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

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

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

179if (state.MembersWithoutExplicitOrImplicitImplementationWhichCanBeImplicitlyImplemented.Length > 0) 211if (state.MembersWithoutExplicitImplementation.Length > 0) 276if (state.MembersWithoutExplicitOrImplicitImplementation.Length != state.MembersWithoutExplicitImplementation.Length) 281for (var i = 0; i < state.MembersWithoutExplicitOrImplicitImplementation.Length; i++)

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

82var allMembersImplemented = state.MembersWithoutExplicitOrImplicitImplementationWhichCanBeImplicitlyImplemented.Length == 0; 83var allMembersImplementedExplicitly = state.MembersWithoutExplicitImplementation.Length == 0; 96var allMembersImplemented = state.MembersWithoutExplicitOrImplicitImplementationWhichCanBeImplicitlyImplemented.Length == 0;

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

33.WhereAsArray(p => !p.IsImplicitlyDeclared && p.Parameters.Length == 0 && p.GetMethod != null && includeMemberType(p.Type)); 46.FirstOrDefault(c => c.Parameters.Length > 0 && c.Parameters[0].IsPrimaryConstructor(cancellationToken)); 253if (member is IMethodSymbol { IsStatic: false, ReturnsVoid: true, Arity: 0, Parameters.Length: 0 } disposeMethod)

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

366method1.TypeParameters.Length == method2.TypeParameters.Length &&

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

75if (method.Parameters.Length != conflictingMethod.Parameters.Length)

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

48if (property is { IsIndexer: false, Parameters.Length: > 0 } &&

src\Analyzers\Core\CodeFixes\MakeMemberStatic\AbstractMakeMemberStaticCodeFixProvider.cs (2)

21if (context.Diagnostics.Length == 1 && 31for (var i = 0; i < diagnostics.Length; i++)

src\Analyzers\Core\CodeFixes\MakeTypeAbstract\AbstractMakeTypeAbstractCodeFixProvider.cs (1)

31for (var i = 0; i < diagnostics.Length; i++)

src\Analyzers\Core\CodeFixes\MatchFolderAndNamespace\AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (1)

85progressTracker.AddItems(documentIdToDiagnosticsMap.Length);

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

125diagnostics.Length == 1, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchExpressionCodeFixProvider.cs (3)

55return arms.Length > 0 && PopulateSwitchExpressionHelpers.IsDefault(arms[^1]) 56? arms.Length - 1 57: arms.Length;

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchStatementCodeFixProvider.cs (3)

86if (cases.Length > 0) 91return cases.Length - 1; 95return cases.Length;

src\Analyzers\Core\CodeFixes\UnsealClass\AbstractUnsealClassCodeFixProvider.cs (1)

44if (definition is not null && definition.DeclaringSyntaxReferences.Length > 0)

src\Analyzers\Core\CodeFixes\UpgradeProject\AbstractUpgradeProjectCodeFixProvider.cs (2)

51if (upgradeableProjects.Length == 0) 62if (upgradeableProjects.Length > 1)

src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

218bannerService.GetLeadingBlankLines(nodeToRemove).Length == 0) 351if (symbols.Length > 0 && symbols.All(s => !s.OriginalDefinition.Equals(property.OriginalDefinition)))

src\Analyzers\Core\CodeFixes\UseAutoProperty\UseAutoPropertyFixAllProvider.cs (1)

60originalContext.Progress.AddItems(contexts.Length);

src\Analyzers\Core\CodeFixes\UseCoalesceExpression\AbstractUseCoalesceExpressionForIfNullStatementCheckCodeFixProvider.cs (2)

57if ((ifStatementLeadingTrivia.Length >= 0 || whenTrueStatementLeadingTrivia.Length >= 0) &&

src\Analyzers\Core\CodeFixes\UseConditionalExpression\ForAssignment\AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs (2)

216if (localDeclaration.Declarations.Length != 1) 223if (declarators.Length != 1)

src\Compilers\Core\AnalyzerDriver\DeclarationComputer.cs (2)

75if (declaredSymbol is INamespaceSymbol namespaceSymbol && namespaceSymbol.ConstituentNamespaces.Length > 1) 81Debug.Assert(assemblyScopedNamespaceSymbol.ConstituentNamespaces.Length == 1);

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

76if (docIdResults.Length > 0) 111if (candidateMembers.Length == 0) 507var count = methodContext.TypeParameters.Length; 550for (int i = 0; i < methodContext.TypeParameters.Length; ++i) 562for (int i = 0; i < containingType.TypeParameters.Length; ++i) 584if (candidateMembers.Length == 0) 777if (symbolParameters.Length != expectedParameters.Length) 846if (index < typeParameters.Length) 861return typeSymbol.TypeParameters.Length + GetTypeParameterCount(typeSymbol.ContainingType);

src\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoEncoder.cs (2)

120builder.WriteInt32(s.Length); 181builder.WriteInt32(info.Names.Length);

src\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoReader.cs (8)

220while (offset < bytes.Length) 424var resultBuilder = ArrayBuilder<ImmutableArray<string>>.GetInstance(groupSizes.Length); 432if (pos >= importStrings.Length) 455for (; pos < importStrings.Length; pos++) 472if (pos < importStrings.Length) 523if (i + sizeof(int) > bytes.Length) 535if (i + sizeof(short) > bytes.Length) 547if (i + sizeof(byte) > bytes.Length)

StackTraceExplorer\AbstractStackTraceSymbolResolver.cs (3)

37return typeArguments.Length == stackFrameTypeArguments.Length; 63if (currentArrayType.Rank != arrayExpression.CommaTokens.Length + 1) 86if (parameters.Length != stackFrameParameters.Parameters.Length)

UnusedReferences\UnusedReferencesRemover.cs (1)

228if (reference.CompilationAssemblies.Length > 0)

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (1)

77if (argumentIndex >= parameters.Length)

Wrapping\AbstractCodeActionComputer.cs (2)

283if (wrappingActions.Length == 0) 290if (wrappingActions.Length == 1 && group.IsInlinable)

Wrapping\BinaryExpression\AbstractBinaryExpressionWrapper.cs (3)

74Debug.Assert(exprsAndOperators.Length >= 3); 75Debug.Assert(exprsAndOperators.Length % 2 == 1, "Should have odd number of exprs and operators"); 76for (var i = 0; i < exprsAndOperators.Length; i++)

Wrapping\BinaryExpression\BinaryExpressionCodeActionComputer.cs (2)

93for (var i = 1; i < _exprsAndOperators.Length; i += 2) 126var count = _exprsAndOperators.Length - 1;

Wrapping\ChainedExpression\AbstractChainedExpressionWrapper.cs (1)

96if (chunks.Length <= 1)

Wrapping\ChainedExpression\ChainedExpressionCodeActionComputer.cs (2)

146for (var i = 1; i < _chunks.Length; i++) 192for (var i = 1; i < chunk.Length; i++)