Item

Binder\Binder.QueryUnboundLambdaState.cs (2)

33public override string ParameterName(int index) { return _parameters[index].Name; } 52public override Location ParameterLocation(int index) { return _parameters[index].TryGetFirstLocation(); }

Binder\Binder.ValueChecks.cs (7)

2317var argument = argsOpt[argIndex]; 2332parameters[argsToParamsOpt.IsDefault ? argIndex : argsToParamsOpt[argIndex]] : 2347refKind = argRefKindsOpt[argIndex]; 2436var argument = argsOpt[argIndex]; 2437var refKind = argRefKindsOpt.IsDefault ? RefKind.None : argRefKindsOpt[argIndex]; 2965int paramIndex = argsToParamsOpt.IsDefault ? argIndex : argsToParamsOpt[argIndex];

Binder\Binder.WithQueryLambdaParametersBinder.cs (1)

61var nextField = path[i];

Binder\Binder_Attributes.cs (13)

46var binder = binders[i]; 47AttributeSyntax attributeToBind = attributesToBind[i]; 90AttributeSyntax attributeSyntax = attributesToBind[i]; 91NamedTypeSymbol boundAttributeType = boundAttributeTypes[i]; 92Binder binder = binders[i]; 384Debug.Assert(!arguments[argIndex].IsParamsArrayOrCollection || arguments[argIndex] is BoundArrayCreation); 386int paramIndex = argsToParamsOpt.IsDefault ? argIndex : argsToParamsOpt[argIndex]; 389(arguments[argIndex].IsParamsArrayOrCollection && arguments[argIndex] is BoundArrayCreation { Bounds: [BoundLiteral { ConstantValueOpt.Value: 0 }] }) ? 716var paramIndex = argumentsToParams.IsDefault ? i : argumentsToParams[i]; 717ParameterSymbol parameter = parameters[paramIndex]; 719TypedConstant reorderedArgument = constructorArgsArray[i];

Binder\Binder_Await.cs (1)

483var parameter = method.Parameters[method.ParameterCount - 1];

Binder\Binder_Constraints.cs (2)

396constraintClauses[i] = RemoveInvalidConstraints(typeParameters[i], constraintClauses[i], syntaxNodes[i], performOnlyCycleSafeValidation, diagnostics); 417var constraintType = constraintTypes[i];

Binder\Binder_Conversions.cs (10)

384new BoundValuePlaceholder(source.Syntax, sourceTypes[i].Type), 385elementConversions[i], 389destTypes[i].Type, 392elementConversions[i].AssertUnderlyingConversionsChecked(); 1979? CreateConversion(oldValue.Syntax, oldValue, underlyingConversions[i], isCast: false, conversionGroupOpt: null, destination, diagnostics) 2319var lambdaParameter = lambdaSymbol.Parameters[p]; 2320var delegateParameter = delegateParameters[p]; 2486var destType = targetElementTypes[i]; 2848var delegateParameter = delegateOrFuncPtrParameters[i]; 2849var methodParameter = methodParameters[isExtensionMethod ? i + 1 : i];

Binder\Binder_Crefs.cs (3)

506if (ContainsNestedTypeOfUnconstructedGenericType(parameterSymbols[i].Type)) 700symbol = symbols[symbolIndex]; // NOTE: symbols, not unwrappedSymbols. 712diagnostics.Add(ErrorCode.WRN_AmbiguousXMLReference, crefSyntax.Location, crefSyntax.ToString(), symbol, symbols[otherIndex]);

Binder\Binder_Deconstruct.cs (7)

