Length

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (1)

75for (var i = 0; i < _missingParameters.Length; ++i)

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (2)

117var useSubMenu = state.ConstructorCandidates.Length > 1; 143=> parameters.Length == 0 || !parameters.Last().IsOptional;

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (2)

102if (constructorParams.Length == 2) 119=> constructorParams.Length != 0 &&

AddFileBanner\AbstractAddFileBannerCodeRefactoringProvider.cs (1)

164Debug.Assert(banner.Length > 0);

AddFileBanner\AddFileBannerHelpers.cs (1)

59var result = new FixedSizeArrayBuilder<SyntaxTrivia>(banner.Length);

AddImport\AbstractAddImportFeatureService.cs (2)

153if (exactReferences.Length > 0) 522var result = new FixedSizeArrayBuilder<(Diagnostic, ImmutableArray<AddImportFixData>)>(diagnostics.Length);

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)

703return newApplicableDiagnostics.Count == applicableDiagnostics.Length

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (6)

59if (diagnosticsAndCodeActions.Length > 0) 64FixAllLogger.LogFixesToMergeStats(functionId, fixAllState.CorrelationId, diagnosticsAndCodeActions.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)

296for (var index = 0; index < parts.Length; index++) 301index < 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)

128if (originalNamespaceDeclarations.Length == 0) 140for (var i = 0; i < originalNamespaceDeclarations.Length; i++) 156Debug.Assert(namespaces.Length == originalNamespaceDeclarations.Length); 279using var _1 = ArrayBuilder<(DocumentId, SyntaxNode)>.GetInstance(ids.Length, out var containers); 335&& typeSymbol.DeclaringSyntaxReferences.Length > 1 390for (var i = 1; i <= parts.Length; ++i) 403var builder = new FixedSizeArrayBuilder<SyntaxNode>(names.Length); 404for (var i = 0; i < names.Length; ++i) 475if (refLocationsInSolution.Length != refLocationsInOtherDocuments.Count) 604Debug.Assert(containersToAddImports.Length > 0); 823if (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)

45if (!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)

156var 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 (3)

162capacity: symbols.Length, 236for (index = 0; index < symbolList.Length; ++index) 244return index < symbolList.Length;

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

153bestSymbol = currentValue.bestSymbol.Parameters.Length > symbol.Parameters.Length ? symbol : currentValue.bestSymbol;

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)

110if (symbols.Length > 1) 114else if (symbols.Length == 1) 146if (linkedIds.Length > 0) 194if (symbols.Length == 0) 395if (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)

113var labelCount = sections.Sum(section => section.Labels.IsDefault ? 1 : section.Labels.Length); 146case IBlockOperation { Operations: { Length: 1 } statements }: 164if (section.Labels.Length == 1) 167if (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 (1)

145using var _ = ArrayBuilder<SyntaxNode>.GetInstance(pieces.Length, out var content);

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

400index >= 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\ICopilotChangeAnalysisService.cs (1)

59Contract.ThrowIfTrue(new NormalizedTextSpanCollection(changes.Select(c => c.Span)).Count != changes.Length, "'changes' was not normalized.");

Debugging\AbstractBreakpointResolver.cs (4)

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

Diagnostics\Analyzers\UnboundIdentifiersDiagnosticAnalyzerBase.cs (1)

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

Diagnostics\Service\DocumentAnalysisExecutor.cs (1)

365var builder = new FixedSizeArrayBuilder<DiagnosticData>(diagnostics.Length);

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

206using var _ = ArrayBuilder<DiagnosticAnalyzer>.GetInstance(analyzers.Length, out var filteredAnalyzers);

DocumentHighlighting\AbstractDocumentHighlightsService.cs (1)

216symbol.Locations.Length > 0)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (26)

