Item

src\4f0789c9734b88bf\CSharpInitializeParameterService.cs (2)

88if (tupleRight.Elements[i] is IParameterReferenceOperation parameterReference && sibling.Equals(parameterReference.Parameter) && 89IsFieldOrPropertyReference(tupleLeft.Elements[i], sibling.ContainingType, out _))

src\roslyn\src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (2)

180if (!CanConvertTypes(leftArguments[i], rightArguments[i], model))

src\roslyn\src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (1)

231var parameter = method.Parameters[index];

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForFluentCodeFixProvider.cs (2)

112var match = matches[i]; 160var argument = matches[i].Node;

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionInitializer\CSharpUseCollectionInitializerCodeFixProvider_CollectionInitializer.cs (1)

43var match = matches[i];

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseExplicitArrayInExpressionTree\CSharpUseExplicitArrayInExpressionTreeCodeFixProvider.cs (2)

82var originalParameter = originalMethod.Parameters[i]; 83var currentParameter = currentMethod.Parameters[i];

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseExplicitTypeCodeFixProvider.cs (1)

196var type = elements[i].Type;

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseObjectInitializer\CSharpUseObjectInitializerCodeFixProvider.cs (1)

82var match = matches[i];

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SemanticModelExtensions.cs (1)

73.Select((name, index) => new ParameterName(name, isFixed[index]))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (4)

369.Select(tupleType => new TypeInferenceInfo(tupleType.TupleElements[index].Type)); 714DetermineTypeParameterMapping(inferredNamedType.TypeArguments[i], returnNamedType.TypeArguments[i], result); 797var parameter = parameterSet[index];

ChangeSignature\CSharpChangeSignatureService.cs (1)

841dictionary.Add(originalParameters[i].Name.ToString(), paramNode);

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (2)

422var part = namespaceParts[index].EscapeIdentifier(); 435var part = namespaceParts[index].EscapeIdentifier();

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (2)

388expression = MemberAccessExpression(SimpleMemberAccessExpression, expression, names[i]); 395subpattern = Subpattern(names[i], RecursivePattern(subpattern));

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider_Operators.cs (1)

84var (opName, position) = s_operatorInfo[i];

Completion\CompletionProviders\TupleNameCompletionProvider.cs (1)

104var field = type.TupleElements[index];

ConvertAnonymousType\CSharpConvertAnonymousTypeToTupleCodeRefactoringProvider.cs (2)

49if (i == n - 1 && i < originalSeparators.Length && originalSeparators[i].TrailingTrivia is [.., (kind: SyntaxKind.EndOfLineTrivia) newLine]) 56result.Add(originalSeparators[i]);

ConvertIfToSwitch\CSharpConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)

49var label = section.Labels[i];

ConvertLinq\ConvertForEachToLinqQuery\AbstractConverter.cs (1)

233var node = ForEachInfo.ConvertingExtendedNodes[extendedNodeIndex];

GenerateType\CSharpGenerateTypeService.cs (2)

69var typeParameter = parameterIndex < type.TypeParameters.Length ? type.TypeParameters[parameterIndex] : null; 76var typeParameter = parameterIndex < method.TypeParameters.Length ? method.TypeParameters[parameterIndex] : null;

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (2)

159if (!DefaultValueMatches(implParameters[i], interfaceParameters[i]))

IntroduceVariable\CSharpIntroduceLocalForExpressionCodeRefactoringProvider.cs (1)

105if (field.Name == tupleUnderlyingType.TupleElements[index].Name)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

165var lambdaParameter = lambdaMethod.Parameters[i]; 166var invokedParameter = invokedMethod.Parameters[i];

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnreachableCode\RemoveUnreachableCodeHelpers.cs (1)

63var currentStatement = siblingStatements[i];

src\roslyn\src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (1)

203var element = arrayCreationElements[startIndex + i];

src\roslyn\src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (2)

180if (!CanConvertTypes(leftArguments[i], rightArguments[i], model))

src\roslyn\src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (1)

231var parameter = method.Parameters[index];

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForFluentCodeFixProvider.cs (2)

112var match = matches[i]; 160var argument = matches[i].Node;

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionInitializer\CSharpUseCollectionInitializerCodeFixProvider_CollectionInitializer.cs (1)

43var match = matches[i];

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseExplicitArrayInExpressionTree\CSharpUseExplicitArrayInExpressionTreeCodeFixProvider.cs (2)

82var originalParameter = originalMethod.Parameters[i]; 83var currentParameter = currentMethod.Parameters[i];

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseExplicitTypeCodeFixProvider.cs (1)