305hasErrors |= !MakeDeconstructionConversion(tupleOrDeconstructedTypes[i], elementSyntax, rightSyntax, diagnostics, 323nestedConversion = this.Conversions.ClassifyConversionFromType(tupleOrDeconstructedTypes[i], single.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 329GenerateImplicitConversionError(diagnostics, Compilation, single.Syntax, nestedConversion, tupleOrDeconstructedTypes[i], single.Type); 334var operandPlaceholder = new BoundValuePlaceholder(syntax, tupleOrDeconstructedTypes[i]).MakeCompilerGenerated(); 362variables[i] = new DeconstructionVariable(SetInferredType(pending, foundTypes[i], diagnostics), variable.Syntax); 480BoundExpression element = rhsLiteral.Arguments[i]; 687if (parameters[i].RefKind != RefKind.Out)

Binder\Binder_Expressions.cs (19)

2860var argument = tupleArguments[i]; 2861var targetElementType = targetElementTypesWithAnnotations[i].Type; 3484arguments[arg] = coerceArgument(in methodResult, receiver, parameters, argumentsForInterpolationConversion: arguments, argument, arg, parameters[paramNum].TypeWithAnnotations, diagnostics); 3606if (parameters[paramsIndex].Type.IsSZArray()) 3626BoundExpression collection = CreateParamsCollection(node, parameters[paramsIndex], collectionArgs, diagnostics); 3680return parameters[paramNum]; 3765int handlerParameter = handlerParameterIndexes[handlerParameterIndex]; 3798int argumentIndex = handlerArgumentIndexes[i]; 3814var originalParameterIndex = handlerParameterIndexes[i]; 3815var parameter = parameters[originalParameterIndex]; 3834var originalParameterIndex = handlerParameterIndexes[i]; 3835var parameter = parameters[originalParameterIndex]; 4231BoundExpression boundExpression = boundInitExpr[boundInitExprIndex]; 4256init = boundInitExpr[boundInitExprIndex]; 4391var size = sizes[i]; 6559MethodSymbol constructor = constructors[i]; 7561var typeArgument = typeArgumentsWithAnnotations[i]; 10872parameterTypes[i], 10873parameterRefKinds.IsDefault ? RefKind.None : parameterRefKinds[i],

Binder\Binder_Initializers.cs (2)

173ImmutableArray<FieldOrPropertyInitializer> siblingInitializers = initializers[i]; 184var initializer = siblingInitializers[j];

Binder\Binder_InterpolatedString.cs (3)

380var part = parts[i]; 534arg.AppendCalls[i], 856var part = unconvertedInterpolatedString.Parts[i];

Binder\Binder_Invocation.cs (9)

565if (refKinds[argIndex] == RefKind.In) 567Error(diagnostics, ErrorCode.ERR_InDynamicMethodArg, arguments[argIndex].Syntax); 1434parameter = parameters[argumentOrdinal]; 1438parameter = parameters[n - 1]; 1448int parameterOrdinal = argsToParamsOpt[argumentOrdinal]; 1452parameter = parameters[parameterOrdinal]; 1571BoundExpression collection = CreateParamsCollection(node, parameters[paramsIndex], collectionArgs: ImmutableArray<BoundExpression>.Empty, diagnostics); 2154return (i < parameterList.Length) ? parameterList[i].Type : null; 2190TypeSymbol returnType = members[i].GetTypeOrReturnType().Type;

Binder\Binder_Lookup.cs (3)

638return originalSymbols[best.Index]; 1077addAllInterfaces(interfaces[i], visited, result, basesBeingResolved, cycleGuard); 1104var baseInterface = baseInterfaces[i];

Binder\Binder_Operators.cs (1)

1273var op = operators[i];

Binder\Binder_Patterns.cs (5)

1067TypeSymbol elementType = isError ? CreateErrorType() : outPlaceholders[i].Type; 1074parameter = deconstructMethod.Parameters[parameterIndex]; 1172TypeSymbol elementType = isError ? CreateErrorType() : elementTypesWithAnnotations[i].Type; 1422TypeSymbol elementType = isError ? CreateErrorType() : outPlaceholders[i].Type; 1445TypeSymbol elementType = isError ? CreateErrorType() : elementTypes[i].Type;

Binder\Binder_Query.cs (4)

470arguments = arguments.SetItem(arguments.Length - 1, MakeQueryClause(join.Into, arguments[arguments.Length - 1], g)); 539arguments = arguments.SetItem(arguments.Length - 1, MakeQueryClause(join.Into, arguments[arguments.Length - 1], g)); 633arguments.SetItem(arguments.Length - 2, MakeQueryClause(from, arguments[arguments.Length - 2], x2, invocation, castInvocation))); 680var c1 = invocation.Arguments[index] as BoundConversion;

Binder\Binder_Statements.cs (7)

2143var delegateRefKind = delegateParameters[i].RefKind; 2159if (delegateParameters[i].TypeWithAnnotations.IsStatic) 2162Error(diagnostics, ErrorFacts.GetStaticClassParameterCode(useWarning: false), anonymousFunction.ParameterLocation(i), delegateParameters[i].Type); 2185var delegateParameterType = delegateParameters[i].Type; 2186var delegateRefKind = delegateParameters[i].RefKind; 2521var argument = tupleArguments[i]; 2522var targetElementType = targetElementTypes[i].Type;

Binder\Binder_Symbols.cs (13)

1997return originalSymbols[best.Index]; 2008return originalSymbols[best.Index]; 2019return originalSymbols[best.Index]; 2032Debug.Assert(!Symbol.Equals(originalSymbols[best.Index], originalSymbols[secondBest.Index], TypeCompareKind.ConsiderEverything) || options.IsAttributeTypeLookup(), 2035Debug.Assert(!Symbol.Equals(first, second, TypeCompareKind.ConsiderEverything) || !Symbol.Equals(originalSymbols[best.Index], originalSymbols[secondBest.Index], TypeCompareKind.ConsiderEverything), 2190Debug.Assert(originalSymbols[best.Index].Name != originalSymbols[secondBest.Index].Name || 2191!Symbol.Equals(originalSymbols[best.Index], originalSymbols[secondBest.Index], TypeCompareKind.ConsiderEverything), 2201originalSymbols[best.Index].Name != originalSymbols[secondBest.Index].Name && // Use alias names, if available.

Binder\Binder_TupleOperators.cs (9)

61builder.Add(ApplyConvertedTypes(arguments[i], multiple.Operators[i], isRight, diagnostics)); 240operatorsBuilder.Add(BindTupleBinaryOperatorInfo(node, kind, leftParts[i], rightParts[i], diagnostics)); 295string leftName = leftNoNames ? null : leftNames[i]; 296string rightName = rightNoNames ? null : rightNames[i]; 304bool leftWasInferred = leftNoInferredNames ? false : leftInferred[i]; 305bool rightWasInferred = rightNoInferredNames ? false : rightInferred[i]; 318Location location = ((BoundTupleExpression)(useRight ? right : left)).Arguments[i].Syntax.Parent.Location;

Binder\DecisionDagBuilder.cs (10)

351tests.Add(MakeTestsAndBindings(indexTemp, pattern.Subpatterns[i].Pattern, bindings)); 539BoundPattern pattern = recursive.Deconstruction[i].Pattern; 541var element = new BoundDagTemp(syntax, method.Parameters[i + extensionExtra].Type, evaluation, i); 560BoundPattern pattern = recursive.Deconstruction[i].Pattern; 562FieldSymbol field = elements[i]; 776var node = sortedBoundDagNodes[i]; 1004var state = sortedStates[i]; 1658stateIdentifierMap.Add(allStates[i], i); 2413remainingTests.Insert(i + j, testsToInsert[j]); 2493remainingTests.Insert(i + j, testsToInsert[j]);

Binder\LocalScopeBinder.cs (1)

141var symbol = array[i];

Binder\PatternExplainer.cs (6)

53var n = nodes[i]; 252BoundDecisionDagNode node = pathToNode[i]; 257BoundDecisionDagNode nextNode = (i < n - 1) ? pathToNode[i + 1] : targetNode; 385switch (evaluations[i]) 428switch (evaluations[i]) 547var elementTemp = new BoundDagTemp(e.Syntax, method.Parameters[j + extensionExtra].Type, e, j);

Binder\RefSafetyAnalysis.cs (5)

639var arg = arguments[i]; 710valEscapeScope = GetValEscape(arguments[argIndex], _localScopeDepth); 957var arg = (BoundDeconstructValuePlaceholder)invocation.Arguments[i + offset]; 984var (placeholder, placeholderConversion) = conversion.DeconstructConversionInfo[i]; 986VisitDeconstructionArguments(nestedVariables, syntax, underlyingConversion, right: invocation.Arguments[i + offset]);

Binder\Semantics\Conversions\Conversion.cs (3)

494UserDefinedConversionAnalysis analysis = conversionResult.Results[conversionResult.Best]; 520UserDefinedConversionAnalysis analysis = conversionResult.Results[conversionResult.Best]; 1134UserDefinedConversionAnalysis analysis = conversionResult.Results[conversionResult.Best];

Binder\Semantics\Conversions\ConversionsBase.cs (17)

1517delegateParameterRefKind: delegateParameters[p].RefKind, 1519!delegateParameters[p].Type.Equals(anonymousFunction.ParameterType(p), TypeCompareKind.AllIgnoreOptions)) 1529if (delegateParameters[p].RefKind != RefKind.None) 1560if (delegateParameters[p].TypeWithAnnotations.IsStatic) 1571if (delegateParameters[p].RefKind == RefKind.Out) 1740UserDefinedConversionAnalysis analysis = result.Results[result.Best]; 2346var argument = arguments[i]; 2347var result = classifyConversion(this, argument, targetElementTypes[i], isChecked: isChecked, ref useSiteInfo, forCast: forCast); 2420var conversion = classifyConversion(this, sourceTypes[i], destTypes[i], isChecked: isChecked, ref useSiteInfo, forCast); 3398var sourceParam = sourceSig.Parameters[i]; 3399var destinationParam = destinationSig.Parameters[i]; 3406if (!hasConversion(sourceParam.RefKind, destinationSig.Parameters[i].TypeWithAnnotations, sourceSig.Parameters[i].TypeWithAnnotations, ref useSiteInfo)) 3688var sourceArg = sourceTypeArguments[i].Type; 3689var destinationArg = destinationTypeArguments[i].Type; 3691switch (original.TypeParameters[i].Variance)

Binder\Semantics\Conversions\UserDefinedConversionResult.cs (2)

89Results[i].Operator, 90Results[i].Kind);

Binder\Semantics\Conversions\UserDefinedImplicitConversions.cs (5)

552if (predicate(items[i])) 743return best == null ? null : extract(items[best.Value]); 782return best == null ? null : extract(items[best.Value]); 811T currentItem = items[currentIndex]; 860T currentItem = items[currentIndex];

Binder\Semantics\OverloadResolution\ArgumentAnalysisResult.cs (2)

27return ArgsToParamsOpt[arg]; 127s += "\nArgument " + i + " corresponds to parameter " + ArgsToParamsOpt[i];

Binder\Semantics\OverloadResolution\MemberAnalysisResult.cs (2)

159return this.ConversionsOpt[arg]; 170return ArgsToParamsOpt[arg];

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (31)

Binder\Semantics\OverloadResolution\OverloadResolution.cs (18)

2074return parameters[paramIndex]; 3095var element = collectionExpressionElements[i]; 3096var conversionToE1 = underlyingElementConversions1[i]; 3097var conversionToE2 = underlyingElementConversions2[i]; 3364if (!ExpressionMatchExactly(sourceArguments[i], destTypes[i].Type, ref useSiteInfo)) 3715var param1 = p1[i]; 3716var param2 = p2[i]; 3845int parm = argToParamMap.IsDefault ? arg : argToParamMap[arg]; 3851var parameter = parameters[parm]; 3987var parm = argToParamMap.IsDefault ? arg : argToParamMap[arg]; 3988var parameter = parameters[parm]; 4265if (!parameterTypes[i].Type.CheckAllConstraints(Compilation, Conversions)) 4384paramsElementTypeOpt = parameters.ParameterTypes[parameters.FirstParamsElementIndex]; 4445RefKind parameterRefKind = parameters.ParameterRefKinds.IsDefault ? RefKind.None : parameters.ParameterRefKinds[argumentPosition]; 4466&& parameters.ParameterTypes[argumentPosition].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }) 4479parameters.ParameterTypes[argumentPosition].Type, 4491(ignoreOpenTypes && parameters.ParameterTypes[argumentPosition].Type.ContainsTypeParameter(parameterContainer: (MethodSymbol)candidate))));

Binder\Semantics\OverloadResolution\OverloadResolution_ArgsToParameters.cs (3)

320if (memberParameters[p].Name == name) 365if (parameters.Length == parameterPosition || !CanBeOptional(parameters[parameterPosition], isMethodGroupConversion)) 462if (CanBeOptional(parameters[p], isMethodGroupConversion))

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (2)

909badParamName = parameters[badParamIndex].Name; 1122if (parameters[i].RefKind != RefKind.None)

BoundTree\BoundCollectionExpression.cs (1)

22if (Elements[i] is BoundCollectionExpressionSpreadElement spreadElement)

BoundTree\BoundDecisionDag.cs (1)

107BoundDecisionDagNode node = sortedNodes[i];

BoundTree\BoundNodeExtensions.cs (1)

26if (nodeArray[i].HasErrors)

BoundTree\BoundTreeRewriter.cs (1)

36var item = list[i];

BoundTree\BoundTreeWalker.cs (3)

23this.Visit(list[i]); 44this.Visit(arguments[arguments.Length - 1]); 48this.Visit(arguments[arguments.Length - 2]);

BoundTree\Constructors.cs (3)

192var parameterRefKind = method.ParameterRefKinds.IsDefault ? RefKind.None : method.ParameterRefKinds[i]; 193var argumentRefKind = argumentRefKindsOpt.IsDefault ? RefKind.None : argumentRefKindsOpt[i]; 206Debug.Assert(method is ErrorMethodSymbol || arguments[i].Kind == BoundKind.ArgListOperator);

BoundTree\Formatting.cs (2)

93argumentDisplays[i] = arguments[i].Display; 210argumentDisplays[i] = arguments[i].Display;