789var map = new Dictionary<SyntaxNode, EditKind>(editScript.Edits.Length); 837Debug.Assert(oldActiveStatements.Length == newActiveStatements.Count); 838Debug.Assert(oldActiveStatements.Length == newExceptionRegions.Count); 1003Debug.Assert(newActiveStatementSpans.IsEmpty || oldActiveStatements.Length == newActiveStatementSpans.Length); 1004Debug.Assert(oldActiveStatements.IsEmpty || oldActiveStatements.Length == newActiveStatements.Count); 2513oldMethod.TypeParameters.Length == newMethod.TypeParameters.Length && 2574if (editScript.Edits.Length == 0 && triviaEdits.Count == 0) 4695for (var i = 0; i < newAttributes.Length; i++) 4978if (newDiagnosticSymbol.DeclaringSyntaxReferences.Length > 0 && !newDiagnosticSymbol.IsImplicitlyDeclared) 5210if (attributes.Length == 0) 5224if (attribute.AttributeClass.Equals(layoutAttribute) && attribute.ConstructorArguments.Length == 1) 5410else if (newCtor.Parameters.Length == 0) 5542member.DeclaringSyntaxReferences.Length > 0) // skip generated fields (e.g. VB auto-property backing fields) 5564return type.InstanceConstructors.FirstOrDefault(m => m.Parameters.Length == 0); 5577symbol.DeclaringSyntaxReferences.Length > 1 && symbol.DeclaringSyntaxReferences.Any(IsNotInDocument, tree); 5793using var _1 = ArrayBuilder<int>.GetInstance(newInLambdaCaptures.Length, fillWithValue: 0, out var reverseCapturesMap); 5796using var _2 = ArrayBuilder<SyntaxNode?>.GetInstance(newInLambdaCaptures.Length, fillWithValue: null, out var newCapturesToClosureScopes); 5800using var _3 = ArrayBuilder<SyntaxNode?>.GetInstance(oldInLambdaCaptures.Length, fillWithValue: null, out var oldCapturesToClosureScopes); 6130var result = BitVector.Create(captures.Length); 6155for (var i = 0; i < array.Length; i++) 6310for (var oldCaptureIndex = 0; oldCaptureIndex < oldCaptures.Length; oldCaptureIndex++) 6329for (var newCaptureIndex = 0; newCaptureIndex < newCaptures.Length; newCaptureIndex++) 6479for (var i = 0; i < oldLambdaSymbol.Parameters.Length; i++) 6484for (var i = 0; i < oldLambdaSymbol.TypeParameters.Length; i++)

EditAndContinue\ActiveStatementsMap.cs (2)

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

EditAndContinue\DebuggingSession.cs (3)

681for (var i = 0; i < documentIds.Length; i++) 776spans.AddMany([], documentIds.Length); 810Debug.Assert(spans.Count == documentIds.Length);

EditAndContinue\DebuggingSessionTelemetry.cs (2)

107map["RudeEditsCount"] = editSessionData.RudeEdits.Length; 110map["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) 681if (analysis.ActiveStatements.Length > 0) 1327Debug.Assert(oldActiveStatements.Length == newExceptionRegions.Length); 1328Debug.Assert(newActiveStatements.Length == newExceptionRegions.Length); 1330for (var i = 0; i < newActiveStatements.Length; i++) 1390for (var j = 0; j < oldActiveStatementExceptionRegions.Spans.Length; j++)

EditAndContinue\Utilities\Extensions.cs (3)

182=> method.Parameters.Length > 0 && 183method.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) 501if (attribute.ConstructorArguments.Length == 0)

EmbeddedLanguages\Json\JsonNodes.cs (6)

34internal override int ChildCount => Sequence.Length + 1; 38if (index == Sequence.Length) 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)

180else 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 (3)

131for (int i = 0, n = sequence.Length; i < n; i++) 146if (!allowTrailingComma && sequence.Length != 0 && sequence.Length % 2 == 0)

EmbeddedLanguages\RegularExpressions\RegexNodes.cs (1)

59internal override int ChildCount => Children.Length;

EmbeddedLanguages\StackFrame\StackFrameNodeDefinitions.cs (2)

330internal override int ChildCount => 1 + ArrayRankSpecifiers.Length; 362internal override int ChildCount => 2 + CommaTokens.Length;

EncapsulateField\AbstractEncapsulateFieldService.cs (2)

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

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