196var type = elements[i].Type;

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseObjectInitializer\CSharpUseObjectInitializerCodeFixProvider.cs (1)

82var match = matches[i];

ChangeSignature\AbstractChangeSignatureService.cs (16)

487var decl = declarationParametersToPermute[i]; 562if (!arguments[i].IsNamed && removedParams && i >= updatedSignature.UpdatedConfiguration.ToListOfParameters().Length) 567if (!arguments[i].IsNamed || updatedSignature.UpdatedConfiguration.ToListOfParameters().Any(static (p, arg) => p.Name == arg.arguments[arg.i].GetName(), (arguments, i))) 569newArguments.Add(arguments[i]); 637parametersToPermute.Add(originalParameters[position]); 696var newParam = reorderedParameters[index]; 790if (updatedParameters[i] != signaturePermutation.UpdatedConfiguration.ThisParameter 794if (updatedParameters[i] is AddedParameter addedParameter) 841parameters[indexInListOfPreexistingArguments].IsParams) 849var newArgument = CreateExplicitParamsArrayFromIndividualArguments(newArguments, indexInListOfPreexistingArguments, parameters[indexInListOfPreexistingArguments]); 850newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name); 856newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name); 883newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name); 1007updatedNodeList.Add(permutedParamNodes[index].WithLeadingTrivia(content.GetLeadingTrivia()).WithTrailingTrivia(content.GetTrailingTrivia())); 1025extraNodeList.Add(permutedParamNodes[index]);

ChangeSignature\SignatureChange.cs (3)

33var parameter = originalParameterList[i]; 112if (originalListWithoutRemovedOrAdded[i] != updatedListWithoutRemovedOrAdded[i])

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

59var originalpragmaAction = pragmaActions[i]; 60var diagnostic = diagnostics[i];

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

81var trivia = triviaList[index]; 96? triviaList[index]

CodeLens\CodeLensReferencesService.cs (2)

409var part = parts[index]; 414switch (parts[index + 1].Kind)

CodeRefactorings\AddAwait\AbstractAddAwaitCodeRefactoringProvider.cs (1)

48var expression = expressions[i];

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

194if (!TypeNameMatches(fileNameParts[i], typeNameParts[i].name, typeNameParts[i].arity))

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

102var node = syntaxNodes[i];

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (3)

151var namespaceName = semanticModel.GetRequiredDeclaredSymbol(originalNamespaceDeclarations[i], cancellationToken).ToDisplayString(); 165var namespaceToRename = namespaces[i]; 407builder.Add(CreateImport(generator, names[i], withFormatterAnnotation));

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (1)

269var firstMatch = bestSymbols[index];

Completion\Providers\AbstractSymbolCompletionProvider.cs (3)

110var inferredType = syntaxContext.InferredTypes[i]; 208var firstMatch = symbolList[index]; 267var symbol = symbolList[index];

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

48_mapBuilder.Add(receiverType, syntaxIndex.DeclaredSymbolInfos[index]);

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

332var originalProperty = originalProperties[i]; 333var newProperty = newProperties[i];

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

417syntaxFacts.ConvertToSingleLine(expressions[index], useElasticTrivia: true).WithAdditionalAnnotations(Formatter.Annotation));

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (3)

680if (!comparer.Equals(fields1[i].Name, fields2[i].Name)) 860generator.IdentifierName(constructor.Parameters[index].Name),

Copilot\CopilotUtilities.cs (2)

89var lastEdit = textChanges[i - 1]; 90var currentEdit = textChanges[i];

DocumentationComments\AbstractDocumentationCommentFormattingService.cs (1)

553var parts = typeArgs[typeParameterIndex].ToMinimalDisplayParts(semanticModel, position, format);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (22)