BoundTree\NullabilityRewriter.cs (2)

180_remappedSymbols.Add(lambda.Parameters[i], updatedLambda.Parameters[i]);

BoundTree\UnboundLambda.cs (13)

749parameterScopesBuilder[i] = lambdaSymbol.Parameters[i].EffectiveScope; 753Debug.Assert(lambdaSymbol.Parameters[i].EffectiveScope == parameterScopesBuilder[i]); 922if (targetParameterTypes[i].Type.ContainsPointer()) 1058if (!other.ParameterTypes[i].Equals(this.ParameterTypes[i], TypeCompareKind.ConsiderEverything) || 1059other.ParameterRefKinds[i] != this.ParameterRefKinds[i]) 1519return _parameterAttributes.IsDefault ? default : _parameterAttributes[index]; 1525return _parameterNames[index]; 1530return _parameterIsDiscardOpt.IsDefault ? false : _parameterIsDiscardOpt[index]; 1536return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index]; 1542return _parameterDeclaredScopes.IsDefault ? ScopedKind.None : _parameterDeclaredScopes[index]; 1556return _parameterTypesWithAnnotations[index];

CodeGen\EmitAddress.cs (1)

387BoundExpression index = indices[i];

CodeGen\EmitArrayInitializer.cs (2)

87var init = inits[i]; 146indices.Push(new IndexDesc(i, ((BoundArrayInitialization)inits[i]).Initializers));

CodeGen\EmitExpression.cs (15)

709BoundExpression argument = expression.Arguments[i]; 710RefKind refKind = expression.ArgumentRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : expression.ArgumentRefKindsOpt[i]; 959EmitArgument(arguments[i], argRefKind); 975argRefKind = argRefKindsOpt[i]; 977Debug.Assert(argRefKind == parameters[i].RefKind || 978parameters[i].RefKind switch 988Debug.Assert(parameters[i].RefKind != RefKind.RefReadOnlyParameter, 992argRefKind = parameters[i].RefKind switch 1002Debug.Assert(arguments[i].Kind == BoundKind.ArgListOperator); 1680method.IsVararg ? (BoundArgListOperator)arguments[arguments.Length - 1] : null); 2014actualMethodTargetedByTheCall.IsVararg ? (BoundArgListOperator)arguments[arguments.Length - 1] : null); 2255int varArgCount = ((BoundArgListOperator)arguments[fixedArgCount]).Arguments.Length; 2279int varArgCount = ((BoundArgListOperator)objCreation.Arguments[fixedArgCount]).Arguments.Length; 2456constructor.IsVararg ? (BoundArgListOperator)expression.Arguments[expression.Arguments.Length - 1] : null); 2713constructor.IsVararg ? (BoundArgListOperator)objCreation.Arguments[objCreation.Arguments.Length - 1] : null);

CodeGen\EmitStatement.cs (1)

129EmitStatement(list.Statements[i]);

CodeGen\Optimizer.cs (5)

726var sideeffect = sideeffects[i]; 780if (localUsedWalker.IsLocalUsedIn(sideeffects[i])) 1276var arg = arguments[i]; 1300RefKind refKind = argRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : argRefKindsOpt[i]; 1768var initializer = initializers[i];

CommandLine\CSharpCompiler.cs (2)

85sourceFiles[i], 104Debug.Assert(sourceFiles[i].IsInputRedirected || PathUtilities.IsAbsolute(normalizedFilePath));

Compilation\CSharpCompilation.cs (11)

1203return index < 0 ? null : this.Assembly.Modules[index]; 3711var m = (Symbols.Metadata.PE.PEModuleSymbol)modules[i]; 3854if (b != bytes[i]) 4039if (parameterTypes[i] is null) 4125ITypeSymbol typeSymbol = elementTypes[i]; 4127var annotation = (elementNullableAnnotations.IsDefault ? typeSymbol.NullableAnnotation : elementNullableAnnotations[i]).ToInternalAnnotation(); 4180memberTypes[i].EnsureCSharpSymbolOrNull($"{nameof(memberTypes)}[{i}]"); 4192var type = memberTypes[i].GetSymbol(); 4193var name = memberNames[i]; 4194var location = memberLocations.IsDefault ? Location.None : memberLocations[i]; 4195var nullableAnnotation = memberNullableAnnotations.IsDefault ? NullableAnnotation.Oblivious : memberNullableAnnotations[i].ToInternalAnnotation();

Compilation\MemberSemanticModel.cs (2)

1133return elements[idx].GetPublicSymbol(); 1275var boundAdd = boundCollectionInitializer.Initializers[collectionInitializer.Expressions.IndexOf(node)];

Compilation\SyntaxAndDeclarationManager.cs (4)

414var tree = syntaxTrees[i]; 527var tree = syntaxTrees[i]; 548var tree = syntaxTrees[i]; 630stack.Push(current.Children[i]);

Compilation\SyntaxAndDeclarationManager.LazyState.cs (1)

55Debug.Assert(syntaxTrees.All(tree => syntaxTrees[syntaxTreeOrdinalMap[tree]] == tree));

Compiler\AnonymousTypeMethodBodySynthesizer.cs (4)

57F.Assignment(F.Field(F.This(), anonymousType.Properties[index].BackingField), F.Parameter(_parameters[index])); 207F.Field(F.This(), anonymousType.Properties[index].BackingField), 255AnonymousTypePropertySymbol property = anonymousType.Properties[i];

Compiler\ClsComplianceChecker.cs (6)

117ModuleSymbol module = symbol.Modules[i]; 695if (TryGetClsComplianceAttributeLocation(parameters[i].GetAttributes(), out attributeLocation)) 1369TypeSymbol xType = xParameterTypes[i].Type; 1370TypeSymbol yType = yParameterTypes[i].Type; 1405sawRefKindDifference = sawRefKindDifference || xRefKinds[i] != yRefKinds[i];

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (1)

478originatingSyntax = _sourceIncludeElementNodes[_nextSourceIncludeElementIndex];

Compiler\MethodCompiler.cs (1)

496var member = members[memberOrdinal];

Declarations\MergedNamespaceDeclaration.cs (1)

51sortKey = LexicalSortKey.First(sortKey, new LexicalSortKey(_declarations[i].NameLocation, compilation));

Declarations\MergedTypeDeclaration.cs (1)

165sortKey = LexicalSortKey.First(sortKey, new LexicalSortKey(Declarations[i].NameLocation, compilation));

Emitter\EditAndContinue\CSharpDefinitionMap.cs (3)

105var key = new EncHoistedLocalInfo(localSlotDebugInfo[slotIndex], (Cci.ITypeReference)field.Type.GetCciAdapter()); 162var metadata = slotMetadata[slotIndex]; 185result[i] = new EncLocalInfo(slotMetadata[i].SignatureOpt);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (1)

196var otherModule = otherAssembly.Modules[i];

Emitter\Model\AttributeDataAdapter.cs (1)

135metadataExprs[i] = CreateMetadataExpression(values[i], context);

Emitter\Model\NamedTypeSymbolAdapter.cs (2)

875var arg = moduleBeingBuilt.Translate(arguments[i].Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics); 876var modifiers = arguments[i].CustomModifiers;

Emitter\Model\PEAssemblyBuilder.cs (6)

131builder.Add((Cci.IFileReference)Translate(modules[i], context.Diagnostics)); 172var file = (Cci.IFileReference)Translate(modules[i], diagnostics); 176foreach (EmbeddedResource resource in ((Symbols.Metadata.PE.PEModuleSymbol)modules[i]).Module.GetEmbeddedResourcesOrThrow()) 188diagnostics.Add(new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, modules[i]), NoLocation.Singleton); 214_lazyNullableAttribute.Constructors[constructorIndex], 257_lazyNativeIntegerAttribute.Constructors[constructorIndex],

Emitter\Model\PEModuleBuilder.cs (5)

158foreach (AssemblySymbol aRef in modules[i].GetReferencedAssemblySymbols()) 641GetExportedTypes(modules[i].GlobalNamespace, -1, builder); 792stack.Push((nested[i], index)); 1228!optArgList.ArgumentRefKindsOpt.IsDefaultOrEmpty && optArgList.ArgumentRefKindsOpt[i] != RefKind.None, 1229Translate(optArgList.Arguments[i].Type, syntaxNodeOpt, diagnostics));

Emitter\Model\SymbolAdapter.cs (1)

150CSharpAttributeData attribute = userDefined[i];

FlowAnalysis\AbstractFlowPass.cs (4)

1531VisitRvalue(arguments[i], isKnownToBeAnLvalue: refKind != RefKind.None); 1535VisitLvalue(arguments[i]); 1558WriteArgument(arguments[i], refKind, method); 1568return refKindsOpt.IsDefault || refKindsOpt.Length <= index ? RefKind.None : refKindsOpt[index];

FlowAnalysis\AbstractFlowPass_Switch.cs (1)

28VisitSwitchSection(switchSections[iSection], iSection == iLastSection);