107m[AnalyzerCount] = reordered.Length;

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (1)

44if (results.Length > 0)

ExtractClass\ExtractClassWithDialogCodeAction.cs (1)

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

ExtractMethod\MethodExtractor.Analyzer.cs (2)

326var result = new FixedSizeArrayBuilder<VariableInfo>(variableInfos.Length); 358for (var i = 0; i < variableInfo.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\AbstractFullyQualifyService.cs (1)

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

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

244method.Parameters.Length >= 2 &&

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (3)

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

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.FieldDelegatingCodeAction.cs (1)

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

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (5)

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

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (3)

131m.Parameters.Length == 2 && 162.Any(m => m.Parameters.Length == 1 && !m.IsStatic); 166.Any(m => m.Parameters.Length == 0 && !m.IsStatic);

GenerateOverrides\GenerateOverridesWithDialogCodeAction.cs (2)

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

GenerateType\AbstractGenerateTypeService.cs (1)

78if (actions.Length > 1)

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

629property.Parameters.Length == 0 &&

GoToBase\AbstractGoToBaseService.cs (1)

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

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (2)

572var projectState = definition.SourceSpans.Length > 0 717if (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 (6)

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

InlineHints\AbstractInlineTypeHintsService.cs (2)

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

InlineHints\InlineHint.cs (1)

46if (displayParts.Length == 0)

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (1)

488return parametersWithVariableDeclarationArgument.Length == 1

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (2)

110if (operation?.Declarations.Length != 1) 114if (localDeclaration.Declarators.Length != 1)

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (3)

286=> subsequentStatementRanges.Length == 1 && IsSingleStatementStatementRange(subsequentStatementRanges[0]); 350singleExitPoint = flow.ExitPoints.Length == 1 ? flow.ExitPoints[0] : null; 357return 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 (3)

285Contract.ThrowIfFalse(symbolGroup.Length > 0); 294Contract.ThrowIfFalse(symbolGroup.Length > 0); 735var count = typeParameters.Length;

LanguageServices\SymbolDisplayService\AbstractSymbolDisplayService.cs (2)

37if (symbols.Length == 0) 49if (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)

42using 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 (1)

54if (allReferences.Length == 0)

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (2)

203if (sourceDocuments.Length == 0) 270if (documentInfos.Length > 0)

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (1)

58if (allDestinations.Length == 0)

QuickInfo\CommonSemanticQuickInfoProvider.cs (1)

135=> symbols.Length > 0

QuickInfo\Presentation\QuickInfoContentBuilder.cs (1)

129if (quickInfoItem.RelatedSpans.Length > 0)

QuickInfo\QuickInfoSection.cs (1)

51if (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 && 322if (definition?.DeclaringSyntaxReferences.Length > 0) 417Debug.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)

213if (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 (2)

63preferredParameterIndex >= items[selectedItemIndex.Value].Parameters.Length; 324if (platformParts.Length == 0)

SignatureHelp\CommonSignatureHelpUtilities.cs (1)

35var argumentCount = argumentNames.Length;

Snippets\RoslynLSPSnippetConverter.cs (2)

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

SplitOrMergeIfStatements\Consecutive\AbstractMergeConsecutiveIfStatementsCodeRefactoringProvider.cs (1)

197if (!ifGenerator.IsIfOrElseIf(firstStatement) || ifGenerator.GetElseIfAndElseClauses(firstStatement).Length > 0)

SplitOrMergeIfStatements\Consecutive\AbstractSplitIntoConsecutiveIfStatementsCodeRefactoringProvider.cs (1)

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)

20methodSymbol.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 (8)

67if (method.Locations.Length != 1 || method.DeclaringSyntaxReferences.Length != 1) 93if (statements.Length != 1) 125if (statements.Length < 3) 139if (variables.Length != 1 || 140varDeclStatement.Declarations.Length != 1) 146if (declaration.Declarators.Length != 1) 196for (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)

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

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

793var isPartial = symbol.Locations.Length > 1;

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

69return namedAttributeArguments.Length > 0;

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

817if (methodSymbol.Parameters.Length == 0) 825methodSymbol.Parameters.Length == 1 &&

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

99if (invocation.Arguments.Length == 1 100|| (invocation.Arguments.Length == 2 && UsesInvariantCultureReferenceInsideFormattableStringInvariant(invocation, formatProviderArgumentIndex: 1))) 117|| (invocation.Arguments.Length == 1 && UsesInvariantCultureReferenceInsideFormattableStringInvariant(invocation, formatProviderArgumentIndex: 0))) 216var argCount = invocation.Arguments.Length;

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

103if (method.Parameters.Length != 1) 160if (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)

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

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

239if (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)

58if (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)

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

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

187ExplicitInterfaceImplementations.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)