973var oldStatementSpan = oldActiveStatements[i].UnmappedSpan; 1008if (TryGetTrackedStatement(newActiveStatementSpans, oldActiveStatements[i].Statement.Id, newText, newBody, out var trackedStatement, out var trackedStatementPart)) 1038var ancestors = GetExceptionHandlingAncestors(newStatement, newBody.EncompassingAncestor, oldActiveStatements[i].Statement.IsNonLeaf); 1047newActiveStatements[i] = GetActiveStatementWithSpan(oldActiveStatements[i], newBody.SyntaxTree, newStatementSpan, diagnostics, cancellationToken); 1058newActiveStatements[i] = oldActiveStatements[i].Statement.WithSpan(default); 1183newActiveStatements[activeStatementIndex] = GetActiveStatementWithSpan(oldActiveStatements[activeStatementIndex], topMatch.NewRoot.SyntaxTree, newSpan, diagnostics, cancellationToken); 1194var oldStatementSpan = oldActiveStatements[activeStatementIndex].UnmappedSpan; 1219if (TryGetTrackedStatement(newActiveStatementSpans, oldActiveStatements[activeStatementIndex].Statement.Id, newText, newMemberBody, out var newStatementSyntax, out var _)) 1323var isNonLeaf = oldActiveStatements[activeStatementIndex].Statement.IsNonLeaf; 1324var isPartiallyExecuted = (oldActiveStatements[activeStatementIndex].Statement.Flags & ActiveStatementFlags.PartiallyExecuted) != 0; 1454newActiveStatements[activeStatementIndex] = GetActiveStatementWithSpan(oldActiveStatements[activeStatementIndex], newModel.SyntaxTree, newSpan, diagnostics, cancellationToken); 1469newActiveStatements[i] = oldActiveStatements[i].Statement; 3334newActiveStatements[index] = GetActiveStatementWithSpan(oldActiveStatements[index], newTree, newActiveStatementSpan.Value, diagnostics, cancellationToken); 4939var newAttribute = newAttributes[i]; 6399index.Add(array[i].Key, i); 6554var oldCapture = oldCaptures[oldCaptureIndex]; 6573var newCapture = newCaptures[newCaptureIndex]; 6605var oldCapture = oldCaptures[oldCaptureIndex]; 6727ReportCustomAttributeRudeEdits(diagnosticContext.WithSymbols(oldLambdaSymbol.Parameters[i], newLambdaSymbol.Parameters[i]), capabilities, out _, out _, cancellationToken); 6732ReportCustomAttributeRudeEdits(diagnosticContext.WithSymbols(oldLambdaSymbol.TypeParameters[i], newLambdaSymbol.TypeParameters[i]), capabilities, out _, out _, cancellationToken);

EditAndContinue\ActiveStatementsMap.cs (3)

223var activeStatement = activeStatementsInMappedFile[i]; 313while (start > 0 && startPositionComparer(spans[start - 1], spanStart) == 0) 319while (end < spans.Length && startPositionComparer(spans[end], spanStart) == 0)

EditAndContinue\DebuggingSession.cs (3)

721var documentId = documentIds[i]; 810activeStatementsInChangedDocuments.MultiAdd(oldDocumentActiveStatements[i].Statement, (analysis.DocumentId, analysis.ActiveStatements[i].Span));

EditAndContinue\EditAndContinueDiagnosticDescriptors.cs (3)

221=> s_descriptors[GetDescriptorIndex(kind)]; 224=> s_descriptors[GetDescriptorIndex(kind)]; 227=> s_descriptors[GetDescriptorIndex(errorCode)];

EditAndContinue\EditSession.cs (5)

1695var (_, oldActiveStatement, oldActiveStatementExceptionRegions) = oldActiveStatements[i]; 1696var newActiveStatement = newActiveStatements[i]; 1697var newActiveStatementExceptionRegions = newExceptionRegions[i]; 1753AddNonRemappableRegion(oldActiveStatementExceptionRegions.Spans[j], newActiveStatementExceptionRegions[j], isExceptionRegion: true);

EditAndContinue\MemberBody.cs (1)

73var span = statements[i].UnmappedSpan;

EditAndContinue\Utilities\Extensions.cs (1)

220static (param, constructor) => param.RefKind == RefKind.Out && param.Type.Equals(constructor.Parameters[param.Ordinal].Type, SymbolEqualityComparer.Default),

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

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

EmbeddedLanguages\Json\JsonNodes.cs (4)

41return Sequence[index]; 117return Sequence.NodesAndTokens[index - 1]; 155return Sequence[index - 1]; 314return Sequence[index - 3];

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

165var child = sequence[i]; 166var nextChild = sequence[i + 1];

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

134var child = sequence[i];

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

310AddClassification(node.SequenceList.NodesAndTokens[i].Token, ClassificationTypeNames.RegexAlternation);

EmbeddedLanguages\RegularExpressions\RegexNodes.cs (3)

62=> Children[index]; 587Debug.Assert(sequenceList.NodesAndTokens[i].Kind == RegexKind.BarToken); 597=> SequenceList.NodesAndTokens[index];

EmbeddedLanguages\StackFrame\StackFrameNodeDefinitions.cs (4)

379_ => ArrayRankSpecifiers[index - 1] 419return CommaTokens[index - 1]; 478return TypeArguments.NodesAndTokens[index - 1]; 549return Parameters.NodesAndTokens[index - 1];