FlowAnalysis\FlowAnalysisPass.cs (1)

174builder.Add(AppendImplicitReturn((BoundBlock)statements[n - 1], method));

FlowAnalysis\NullableWalker.cs (41)

2809var parameter = methodParameters[i]; 2812var parameterType = i >= signatureParameters.Length ? parameter.TypeWithAnnotations : signatureParameters[i].TypeWithAnnotations; 4503var argument = arguments[i]; 4533var currentDeclaration = node.Declarations[currentDeclarationIndex]; 4742BoundExpression placeholder = placeholders[i]; 6526var comparand = compareExchangeInfo.Arguments[comparandIndex]; 6527var valueFlowState = compareExchangeInfo.Results[valueIndex].RValueType.State; 6534var locationFlowState = compareExchangeInfo.Results[locationIndex].RValueType.State; 6857var argumentNoConversion = argumentsNoConversions[i]; 6858var argument = i < arguments.Length ? arguments[i] : argumentNoConversion; 6892conversions.IsDefault || i >= conversions.Length ? Conversion.Identity : conversions[i], 6897results[i], 6903if (results[i].RValueType.IsNotNull || isExpandedParamsArgument) 6940arguments[i], 6945results[i], 6956var argument = arguments[i]; 6957var result = results[i]; 6958var argumentNoConversion = argumentsNoConversions[i]; 7005BoundExpression argument = arguments[a]; 7242resultsBuilder.Add(VisitArgumentEvaluate(arguments[i], GetRefKind(refKindsOpt, i), parameterAnnotationsOpt.IsDefault ? default : parameterAnnotationsOpt[i])); 7748var argument = arguments[i]; 7937var visitArgumentResult = argumentResults[i]; 7938builder.Add(getArgumentForMethodTypeInference(arguments[i], visitArgumentResult)); 7966if (collection.Elements[i] is BoundExpression elementExpression) 7973elementsBuilder.Add(collection.Elements[i]); 8482trackState(values[argOrdinal], tupleElements[i], types[argOrdinal]); 8489trackState(values[argOrdinal], restField, types[argOrdinal]); 8548trackConvertedValue(targetElements[i], conversions[i], valueElements[i]); 10184placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 10210var parameter = parameters[i + offset]; 10211var (placeholder, placeholderConversion) = conversion.DeconstructConversionInfo[i]; 10216var nestedRight = CreatePlaceholderIfNecessary(invocation.Arguments[i + offset], parameter.TypeWithAnnotations); 10230var parameter = parameters[i + offset]; 10252var (placeholder, placeholderConversion) = deconstructConversionInfo[i]; 10254var rightPart = rightParts[i];

FlowAnalysis\NullableWalker.SnapshotManager.cs (5)

46int currentPosition = incrementalSnapshots[i].position; 56var sharedState = _walkerSharedStates[incrementalSnapshot.SharedStateIndex]; 63var sharedState = _walkerSharedStates[snapshot.SharedStateIndex]; 100return _incrementalSnapshots[snapshotIndex].snapshot; 118RoslynDebug.Assert(_walkerSharedStates.Length > _incrementalSnapshots[position].snapshot.SharedStateIndex, $"Did not find shared state for {node} `{node.Syntax}`.");

FlowAnalysis\NullableWalker_Patterns.cs (6)

201BoundSubpattern item = rp.Deconstruction[i]; 202FieldSymbol element = elements[i]; 451var parameterType = method.Parameters[i + extensionExtra].TypeWithAnnotations; 514((BoundTupleExpression)expression).Arguments[originalTupleElement.TupleElementIndex]); 518Debug.Assert(originalInputMap[outputSlot] == ((BoundTupleExpression)expression).Arguments[originalTupleElement.TupleElementIndex]); 1000var arm = node.SwitchArms[i];

Lowering\ClosureConversion\ClosureConversion.cs (3)

609var potentialParameter = lambda.Parameters[i]; 897var frameType = (NamedTypeSymbol)loweredSymbol.Parameters[i].Type.OriginalDefinition; 1553_parameterMap.Add(parameter, synthesizedMethod.Parameters[parameter.Ordinal]);

Lowering\DiagnosticsPass_Warnings.cs (6)

28if (argumentRefKindsOpt[i] != RefKind.None) 30var argument = arguments[i]; 244if (method.Parameters[i].RefKind != RefKind.None && (argumentRefKindsOpt.IsDefault || argumentRefKindsOpt[i] == RefKind.None)) return true; 916var leftArgument = leftArguments[i]; 917var rightArgument = rightTuple.Arguments[i];

Lowering\Extensions.cs (1)

21return ArgumentRefKinds[index];

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (2)

577if (refKinds[i] is not (RefKind.Ref or RefKind.Out)) 583if (!TryGetLocalOrParameterInfo(arguments[i], out var targetSymbol, out var targetType, out var targetIndex))

Lowering\LocalRewriter\LocalRewriter.cs (3)

767if (stmt == null || (optimize && IsFieldOrPropertyInitializer(originalStatements[i]) && ShouldOptimizeOutInitializer(stmt))) 796if (IsFieldOrPropertyInitializer(originalStatements[i])) 798BoundStatement original = originalStatements[i];

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.cs (9)

392BoundDecisionDagNode node = nodesToLower[i]; 418BoundDecisionDagNode nextNode = ((i + 1) < length) ? nodesToLower[i + 1] : null; 444Debug.Assert(node == nodesToLower[indexOfNode]); 460nodesToLower[indexOfNode + 1] == evaluationNode && 461!loweredNodes.Contains(nodesToLower[indexOfNode + 2]) ? nodesToLower[indexOfNode + 2] : null; 830_loweredDecisionDag.Add(_factory.ConditionalGoto(MakeValueTest(node.Syntax, input, cases[i].value), cases[i].label, jumpIfTrue: true)); 839_loweredDecisionDag.Add(_factory.ConditionalGoto(MakeRelationalTest(node.Syntax, input, lessThanOrEqualOperator, cases[firstIndex + half - 1].value), gt, jumpIfTrue: false));

Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (3)

187ParameterSymbol parameter = method.Parameters[i]; 623var field = loweredInput.Type.TupleElements[i].CorrespondingTupleField; 625var expr = loweredInput.Arguments[i];

Lowering\LocalRewriter\LocalRewriter_Block.cs (1)

81BoundStatement? statement = VisitPossibleUsingDeclaration(statements[i], statements, i, out var replacedUsingDeclarations);

Lowering\LocalRewriter\LocalRewriter_Call.cs (14)

739var argument = arguments[i]; 833var argument = arguments[argumentIndex]; 878var paramIndex = argsToParamsOpt.IsDefault ? argIndex : argsToParamsOpt[argIndex]; 880RefKind paramRefKind = parameters[paramIndex].RefKind; 1026if (expanded && TryOptimizeParamsArray(rewrittenArguments[rewrittenArguments.Length - 1], out optimized)) 1160var paramRefKind = parameters[i].RefKind; 1163var argRefKind = argumentRefKindsOpt.IsDefault ? RefKind.None : argumentRefKindsOpt[i]; 1169var argRefKind = argumentRefKindsOpt.IsDefault ? RefKind.None : argumentRefKindsOpt[i]; 1173Debug.Assert(parameters[i].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }); 1266var element = elements[i]; 1319BoundExpression argument = rewrittenArguments[a]; 1320int p = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[a] : a; 1322RefKind paramRefKind = parameters[p].RefKind; 1615RefKind paramRefKind = parameters[argIndex].RefKind;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (4)

592var element = VisitExpression((BoundExpression)elements[i]); 1220var rewrittenExpression = RewriteCollectionExpressionElementExpression(elements[i]); 1239var element = elements[i]; 1283var element = elements[i];

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (6)

523if (CanChangeValueBetweenReads(arguments[i])) 526var temp = _factory.StoreToTemp(VisitExpression(arguments[i]), out assignmentToTemp, indexerAccess.ArgumentRefKindsOpt.RefKinds(i) != RefKind.None ? RefKind.Ref : RefKind.None); 533loweredArguments[i] = arguments[i]; 791if (CanChangeValueBetweenReads(loweredIndices[i])) 794var temp = _factory.StoreToTemp(loweredIndices[i], out assignmentToTemp); 801boundTempIndices[i] = loweredIndices[i];

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (3)

969var fieldAccess = MakeTupleFieldAccessAndReportUseSiteDiagnostics(savedTuple, syntax, srcElementFields[i]); 970var convertedFieldAccess = MakeConversionNode(syntax, fieldAccess, elementConversions[i], destElementTypes[i].Type, @checked, explicitCastInCode);

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (4)

230var (placeholder, nestedConversion) = deconstructConversionInfo[i]; 236resultPart = ApplyDeconstructionConversion(nested, rightParts[i], 241var rightPart = rightParts[i]; 364var fieldAccess = MakeTupleFieldAccessAndReportUseSiteDiagnostics(tuple, expression.Syntax, fields[i]);

Lowering\LocalRewriter\LocalRewriter_Field.cs (1)

89currentLinkType = (NamedTypeSymbol)currentLinkType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestPosition - 1].Type;

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (1)