84if (potentialConversionTypes.Length == 1) 88else if (potentialConversionTypes.Length > 1) 201for (var j = 0; j < parameters.Length; j++) 232if (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 (7)

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); 335var builder = new FixedSizeArrayBuilder<CodeFixData>(methodsAndArgumentsToAdd.Length); 461if (i >= method.Parameters.Length)

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

47if (method.ExplicitInterfaceImplementations.Length > 0)

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

89for (int i = 0, n = Math.Min(t1NameSegments.Length, t2NameSegments.Length); i < n; i++) 104return 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)

163var argumentCount = delegatedConstructor.Parameters.Length; 194for (var i = allParameters.Length; i > 0; i--) 255if (ctor.Parameters.Length != ParameterTypes.Length) 258for (var i = 0; i < ParameterTypes.Length; i++) 280=> _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)

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

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

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

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

184for (var i = 0; i < typeArguments.Length; i++) 213var result = new FixedSizeArrayBuilder<IParameterSymbol>(modifiers.Length); 214for (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\ImplementInterface\AbstractImplementInterfaceCodeFixProvider.cs (5)

131if (state.MembersWithoutExplicitOrImplicitImplementationWhichCanBeImplicitlyImplemented.Length > 0) 163if (state.MembersWithoutExplicitImplementation.Length > 0) 177if (state.MembersWithoutExplicitOrImplicitImplementation.Length != state.MembersWithoutExplicitImplementation.Length) 182for (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)

34.Where(p => !p.IsImplicitlyDeclared && p.Parameters.Length == 0 && p.GetMethod != null) 49.FirstOrDefault(c => c.Parameters.Length > 0 && c.Parameters[0].IsPrimaryConstructor(cancellationToken)); 256if (member is IMethodSymbol { IsStatic: false, ReturnsVoid: true, Arity: 0, Parameters.Length: 0 } disposeMethod)

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

372method1.TypeParameters.Length == method2.TypeParameters.Length &&

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

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

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

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

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

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

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

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

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

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

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

60return arms.Length > 0 && PopulateSwitchExpressionHelpers.IsDefault(arms[^1]) 61? arms.Length - 1 62: 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\UseConditionalExpression\ForAssignment\AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs (2)

218if (localDeclaration.Declarations.Length != 1) 225if (declarators.Length != 1)

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

55if (declaredSymbol is INamespaceSymbol namespaceSymbol && namespaceSymbol.ConstituentNamespaces.Length > 1) 61Debug.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)

219while (offset < bytes.Length) 423var resultBuilder = ArrayBuilder<ImmutableArray<string>>.GetInstance(groupSizes.Length); 431if (pos >= importStrings.Length) 454for (; pos < importStrings.Length; pos++) 471if (pos < importStrings.Length) 522if (i + sizeof(int) > bytes.Length) 534if (i + sizeof(short) > bytes.Length) 546if (i + sizeof(byte) > bytes.Length)

StackTraceExplorer\AbstractStackTraceSymbolResolver.cs (3)

36return typeArguments.Length == stackFrameTypeArguments.Length; 62if (currentArrayType.Rank != arrayExpression.CommaTokens.Length + 1) 85if (parameters.Length != stackFrameParameters.Parameters.Length)

UnusedReferences\UnusedReferencesRemover.cs (1)

228if (reference.CompilationAssemblies.Length > 0)

UseAutoProperty\UseAutoPropertyFixAllProvider.cs (1)

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

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