ExtractMethod\MethodExtractor.Analyzer.cs (5)

339return variableInfos.SetItem(index, VariableInfo.CreateReturnValue(variableInfos[index])); 360var variable = variableInfo[i]; 839if (arguments[i] is ITypeParameterSymbol argument) 841if (parameters[i] is not 853else if (arguments[i] is INamedTypeSymbol candidate)

FindUsages\DefinitionsAndReferences.cs (1)

39var reference = references[i];

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (1)

58var (parameter, fieldOrProperty) = _state.Parameters[i];

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.FieldDelegatingCodeAction.cs (2)

42parameterToExistingFieldMap[_state.Parameters[i].parameter.Name] = _state.Parameters[i].fieldOrProperty;

GenerateType\AbstractGenerateTypeService.GenerateNamedType.cs (1)

204var parameterType = parameterTypes[i];

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (3)

808semanticModel, methodSymbol.Parameters[i], blockStatement, cancellationToken); 818semanticModel, methodSymbol.Parameters[i], blockStatement, cancellationToken); 822return statementIndex > 0 && blockStatement.Operations[statementIndex - 1] is { IsImplicit: false, Syntax: var priorSyntax }

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (4)

381var parameter = parameters[i]; 382var fieldOrProperty = fieldsOrProperties[i]; 593var target = targetTuple.Elements[i]; 594var value = valueTuple.Elements[i];

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (2)

375var currentStatement = statementsFromDeclarationToEnd[statementIndex]; 423return statementsFromDeclarationToEnd[endOfUsingStatementIndex];

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.cs (1)

93var structuralType = transitiveStructuralTypeReferences[i];

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

608var typeArgument = typeArguments[i]; 609var typeParameter = typeParameters[i]; 834parts.AddRange(TypeParameterName(typeParameters[i].Name)); 839parts.AddRange(ToMinimalDisplayParts(typeArguments[i]));

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (7)

59lineBuilder.Append(string.Format(s_labelFormat, parameterNames[i])); 63docCommentFormattingService.Format(docComment.GetParameterText(parameterNames[i])), 83lineBuilder.Append(string.Format(s_labelFormat, typeParameterNames[i])); 87docCommentFormattingService.Format(docComment.GetTypeParameterText(typeParameterNames[i])), 110var rawExceptionTexts = docComment.GetExceptionTexts(exceptionTypes[i]); 121lineBuilder.Append(string.Format(s_labelFormat, exceptionTypes[i])); 124AddWrappedTextFromRawText(docCommentFormattingService.Format(rawExceptionTexts[j]), formattedCommentLinesBuilder);

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)

93.Where(i => typeParameters.Contains(_selectedType.TypeParameters[i]))

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

72var element = elements[argumentIndex];

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (1)

305var (roslynKind, vsKind) = s_kindPairs[i];

NavigateTo\RegexPatternDetector.cs (1)

89if (topSequence.Children[i] is RegexWildcardNode wildcard)

Shared\Extensions\ISymbolExtensions_Sorting.cs (2)

75var xParam = xParameters[i]; 76var yParam = yParameters[i];

SignatureHelp\CommonSignatureHelpUtilities.cs (1)

40argumentIndex < argumentCount ? argumentNames[argumentIndex] : null,

Snippets\RoslynLSPSnippetConverter.cs (1)

88var placeholder = placeholders[i];

src\939a5660f39ce290\AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs (1)

205localDeclaration = parentBlock.Operations[ifIndex - 1] as IVariableDeclarationGroupOperation;

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

178var statement = statements[i];

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

22if (HasDefaultCase(switchStatement.Cases[index]))

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (1)

206return IsInvariantCultureReference(invocation.Arguments[formatProviderArgumentIndex].Value)

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

67falseStatement = parentBlock.Operations[ifIndex + 1];

src\roslyn\src\Analyzers\Core\Analyzers\UseThrowExpression\AbstractUseThrowExpressionDiagnosticAnalyzer.cs (3)

149statements[ifOperationIndex + 1].Syntax, 150statements[expressionStatementIndex - 1].Syntax); 177expressionStatement = containingBlock.Operations[i] as IExpressionStatementOperation;

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

200if (argumentName.Equals(parameters[j].Name))

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