30BoundLocalDeclaration localDecl = localDecls[i];

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

597var arg = args[i];

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (3)

46if (construction.ArgumentRefKindsOpt[i] == RefKind.Out) 51Debug.Assert(construction.ArgumentRefKindsOpt[i] == RefKind.None); 168var part = node.Parts[i];

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (13)

67var element = tuple.Arguments[i]; 68var elementConversion = underlyingConversions[i]; 69var elementType = resultTypes[i].Type; 119var fieldAccess = MakeTupleFieldAccessAndReportUseSiteDiagnostics(savedTuple, syntax, srcElementFields[i]); 121syntax, fieldAccess, elementConversions[i], boundConversion.Checked, boundConversion.ExplicitCastInCode, null, null, destElementTypes[i].Type, boundConversion.HasErrors); 155var argument = tuple.Arguments[i]; 156var newArgument = ReplaceTerminalElementsWithTemps(argument, multiple.Operators[i], initEffects, temps); 452argumentBuilder.Add(MakeBoundConversion(GetTuplePart(operand, i), underlyingConversions[i], types[i], conv)); 495BoundExpression nextLogicalOperand = RewriteTupleOperator(nestedOperators[i], leftElement, rightElement, type, temps, operatorKind); 521return tupleExpression.Arguments[i]; 530return MakeTupleFieldAccessAndReportUseSiteDiagnostics(tuple, tuple.Syntax, tuple.Type.TupleElements[i]);

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (1)

75result = RewriteDeclarationUsingStatement(syntax, declarations[i], result, awaitKeyword, awaitOpt, patternDisposeInfo);

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (5)

584loweredArguments[i], 585argumentNames.IsDefaultOrEmpty ? NoName : argumentNames[i], 586refKinds.IsDefault ? RefKind.None : refKinds[i], 770byRefs[j] = getRefKind(refKinds[i]); 914result[j++] = arguments[i].Type ?? systemObjectType;

Lowering\SpillSequenceSpiller.cs (6)

611if (newList[i].Kind == SpillSequenceBuilderKind) 626builder = new BoundSpillSequenceBuilder(lastSpill < newList.Length ? (newList[lastSpill] as BoundSpillSequenceBuilder)?.Syntax : null); 634var refKind = refKinds.IsDefault ? RefKind.None : refKinds[i]; 635var replacement = Spill(builder, newList[i], refKind, sideEffectsOnly); 648var lastSpillNode = (BoundSpillSequenceBuilder)newList[lastSpill]; 654result.Add(newList[i]);

Operations\CSharpOperationFactory.cs (5)

1551=> arg.@this.CreateBoundInterpolatedStringExpressionOperation(boundInterpolatedString, arg.Data.PositionInfo[i]); 2304var part = parts[i]; 2305var currentPosition = positionInfo[i]; 2389BoundExpression? alignment = alignmentIndex == -1 ? null : arguments[alignmentIndex]; 2391BoundExpression? format = formatIndex == -1 ? null : arguments[formatIndex];

Operations\CSharpOperationFactory_Methods.cs (9)

313var argumentKind = GetArgumentKind(arguments[i], ref defaultArguments, i); 314argumentsBuilder.Add(operationFactory.CreateArgumentOperation(argumentKind, parameters[i].GetPublicSymbol(), arguments[i])); 323argumentsBuilder.Add(operationFactory.CreateArgumentOperation(argumentKind, null, arguments[i])); 373BoundExpression argument = arguments[a]; 375int p = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[a] : a; 376var parameter = parameters[p]; 421IOperation value = Create(arguments[i]); 481var currentDeclaration = declarations[currentDeclarationIndex];

SymbolDisplay\SymbolDisplayVisitor.Types.cs (5)

499tupleSymbol = (INamedTypeSymbol)currentUnderlying.TypeArguments[NamedTypeSymbol.ValueTupleRestPosition - 1]; 552var element = elements[i]; 800var typeArg = typeArguments[i]; 828AddCustomModifiersIfNeeded(modifiers[i], leadingSpace: true, trailingSpace: false); 909ITypeSymbol baseType = typeParam.ConstraintTypes[i];

Symbols\AbstractTypeMap.cs (10)

66var oldArgument = oldTypeArguments[i]; 142NamedTypeSymbol modifier = ((CSharpCustomModifier)customModifiers[i]).ModifierSymbol; 150builder.Add(customModifiers[i].IsOptional ? CSharpCustomModifier.CreateOptional(substituted) : CSharpCustomModifier.CreateRequired(substituted)); 153modifier = ((CSharpCustomModifier)customModifiers[i]).ModifierSymbol; 158builder.Add(customModifiers[i].IsOptional ? CSharpCustomModifier.CreateOptional(substituted) : CSharpCustomModifier.CreateRequired(substituted)); 162builder.Add(customModifiers[i]); 297var t = original[i]; 306result[j] = original[j]; 414var t = original[i]; 423result[j] = original[j];

Symbols\AnonymousTypes\AnonymousTypeManager.cs (1)

50return anonymous.Properties[index];

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (5)

205var field = fields[i]; 236var original = TypeWithAnnotations.Create(genericFieldTypes[index].Type); 264refKinds[i] = fields[i].RefKind; 306if (!isValidTypeArgument(useUpdatedEscapeRules, runtimeSupportsByRefLikeGenerics, fields[i], ref needsIndexedName)) 311var returnParameter = fields[n - 1];

Symbols\AnonymousTypes\PublicSymbols\AnonymousType.DelegatePublicSymbol.cs (1)

60var field = fields[i];

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ConstructorSymbol.cs (1)

32PropertySymbol property = properties[index];

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.DelegateTemplateSymbol.cs (7)

60new SynthesizedDelegateInvokeMethod.ParameterDescription(TypeWithAnnotations.Create(typeParams[i]), refKinds.IsNull ? RefKind.None : refKinds[i], ScopedKind.None, defaultValue: null, isParams: false, hasUnscopedRefAttribute: false)); 64var returnType = TypeWithAnnotations.Create(voidReturnTypeOpt ?? typeParams[parameterCount]); 129var field = fields[i]; 130var type = TypeWithAnnotations.Create(typeParams[i]); 145var returnType = TypeWithAnnotations.Create(returnsVoid ? returnParameter.Type : typeParams[parameterCount]); 180allowsRefLikeType: typeParametersToSubstitute[i].AllowsRefLikeType)); 200var field = fields[i];

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TemplateSymbol.cs (2)

55AnonymousTypeField field = typeDescr.Fields[fieldIndex]; 196string fieldName = this.Properties[fieldIndex].Name;

Symbols\Attributes\AttributeData.cs (1)

796if (attributes[i].IsTargetAttribute(description))

Symbols\Attributes\SourceAttributeData.cs (4)

146int sourceArgIndex = _constructorArgumentsSourceIndices[parameterIndex]; 152Debug.Assert(this.AttributeConstructor.Parameters[parameterIndex].IsOptional || 153this.AttributeConstructor.Parameters[parameterIndex].IsParamsArray); 282TypeSymbol parameterType = parameters[parameterIndex].Type;

Symbols\Compilation_UsedAssemblies.cs (2)

105foreach (var dependency in assembly.Modules[i].ReferencedAssemblySymbols) 132foreach (var dependency in SourceAssembly.Modules[i].ReferencedAssemblySymbols)

Symbols\Compilation_WellKnownMembers.cs (1)

1110return named.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[argumentIndex].Type;

Symbols\ConstraintsHelper.cs (4)

427var constraint = constraintClauses[i]; 428var typeParameter = typeParameters[i]; 914if (!CheckConstraints(containingSymbol, in args, substitution, typeParameters[i], typeArguments[i], diagnosticsBuilder, nullabilityDiagnosticsBuilderOpt,

Symbols\ConstructedNamedTypeSymbol.cs (2)

104if (!typeArguments[i].Is(typeParameters[i]))

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (5)

361var thisParam = _parameters[i]; 362var otherParam = signature._parameters[i]; 464var originalParam = originalParameters[i]; 465var substitutedType = substitutedParameterTypes[i]; 466var customModifiers = substitutedRefCustomModifiers.IsDefault ? originalParam.RefCustomModifiers : substitutedRefCustomModifiers[i];

Symbols\MemberSignatureComparer.cs (2)

648if (!HaveSameConstraints(typeParameters1[i], typeMap1, typeParameters2[i], typeMap2))

Symbols\Metadata\PE\DynamicTypeDecoder.cs (1)

425private bool PeekFlag() => _index < _dynamicTransformFlags.Length && _dynamicTransformFlags[_index];

Symbols\Metadata\PE\MemberRefMetadataDecoder.cs (4)

106typeArgument = namedType.TypeParameters[position - arityOffset]; 238if (!ParametersMatch(candidateMethod.Parameters[i], candidateMethodTypeMap, ref targetParamInfo[i + 1 /*for return type*/])) 322var targetCustomModifier = targetCustomModifiers[i]; 323CustomModifier candidateCustomModifier = candidateCustomModifiers[i];

Symbols\Metadata\PE\MetadataDecoder.cs (4)

83return typeParameters[position]; 103return type.TypeParameters[position]; 241if (ReferenceEquals(containingAssembly, assemblies[i])) 255if (IsOrClosedOverATypeFromAssemblies(arguments[i].Type, assemblies))

Symbols\Metadata\PE\NativeIntegerTypeDecoder.cs (1)

120return (_transformFlags[_index++], type.IsNativeIntegerWrapperType) switch

Symbols\Metadata\PE\PENamedTypeSymbol.cs (15)

957if (instanceIndex < uncommon.lazyInstanceEnumFields.Length && uncommon.lazyInstanceEnumFields[instanceIndex].Handle == fieldDef) 959yield return uncommon.lazyInstanceEnumFields[instanceIndex]; 964if (staticIndex < staticFields.Length && staticFields[staticIndex].Kind == SymbolKind.Field) 966var field = (PEFieldSymbol)staticFields[staticIndex]; 980Debug.Assert(staticIndex == staticFields.Length || staticFields[staticIndex].Kind != SymbolKind.Field); 1071if (members[index].Kind != SymbolKind.Method) 1076var method = (MethodSymbol)members[index]; 1089if (index >= members.Length || members[index].Kind != SymbolKind.Method) 1095var method = (PEMethodSymbol)members[index]; 1117if (index == members.Length || members[index].Kind != SymbolKind.Method) 1124method = (PEMethodSymbol)members[index]; 2444if (members[i].Kind == kind) 2466var member = members[i]; 2763var containingTypeParameter = containingTypeParameters[i]; 2764var nestedTypeParameter = nestedTypeParameters[i];

Symbols\Metadata\PE\PEParameterSymbol.cs (1)

765if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal))

Symbols\Metadata\PE\SymbolFactory.cs (2)

129if (refersToNoPiaLocalType[i] || 131MetadataDecoder.IsOrClosedOverATypeFromAssemblies(arguments[i].Key, linkedAssemblies)))

Symbols\Metadata\PE\TupleTypeDecoder.cs (3)

220var param = type.Signature.Parameters[i]; 318TypeWithAnnotations typeArg = typeArgs[i]; 375if (_elementNames[start + i] != null)

Symbols\MethodSymbol.cs (1)

906internal TypeSymbol GetParameterType(int index) => ParameterTypesWithAnnotations[index].Type;

Symbols\MethodSymbolExtensions.cs (1)

18return method.ParameterCount != 0 && method.Parameters[method.ParameterCount - 1].IsParams;

Symbols\ModuleSymbol.cs (1)

248return referencedAssemblies[referencedAssemblyIndex];

Symbols\NamedTypeSymbol.cs (7)

86var result = TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[index]; 886var typeArgument = typeArguments[i]; 887var otherTypeArgument = otherTypeArguments[i]; 1055TypeWithAnnotations typeArgumentA = typeArgumentsA[i]; 1056TypeWithAnnotations typeArgumentB = typeArgumentsB[i]; 1057VarianceKind typeArgumentVariance = GetTypeArgumentVariance(variance, isTuple ? VarianceKind.Out : typeParameters[i].Variance); 1660typeToCheck = ((NamedTypeSymbol)typeToCheck).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type;

Symbols\ParameterSignature.cs (1)

43var parameter = parameters[parm];

Symbols\PropertySymbolExtensions.cs (1)

15return property.ParameterCount != 0 && property.Parameters[property.ParameterCount - 1].IsParams;

Symbols\PublicModel\NamedTypeSymbol.cs (1)

96return UnderlyingNamedTypeSymbol.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ordinal].CustomModifiers;

Symbols\PublicModel\Symbol.cs (2)

47var type = typeArguments[i].EnsureCSharpSymbolOrNull(nameof(typeArguments)); 48var annotation = typeArgumentNullableAnnotations.IsDefault ? NullableAnnotation.Oblivious : typeArgumentNullableAnnotations[i].ToInternalAnnotation();

Symbols\ReducedExtensionMethodSymbol.cs (4)

178if (!typeArgsForConstraintsCheck[i].HasType) 186var typeArg = typeArgsForConstraintsCheck[i]; 189notInferredTypeParameters.Add(typeParams[i]); 571parameters.Add(new ReducedExtensionMethodParameterSymbol(this, reducedFromParameters[i + 1]));

Symbols\ReferenceManager.cs (21)

338assemblyModules[i].SetReferences(referencedModulesReferences[i - 1]); 430bound.AssemblySymbol = ((AssemblyDataForMetadataOrCompilation)allAssemblyData[i]).CreateAssemblySymbol(); 434Debug.Assert(allAssemblyData[i].IsLinked == bound.AssemblySymbol.IsLinked); 551var compilationData = assemblies[i] as AssemblyDataForCompilation; 559var fileData = (AssemblyDataForFile)assemblies[i]; 575if (assemblies[i].ContainsNoPiaLocalTypes) 583if (assemblies[i].IsLinked) 627var compilationData = assemblies[i] as AssemblyDataForCompilation; 634var fileData = (AssemblyDataForFile)assemblies[i]; 656retargetingAssemblySymbol.UnderlyingAssembly.Modules[j].GetReferencedAssemblies(); 680if (!underlyingReferencedAssemblySymbols[k].IsLinked) 682filteredReferencedAssemblies[newIndex] = referencedAssemblies[k]; 705symbols[k] = GetOrAddMissingAssemblySymbol(referencedAssemblies[k], ref missingAssemblies); 710modules[j].SetReferences(moduleReferences, sourceAssemblyDebugOnly); 733int moduleReferenceCount = fileData.Assembly.ModuleReferenceCounts[j]; 754modules[j].SetReferences(moduleReferences, sourceAssemblyDebugOnly); 776int refsCount = (moduleIndex == 0) ? totalReferencedAssemblyCount : modules[moduleIndex - 1].ReferencedAssemblies.Length; 811moduleSymbols[moduleIndex].SetReferences(references, sourceAssembly); 1118if (!sourceReferencedAssemblySymbols[i].IsLinked) 1120result.Add(sourceReferencedAssemblies[i]); 1126result.AddRange(modules[i].GetReferencedAssemblies());

Symbols\Retargeting\RetargetingAssemblySymbol.cs (1)

114PEModuleSymbol under = (PEModuleSymbol)underlyingAssembly.Modules[i];

Symbols\Retargeting\RetargetingEventSymbol.cs (1)

122var retargeted = this.RetargetingTranslator.Retarget(impls[i]);

Symbols\Retargeting\RetargetingMethodSymbol.cs (2)

179parameters.Add(new RetargetingMethodParameterSymbol(this, list[i])); 325var retargeted = this.RetargetingTranslator.Retarget(impls[i], MemberSignatureComparer.RetargetedExplicitImplementationComparer);

Symbols\Retargeting\RetargetingModuleSymbol.cs (13)

205while (underlyingBoundReferences[j].IsLinked) 212var definitionIdentity = ReferenceEquals(referencedAssemblySymbols[i], originatingSourceAssemblyDebugOnly) ? 214referencedAssemblySymbols[i].Identity; 216Debug.Assert(identityComparer.Compare(moduleReferences.Identities[i], definitionIdentity) != AssemblyIdentityComparer.ComparisonResult.NotEquivalent); 217Debug.Assert(identityComparer.Compare(moduleReferences.Identities[i], underlyingBoundReferences[j].Identity) != AssemblyIdentityComparer.ComparisonResult.NotEquivalent); 220if (!ReferenceEquals(referencedAssemblySymbols[i], underlyingBoundReferences[j])) 224if (!_retargetingAssemblyMap.TryGetValue(underlyingBoundReferences[j], out destinationData)) 226_retargetingAssemblyMap.Add(underlyingBoundReferences[j], 227new DestinationData { To = referencedAssemblySymbols[i] }); 231Debug.Assert(ReferenceEquals(destinationData.To, referencedAssemblySymbols[i])); 237while (j < underlyingBoundReferences.Length && underlyingBoundReferences[j].IsLinked)

Symbols\Retargeting\RetargetingPropertySymbol.cs (2)

116parameters[i] = new RetargetingPropertyParameterSymbol(this, list[i]); 182var retargeted = this.RetargetingTranslator.Retarget(impls[i], MemberSignatureComparer.RetargetedExplicitImplementationComparer);

Symbols\Retargeting\RetargetingSymbolTranslator.cs (3)

304PEModuleSymbol addedModule = (PEModuleSymbol)this.RetargetingAssembly.Modules[module.Ordinal]; 719var oldModifier = oldModifiers[i]; 1062return retargetedContainingType.TypeParameters[typeParameter.Ordinal];

Symbols\Source\CustomModifierUtils.cs (2)