153var parameterType = parameters[parameterIndex].Type; 154if (parameters[parameterIndex].IsParams

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

495var parameter = method.Parameters[i];

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

90var t1NameSegment = t1NameSegments[i]; 91var t2NameSegment = t2NameSegments[i];

src\roslyn\src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractAddDocCommentNodesCodeFixProvider.cs (2)

67var parameterName = parameterNames[index]; 89nodeBeforeNewParamNode = GetParamNodeForParamName(paramNodes, parameterNames[index - 1]);

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

185.Select((name, index) => new ParameterName(name, isFixed[index], parameterNamingRule))

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

256var ctorParameter = ctor.Parameters[i]; 257var result = SymbolEquivalenceComparer.Instance.Equals(ctorParameter.Type, ParameterTypes[i]) && 258ctorParameter.RefKind == _parameterRefKinds[i]; 276=> _arguments.IsDefault || index >= _arguments.Length ? string.Empty : _arguments[index].Name;

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

114var constructorParameter = constructorInCompilation.Parameters[i]; 118var expression = expressions[i]; 159var parameterName = parameterNames[i]; 160var parameterType = parameterTypes[i]; 161var argument = arguments[i];

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

178if (typeArguments[i] != null) 180result[typeArguments[i]] = typeParameters[i]; 210refKind: modifiers[i], 212isOptional: optionality[i], 214name: names[i].BestNameForParameter));

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\TypeParameterSubstitution.cs (1)

97(INamedTypeSymbol)symbol.ConstraintTypes[i], projects).ConfigureAwait(false);

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

215var parameter = containingMethod.Parameters[i];

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

283var (typeA, membersA) = state.MembersWithoutExplicitOrImplicitImplementation[i]; 284var (typeB, membersB) = state.MembersWithoutExplicitImplementation[i];

src\roslyn\src\Analyzers\Core\CodeFixes\MakeMemberStatic\AbstractMakeMemberStaticCodeFixProvider.cs (1)

33var declaration = diagnostics[i].Location.FindNode(cancellationToken);

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

33if (IsValidRefactoringContext(diagnostics[i].Location?.FindNode(cancellationToken), out var typeDeclaration))

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

510return TypeInfo.Create(methodContext.TypeParameters[methodTypeParameterIndex]); 552if (methodContext.TypeParameters[i].Name == typeParameterName) 554return TypeInfo.Create(methodContext.TypeArguments[i]); 564if (containingType.TypeParameters[i].Name == typeParameterName) 566return TypeInfo.Create(containingType.TypeArguments[i]); 784if (!ParameterMatches(symbolParameters[i], expectedParameters[i])) 848return typeParameters[index];

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

437var importString = importStrings[pos]; 457var importString = importStrings[pos]; 529return bytes[i] | (bytes[i + 1] << 8) | (bytes[i + 2] << 16) | (bytes[i + 3] << 24); 541return (short)(bytes[i] | (bytes[i + 1] << 8)); 553return bytes[i];

StackTraceExplorer\AbstractStackTraceSymbolResolver.cs (1)

94var paramSymbol = parameters[i];

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (2)

105var argumentName = parameters[argumentIndex].Name; 156? WithName((TSimpleArgumentSyntax)argument.WithoutTrivia(), parameters[i].Name).WithTriviaFrom(argument)

Wrapping\BinaryExpression\BinaryExpressionCodeActionComputer.cs (5)

95var left = _exprsAndOperators[i - 1].AsNode(); 96var opToken = _exprsAndOperators[i].AsToken(); 97var right = _exprsAndOperators[i + 1].AsNode(); 132_exprsAndOperators[i], SingleWhitespaceTrivia, 133NoTrivia, _exprsAndOperators[i + 1]));

Wrapping\ChainedExpression\ChainedExpressionCodeActionComputer.cs (4)

148var chunk = _chunks[i]; 160_chunks[i - 1].Last(), _newlineBeforeOperatorTrivia, 194result.Add(Edit.DeleteBetween(chunk[i - 1], chunk[i]));

src\4f0789c9734b88bf\CSharpInitializeParameterService.cs (2)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

53var tupleElementType = tupleType.TupleElements[i].Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ArgumentSyntaxExtensions.cs (1)

80var parameter = parameters[index];

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\AttributeArgumentSyntaxExtensions.cs (1)

64return parameters[index];

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ExpressionSyntaxExtensions.cs (1)

953return index < typeArguments.Length ? typeArguments[index] : null;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (1)

444var parameter = member.Parameters[index];

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (4)

1349var oldInterpolationPart = oldInterpolationOperation.Parts[i]; 1350var newInterpolationPart = newInterpolationOperation.Parts[i]; 1645var originalParameter = originalParameters[i]; 1646var rewrittenParameter = rewrittenParameters[i];

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SemanticModelExtensions.cs (1)

73.Select((name, index) => new ParameterName(name, isFixed[index]))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (4)