128SourceParameterSymbolBase destinationParameter = (SourceParameterSymbolBase)destinationParameters[i]; 129ParameterSymbol sourceParameter = sourceParameters[i];

Symbols\Source\ExplicitInterfaceHelpers.cs (2)

402if (implementedMemberParameters[i].RefKind != collisionCandidateParameters[i].RefKind)

Symbols\Source\FieldSymbolWithAttributesAndModifiers.cs (1)

332diagnostics.Add(ErrorCode.ERR_StructOffsetOnBadStruct, allAttributeSyntaxNodes[i].Name.Location);

Symbols\Source\LambdaSymbol.cs (1)

367type = parameterTypes[p];

Symbols\Source\SourceAssemblySymbol.cs (11)

183var peModuleSymbol = (Metadata.PE.PEModuleSymbol)_modules[i]; 996ModuleSymbol m = _modules[i]; 1028var m = (PEModuleSymbol)_modules[i]; 1196CSharpAttributeData attribute = appliedSourceAttributes[i]; 1287var peModuleSymbol = (Metadata.PE.PEModuleSymbol)_modules[i]; 1339CSharpAttributeData attribute = attributesFromNetModules[i]; 1343if (!attribute.HasErrors && ValidateAttributeUsageForNetModuleAttribute(attribute, netModuleNames[i], diagnostics, ref uniqueAttributes)) 1394var peModuleSymbol = (PEModuleSymbol)_modules[i]; 1499CSharpAttributeData attribute = attributesFromNetModules[i]; 1500if (!attribute.HasErrors && ValidateAttributeUsageForNetModuleAttribute(attribute, netModuleNames[i], BindingDiagnosticBag.Discarded, ref uniqueAttributes)) 2872var peModuleSymbol = (Metadata.PE.PEModuleSymbol)_modules[i];

Symbols\Source\SourceComplexParameterSymbol.cs (4)

434return definition.Parameters[this.Ordinal].MetadataName; 486return (SourceParameterSymbol)implParameters[this.Ordinal]; 507return (SourceParameterSymbol)defParameters[this.Ordinal]; 692if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal))

Symbols\Source\SourceConstructorSymbolBase.cs (1)

73if (this.IsVararg && (IsGenericMethod || ContainingType.IsGenericType || _lazyParameters.Length > 0 && _lazyParameters[_lazyParameters.Length - 1].IsParams))

Symbols\Source\SourceDelegateMethodSymbol.cs (1)

115var parameterSymbol = invoke.Parameters[i];

Symbols\Source\SourceMemberContainerSymbol.cs (25)

398var decl = declaration.Declarations[i]; 410mods, allowedModifiers, declaration.Declarations[i].NameLocation, diagnostics, 453: ErrorCode.ERR_DuplicateNameInNS, declaration.Declarations[i].NameLocation, this.Name, this.ContainingSymbol); 462diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, declaration.Declarations[i].NameLocation, this.ContainingSymbol, this.Name); 472var singleDeclaration = declaration.Declarations[i]; 1185found = group[initializerIndex]; 1212length += getInitializerLength(initializers[i]); 1258if (precedingInitializerIndex >= 0 && initializers[precedingInitializerIndex].Syntax.Span.Contains(position)) 2154var refKind1 = method1.Parameters[i].RefKind; 2155var refKind2 = method2.Parameters[i].RefKind; 2559if (!op1.ParameterTypesWithAnnotations[p].Equals(op2.ParameterTypesWithAnnotations[p], TypeCompareKind.AllIgnoreOptions)) 2998Debug.Assert(LexicalSortKey.Compare(new LexicalSortKey(initializers[i - 1].First().Syntax, compilation), new LexicalSortKey(initializers[i].Last().Syntax, compilation)) < 0); 3003Debug.Assert(LexicalSortKey.Compare(new LexicalSortKey(initializers[i].First().Syntax, compilation), new LexicalSortKey(initializers[i + 1].Last().Syntax, compilation)) < 0); 3006if (initializers[i].Length != 1) 3008Debug.Assert(LexicalSortKey.Compare(new LexicalSortKey(initializers[i].First().Syntax, compilation), new LexicalSortKey(initializers[i].Last().Syntax, compilation)) < 0); 3068if (LexicalSortKey.Compare(sortKey, new LexicalSortKey(declaredMembers.InstanceInitializers[insertAt][0].Syntax, compilation)) < 0) 3077declaredMembers.DeclarationWithParameters.SyntaxTree == declaredMembers.InstanceInitializers[insertAt][0].Syntax.SyntaxTree && 3078declaredMembers.DeclarationWithParameters.Span.Contains(declaredMembers.InstanceInitializers[insertAt][0].Syntax.Span.Start)) 3081var declaredInitializers = declaredMembers.InstanceInitializers[insertAt]; 3945var methodParam = methodParams[i]; 3951var propertyParamType = (((i == numParams - 1) && !getNotSet) ? propertySymbol.TypeWithAnnotations : propertyParams[i].TypeWithAnnotations).Type;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (8)

1293var baseParameter = baseParameters[i]; 1296var overrideParameter = overrideParameters[parameterIndex]; 1330var overrideParam = overrideParameters[i + overrideParameterOffset]; 1331var baseParam = baseParameters[i]; 1456var baseParameter = baseParameters[i]; 1457var overrideParameter = overrideParameters[i + overrideParameterOffset]; 1507var baseParameter = baseParameters[i]; 1508var overrideParameter = overrideParameters[i + overrideParameterOffset];

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

1136if (namespaceSegments[i] != thisNamespaceNames[i]) 1349if (namespaceSegments[i] != thisNamespaceNames[i])

Symbols\Source\SourceNamedTypeSymbol.cs (14)

268return (constraintTypes.Length > 0) ? constraintTypes[ordinal] : ImmutableArray<TypeWithAnnotations>.Empty; 297return (constraintKinds.Length > 0) ? constraintKinds[ordinal] : TypeParameterConstraintKind.None; 505var constraint = constraintClauses[i]; 516if (!mergeConstraints(originalConstraintTypes, ref originalConstraintTypesMap, ref mergedConstraintTypes, otherPartialConstraints[i])) 525diagnostics.Add(ErrorCode.ERR_PartialWrongConstraints, GetFirstLocation(), this, typeParameters[i]); 535Debug.Assert(originalConstraintTypes[j].Equals(mergedConstraintTypes[j], TypeCompareKind.ObliviousNullableModifierMatchesAny)); 582TypeWithAnnotations constraintType1 = mergedConstraintTypes?[index1] ?? originalConstraintTypes[index1]; 592TypeWithAnnotations constraintType2 = clause.ConstraintTypes[index2]; 632result[constraintTypes[i]] = i; // Use the first type among the duplicates as the source of the nullable information 658var constraint = constraintClauses[i]; 665mergeConstraints(ref mergedKind, originalConstraintTypes, otherPartialConstraints[i]); 1582diagnostics.Add(ErrorCode.ERR_ComImportWithoutUuidAttribute, allAttributeSyntaxNodes[index].Name.Location); 1630diagnostics.Add(ErrorCode.WRN_CoClassWithoutComImport, allAttributeSyntaxNodes[index].Location, this.Name); 1639diagnostics.Add(ErrorCode.ERR_DefaultMemberOnIndexedType, allAttributeSyntaxNodes[index].Name.Location);

Symbols\Source\SourceOrdinaryMethodSymbol.cs (7)

194(args.declaredConstraints[typeParameterSymbol.Ordinal].Constraints & (TypeParameterConstraintKind.ReferenceType | TypeParameterConstraintKind.Default)) == 0; 606var typeParameter1 = typeParameters1[i]; 607var typeParameter2 = typeParameters2[i]; 645var typeParameter = this.TypeParameters[i]; 648switch (declaredConstraints[i].Constraints & (TypeParameterConstraintKind.ReferenceType | TypeParameterConstraintKind.ValueType | TypeParameterConstraintKind.Default)) 676overriddenOrExplicitlyImplementedMethod.TypeParameters[i], overriddenOrExplicitlyImplementedMethod); 900else if (isVararg && (IsGenericMethod || ContainingType.IsGenericType || Parameters.Length > 0 && Parameters[Parameters.Length - 1].IsParams))

Symbols\Source\SourcePropertySymbol.cs (3)

759var definitionParameter = (SourceParameterSymbol)this.Parameters[i]; 760var implementationParameter = (SourceParameterSymbol)implementation.Parameters[i]; 763diagnostics.Add(ErrorCode.ERR_ScopedMismatchInParameterOfPartial, implementation.GetFirstLocation(), new FormattedSymbol(implementation.Parameters[i], SymbolDisplayFormat.ShortFormat));

Symbols\Source\SourceTypeParameterSymbol.cs (5)

134var typeParameter = (SourceTypeParameterSymbolBase)implementingPart.TypeParameters[_ordinal]; 193var typeParameter = (SourceTypeParameterSymbolBase)sourceMethod.SourcePartialDefinition.TypeParameters[_ordinal]; 733var constraintTypes = constraints.IsEmpty ? ImmutableArray<TypeWithAnnotations>.Empty : constraints[Ordinal]; 746return constraintKinds.IsEmpty ? TypeParameterConstraintKind.None : constraintKinds[Ordinal]; 779return ((object)overriddenMethod != null) ? overriddenMethod.TypeParameters[ordinal] : null;

Symbols\Source\TypeParameterConstraintClause.cs (2)

159TypeParameterConstraintClause constraintClause = constraintClauses[thisTypeParameter.Ordinal]; 225TypeParameterConstraintClause constraintClause = constraintClauses[thisTypeParameter.Ordinal];

Symbols\SubstitutedMethodSymbol.cs (5)

178return this.TypeArgumentsWithAnnotations[reducedFromTypeParameter.Ordinal].Type; 413if (!typeParameters[i].Equals( 414typeArguments[i].Type, 454if (!this.TypeArgumentsWithAnnotations[i].Equals(other.TypeArgumentsWithAnnotations[i], compareKind))

Symbols\SubstitutedPropertySymbol.cs (1)

161substituted[i] = new SubstitutedParameterSymbol(this, _containingType.TypeSubstitution, unsubstitutedParameters[i]);

Symbols\SubstitutedTypeParameterSymbol.cs (1)

71return reducedFrom.TypeParameters[this.Ordinal];

Symbols\Symbol_Attributes.cs (13)

344MessageID.IDS_FeatureGenericAttributes.CheckFeatureAvailability(diagnostics, attributesToBind[i]); 422Binder attributeBinder = binders[i]; 474CSharpAttributeData boundAttribute = boundAttributes[i]; 478attributesToBind[i].ArgumentList?.Arguments[0].Expression.Location is { } location) 785NamedTypeSymbol boundAttributeType = boundAttributeTypes[i]; 788if (binders[i] != earlyBinder.Next) 790earlyBinder = new EarlyWellKnownAttributeBinder(binders[i]); 795arguments.AttributeSyntax = attributesToBind[i]; 821var attributeType = attributeTypes[i]; 825this.EarlyDecodeWellKnownAttributeType(attributeType, attributeSyntaxList[i]); 859CSharpAttributeData boundAttribute = boundAttributes[i]; 860AttributeSyntax attributeSyntax = attributeSyntaxList[i]; 861Binder binder = binders[i];

Symbols\SymbolDistinguisher.cs (1)

203return _lazyDescriptions[index];

Symbols\Synthesized\Records\SynthesizedRecordDeconstruct.cs (2)

63var parameter = Parameters[i]; 64var positionalMember = _positionalMembers[i];

Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)

190var member = printableMembers[i];

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (2)

444if (!TypeSymbol.Equals(_parameters[i].Type, other._parameters[i].Type, compareKind))

Symbols\Tuples\TupleErrorFieldSymbol.cs (1)

212newOwner.TupleElementTypesWithAnnotations[TupleElementIndex],

Symbols\Tuples\TupleFieldSymbol.cs (1)

223newUnderlyingOwner = (NamedTypeSymbol)newUnderlyingOwner.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type;

Symbols\Tuples\TupleTypeSymbol.cs (17)

145underlyingType = ((NamedTypeSymbol)underlyingType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type); 213currentType = (NamedTypeSymbol)currentType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestPosition - 1].Type; 295var sourceName = sourceNames[i]; 296var wasInferred = noInferredNames ? false : inferredNames[i]; 298if (sourceName != null && !wasInferred && (allMissing || string.CompareOrdinal(destinationNames[i], sourceName) != 0)) 300diagnostics.Add(ErrorCode.WRN_TupleLiteralNameMismatch, literal.Arguments[i].Syntax.Parent!.Location, sourceName, destination); 625var providedName = elementNames.IsDefault ? null : elementNames[tupleFieldIndex]; 672var isError = errorPositions.IsDefault ? false : errorPositions[tupleFieldIndex]; 712currentValueTuple = (NamedTypeSymbol)oldUnderlying.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestIndex].Type; 747var providedName = elementNames.IsDefault ? null : elementNames[i]; 748var location = elementLocations.IsDefault ? null : elementLocations[i]; 759elementTypes[i], 773elementTypes[i], 793found = (NamedTypeSymbol)found.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type; 849var elementLocation = elementLocations[tupleFieldIndex]; 985var extensionTupleElementTypes = tuple.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type.TupleElementTypesWithAnnotations; 1060var member = members[i];

Symbols\TypeMap.cs (5)

75TypeParameterSymbol tp = typeParameters[i]; 76TypeWithAnnotations ta = typeArguments[i]; 180parameters.Add(currentParameters[i]); 208TypeParameterSymbol tp = from[i]; 209TypeWithAnnotations ta = to[i];

Symbols\TypeSymbol.cs (4)

347addAllInterfaces(interfaces[i], visited, result); 361var baseInterface = baseInterfaces[i]; 2104var typeParameter1 = typeParameters1[i]; 2105var typeParameter2 = typeParameters2[i];

Symbols\TypeSymbolExtensions.cs (8)

869(TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(fields[i].TypeWithAnnotations, canDigThroughNullable); 885next = fields[i].TypeWithAnnotations; 900(TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(typeArguments[i], canDigThroughNullable); 916next = typeArguments[i]; 979(TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(currentPointer.Parameters[i].TypeWithAnnotations, canDigThroughNullable); 996next = currentPointer.Parameters[i].TypeWithAnnotations; 1618if (!typeParameters[i].Equals( 1619typeArguments[i].Type.OriginalDefinition,

Symbols\TypeUnification.cs (2)

170if (!CanUnifyHelper(nt1Arguments[i], 171nt2Arguments[i],

Symbols\TypeWithAnnotations.cs (1)

680transformFlag = transforms[position++];

Symbols\UnboundGenericType.cs (1)

54string name = (i < typeParameters.Length) ? typeParameters[i].Name : string.Empty;

Symbols\VarianceSafety.cs (2)

385TypeParameterSymbol typeParam = namedType.TypeParameters[i]; 386TypeSymbol typeArg = namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[i].Type;

Syntax\CSharpSyntaxTree.cs (2)

215directives = _preprocessorStates[searchResult]; 224directives = _preprocessorStates[searchResult];

Syntax\NullableContextStateMap.cs (7)

55Debug.Assert(contexts[i - 1].Position < contexts[i].Position); 84Debug.Assert(_contexts[index].Position <= position); 85Debug.Assert(index == _contexts.Length - 1 || position < _contexts[index + 1].Position); 94return index < 0 ? GetContextForFileStart() : _contexts[index]; 107var context = index < 0 ? GetContextForFileStart() : _contexts[index]; 126context = _contexts[index];

Utilities\ValueSetFactory.NumericValueSet.cs (20)

42Debug.Assert(tc.Related(LessThanOrEqual, intervals[i].first, intervals[i].last)); 46Debug.Assert(tc.Related(LessThan, tc.Next(intervals[i - 1].last), intervals[i].first)); 68return _tc.ToConstantValue(this._intervals[this._intervals.Length - 1].last); 81return _intervals.Length > 0 && _tc.Related(relation, _intervals[_intervals.Length - 1].last, value); 96return _tc.Related(GreaterThanOrEqual, value, _intervals[lastIntervalIndex].first) && _tc.Related(LessThanOrEqual, value, _intervals[lastIntervalIndex].last); 99if (_tc.Related(LessThanOrEqual, value, _intervals[midIndex].last)) 118return _tc.Related(relation, _intervals[_intervals.Length - 1].last, value); 148builder.Add((_tc.Next(_intervals[i].last), _tc.Prev(_intervals[i + 1].first))); 152if (_tc.Related(LessThan, _intervals[lastIndex].last, _tc.MaxValue)) 154builder.Add((_tc.Next(_intervals[lastIndex].last), _tc.MaxValue)); 174var leftInterval = left[l]; 175var rightInterval = right[r]; 251var leftInterval = left[l]; 252var rightInterval = right[r]; 273var leftInterval = left[l]; 280var rightInterval = right[r];

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (2)

416var part = namespaceParts[index].EscapeIdentifier(); 429var 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];

GenerateType\CSharpGenerateTypeService.cs (2)

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

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (2)

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

InitializeParameter\CSharpInitializeMemberFromParameterCodeRefactoringProvider.cs (2)

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

SignatureHelp\LightweightOverloadResolution.cs (1)

226inParams |= method.Parameters[parameterIndex].IsParams;

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

160var lambdaParameter = lambdaMethod.Parameters[i]; 161var invokedParameter = invokedMethod.Parameters[i];

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

65var currentStatement = siblingStatements[i];

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

204var element = arrayCreationElements[startIndex + i];

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

232var parameter = method.Parameters[index];

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

113var match = matches[i]; 162var argument = matches[i].Node;

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

44var match = matches[i];

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

175var type = elements[i].Type;

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

65var match = matches[i];