ParameterCount

Binder\Binder.ValueChecks.cs (2)

644var argumentsBuilder = ArrayBuilder<BoundExpression>.GetInstance(accessorForDefaultArguments.ParameterCount); 650refKindsBuilderOpt = ArrayBuilder<RefKind>.GetInstance(accessorForDefaultArguments.ParameterCount);

Binder\Binder_Attributes.cs (2)

314if (hasErrors || attributeConstructor.ParameterCount == 0) 328Debug.Assert(rewrittenArguments.Length == attributeConstructor.ParameterCount);

Binder\Binder_Await.cs (3)

422|| method.ParameterCount != 1) 752if (method.ParameterCount != 0) 754var parameter = method.Parameters[method.ParameterCount - 1];

Binder\Binder_Conversions.cs (10)

678ParameterCount: 1, 710ParameterCount: 1, 743ParameterCount: 1, 1452argsToParams = argsToParams.Add(collectionBuilderMethod.ParameterCount - 1); 1552if (forParams && method.ParameterCount != 1) 2268if (collectionInitializer.Expanded && argIndex == collectionInitializer.AddMethod.ParameterCount - 1) 2748Debug.Assert(analysis.Operator is { ParameterCount: 1 } and ({ MethodKind: MethodKind.Constructor } or { MethodKind: MethodKind.Ordinary, IsStatic: true, ContainingType.IsInterface: true })); 3009Debug.Assert(lambdaSymbol.ParameterCount == delegateParameters.Length); 3010for (int p = 0; p < lambdaSymbol.ParameterCount; p++) 3068if (lambdaParameter.IsParams && !delegateParameter.IsParams && p == lambdaSymbol.ParameterCount - 1)

Binder\Binder_Expressions.cs (2)

5131if (baseParameter.Ordinal == resultMember.ParameterCount - 1) 10790original.ParameterCount == 2 &&

Binder\Binder_Operators.cs (1)

3860return method.ParameterCount == parameterCount && method.ReturnsVoid && !method.IsVararg &&

Binder\Binder_Patterns.cs (1)

1692if (parameterIndex < deconstructMethod!.ParameterCount)

Binder\Binder_Statements.cs (3)

1344!(patternMethodSymbol.ParameterCount == 0 || patternMethodSymbol.IsStatic && patternMethodSymbol.ParameterCount == 1)) 4000if (ctor.ParameterCount == 0)

Binder\Binder_Unsafe.cs (1)

93if (ctor.ParameterCount == 0)

Binder\BinderFactory.BinderFactoryVisitor.cs (2)

1251if (method.ParameterCount > 0) 1301Debug.Assert(property.SetMethod.ParameterCount > 0);

Binder\ForEachLoopBinder.cs (6)

1111Debug.Assert(getEnumeratorMethod is null or { ParameterCount: 1 }); 1220var argsBuilder = ArrayBuilder<BoundExpression>.GetInstance(patternDisposeMethod.ParameterCount); 1422if (method.ParameterCount == 0 || isAsync) 1949Debug.Assert(resolvedMember is null or { ParameterCount: 0 }); 1961if (method.ParameterCount == 0) 1966var argsBuilder = ArrayBuilder<BoundExpression>.GetInstance(method.ParameterCount);

Binder\InMethodBinder.cs (1)

199if (_methodSymbol.ParameterCount == 0 || (options & LookupOptions.NamespaceAliasesOnly) != 0)

Binder\LockBinder.cs (1)

122ParameterCount: 0,

Binder\MethodArgumentInfo.cs (1)

36Debug.Assert(method.ParameterCount == 0);

Binder\Semantics\Conversions\Conversions.cs (4)

109ToConversion(resolution.OverloadResolutionResult, resolution.MethodGroup, methodSymbol.ParameterCount); 126ToConversion(resolution.OverloadResolutionResult, resolution.MethodGroup, destination.Signature.ParameterCount); 427var conversion = ToConversion(result, methodGroup, delegateType.DelegateInvokeMethod.ParameterCount); 515Debug.Assert(method.ParameterCount == parameterCount + (isExtensionMethod ? 1 : 0));

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

1517if (anonymousFunction.ParameterCount != invokeMethod.ParameterCount) 3404if (sourceSig.ParameterCount != destinationSig.ParameterCount || 3416for (int i = 0; i < sourceSig.ParameterCount; i++)

Binder\Semantics\Conversions\UserDefinedExplicitConversions.cs (1)

266if (op.ReturnsVoid || op.ParameterCount != 1 || op.ReturnType.TypeKind == TypeKind.Error)

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

295if (op.ReturnsVoid || op.ParameterCount != 1)

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (1)

1007if (!op.IsStatic || op.ParameterCount != 2 || op.ReturnsVoid)

Binder\Semantics\Operators\BinaryOperatorSignature.cs (2)

98Debug.Assert(Method.ParameterCount == 2); 120Debug.Assert(Method.ParameterCount == rightIndex + 1);

Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (1)

827if (!op.IsStatic || op.ParameterCount != 1 || op.ReturnsVoid)

Binder\Semantics\Operators\UnaryOperatorSignature.cs (1)

52Debug.Assert(Method.ParameterCount == 1);

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

1895else if (source.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int sourceParameterCount } sourceSignature } && 1896target.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int targetParameterCount } targetSignature } && 2434if (sourceSignature.ParameterCount != targetSignature.ParameterCount) 2446for (int i = 0; i < sourceSignature.ParameterCount; i++) 2784if (sourceSignature.ParameterCount != targetSignature.ParameterCount) 2796for (int i = 0; i < sourceSignature.ParameterCount; i++) 3268if ((method.ParameterCount < 1) || (arguments.Length < 1))

Binder\UsingStatementBinder.cs (1)

209var argumentsBuilder = ArrayBuilder<BoundExpression>.GetInstance(disposeMethod.ParameterCount);

BoundTree\BoundBinaryOperator.UncommonData.cs (3)

21Debug.Assert(method.ParameterCount == 1); 25Debug.Assert(method is ErrorMethodSymbol or { ParameterCount: 2 }); 74Debug.Assert(method is null or ErrorMethodSymbol { ParameterCount: 0 } or { MethodKind: MethodKind.UserDefinedOperator } or { ParameterCount: 2 });

BoundTree\BoundDagEvaluation.cs (1)

322int count = method.ParameterCount - extensionExtra;

BoundTree\BoundExpression.cs (3)

434Debug.Assert(LogicalOperator.ParameterCount == 2); 435Debug.Assert(TrueOperator.ParameterCount == 1); 436Debug.Assert(FalseOperator.ParameterCount == 1);

BoundTree\Constructors.cs (1)

197if (i < method.ParameterCount)

BoundTree\NullabilityRewriter.cs (3)

256Debug.Assert(lambda.ParameterCount == updatedLambda.ParameterCount); 257for (int i = 0; i < lambda.ParameterCount; i++)

BoundTree\UnboundLambda.cs (1)

1168int parameterCount = invoke.ParameterCount;

CodeGen\EmitExpression.cs (4)

3723if (getMethod.ParameterCount == 1) 3729Debug.Assert(getMethod.ParameterCount == 2); 3750if (getField.ParameterCount == 1) 3756Debug.Assert(getField.ParameterCount == 2);

CodeGen\Optimizer.cs (1)

951((BoundObjectCreationExpression)right).Constructor.ParameterCount != 0);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (2)

31int paramCount = this.ParameterCount; 53for (int index = 0; index < this.ParameterCount; index++)

Compiler\MethodBodySynthesizer.cs (2)

90Debug.Assert(submissionConstructor.ParameterCount == 1); 607baseTypeMethod.ParameterCount == 0 &&

Compiler\MethodCompiler.cs (1)

1256Debug.Assert(!(methodSymbol.IsImplicitInstanceConstructor && methodSymbol.ParameterCount == 0) ||

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (7)

417if (sig.ParameterCount > 0) 419var otherParamsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(sig.ParameterCount); 420var otherParamRefCustomModifiersBuilder = ArrayBuilder<ImmutableArray<CustomModifier>>.GetInstance(sig.ParameterCount); 499var key = new AnonymousDelegateWithIndexedNamePartialKey(delegateTemplate.Arity, delegateTemplate.DelegateInvokeMethod.ParameterCount); 933if (sig.ParameterCount > 0) 935var translatedParamsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(sig.ParameterCount); 936var translatedParamRefCustomModifiersBuilder = ArrayBuilder<ImmutableArray<CustomModifier>>.GetInstance(sig.ParameterCount);

Emitter\Model\MethodReference.cs (1)

54return (ushort)UnderlyingMethod.ParameterCount;

Emitter\Model\MethodSymbolAdapter.cs (1)

160return (ushort)AdaptedMethodSymbol.ParameterCount;

Emitter\Model\PEModuleBuilder.cs (1)

1375int ordinal = methodSymbol.ParameterCount;

FlowAnalysis\AbstractFlowPass.cs (1)

3094Debug.Assert(method.ParameterCount is 1);

FlowAnalysis\NullableWalker.cs (11)

4433else if (constructor?.ParameterCount == 1) 5385if (methodOpt?.ParameterCount == 2) 5635method?.ParameterCount == 2) 7101var parameterCount = method.ParameterCount; 9698targetInvokeMethod.ParameterCount != sourceMethod.ParameterCount) 10468Debug.Assert(method.ParameterCount == 1); 10603Debug.Assert(analysis.Operator is { ParameterCount: 1 } and ({ MethodKind: MethodKind.Constructor } or { MethodKind: MethodKind.Ordinary, IsStatic: true, ContainingType.IsInterface: true })); 11779MethodSymbol? incrementOperator = (node.OperatorKind.IsUserDefined() && node.MethodOpt?.ParameterCount == 1) ? node.MethodOpt : null; 11794if (node.OperandConversion is BoundConversion { Conversion: ({ IsUserDefined: true } or { IsUnion: true }) and { Method.ParameterCount: 1 } operandConversion }) 12762method.ParameterCount == 1)

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

486method.ParameterCount == 0 &&

Lowering\DiagnosticsPass_Warnings.cs (1)

237if (method.ParameterCount != arguments.Length ||

Lowering\ExtensionMethodBodyRewriter.cs (2)

40bool haveExtraParameter = sourceMethod.ParameterCount != implementationMethod.ParameterCount; 43Debug.Assert(implementationMethod.ParameterCount - 1 == sourceMethod.ParameterCount);

Lowering\ExtensionMethodReferenceRewriter.cs (2)

100if (receiverOpt is not null && arguments.Length == method.ParameterCount - 1) 111var builder = ArrayBuilder<RefKind>.GetInstance(method.ParameterCount, RefKind.None);

Lowering\Extensions.cs (2)

54return creation.Constructor.ParameterCount != 0; 100return creation.Constructor.ParameterCount == 0;

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (1)

305var prologueBuilder = ArrayBuilder<BoundStatement>.GetInstance(_factory.CurrentFunction.ParameterCount);

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

261Debug.Assert(e.Property.GetMethod.ParameterCount == 1);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

1058else if (asSpanMethod is MethodSymbol { IsStatic: true, ParameterCount: 1 })

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (4)

962Debug.Assert(analysis.Operator is { ParameterCount: 1 } and ({ MethodKind: MethodKind.Constructor } or { MethodKind: MethodKind.Ordinary, IsStatic: true, ContainingType.IsInterface: true })); 1415Debug.Assert(conversion.Method is { } && !conversion.Method.ReturnsVoid && conversion.Method.ParameterCount == 1); 1560Debug.Assert(conversion.Method is { ParameterCount: 1 } and ({ MethodKind: MethodKind.Constructor } or { MethodKind: MethodKind.Ordinary, IsStatic: true, ContainingType.IsInterface: true })); 1619Debug.Assert(method.ParameterCount == 1);

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (2)

126enterMethod.ParameterCount == 2) 201Debug.Assert(enterMethod.ParameterCount == 1);

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (1)

184Debug.Assert(withExpr.CloneMethod.ParameterCount == 0);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

105Debug.Assert(elementInitializer.Arguments.Length == elementInitializer.AddMethod.ParameterCount);

Lowering\LocalRewriter\LocalRewriter_PropertyAccess.cs (1)

94Debug.Assert(getMethod.ParameterCount == rewrittenArguments.Length);

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (1)

792Debug.Assert(node.MethodOpt.ParameterCount == 1);

Lowering\SyntheticBoundNodeFactory.cs (5)

767var ctor = type.InstanceConstructors.Single(c => c.ParameterCount == args.Length); 776var ctor = type.InstanceConstructors.Single(c => c.ParameterCount == args.Length); 883Debug.Assert(method.ParameterCount == args.Length); 925Debug.Assert(method.ParameterCount == args.Length); 1227var ctor = baseType.InstanceConstructors.Single(c => c.ParameterCount == 0);

Operations\CSharpOperationFactory.cs (1)

3011if (patternDisposeInfo.Method.ParameterCount == 0)

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

654keySelector: template => new AnonymousDelegateWithIndexedNamePartialKey(template.Arity, template.DelegateInvokeMethod.ParameterCount),

Symbols\Attributes\SourceAttributeData.cs (2)

132Debug.Assert(parameterIndex < this.AttributeConstructor.ParameterCount); 140Debug.Assert(this.AttributeConstructor.ParameterCount <= attributeSyntax.ArgumentList.Arguments.Count);

Symbols\ConstraintsHelper.cs (1)

1521if (constructor.ParameterCount == 0)

Symbols\ConversionSignatureComparer.cs (3)

46if (member1.ParameterCount != 1 || member2.ParameterCount != 1) 65if (member.ParameterCount != 1)

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (1)

41return _originalMethod.ParameterCount + (_originalMethod.IsStatic ? 0 : 1);

Symbols\MemberSymbolExtensions.cs (3)

343return ((MethodSymbol)member).ParameterCount; 663if (constructor.ParameterCount != 0) 686return method.MethodKind == MethodKind.Constructor && method.ParameterCount == 0;

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

361if (sig.ParameterCount > 0) 364var paramsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(sig.ParameterCount);

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

220if (candidateMethod.ParameterCount != numParams)

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

184if (type.Signature.ParameterCount > 0) 186var builder = ArrayBuilder<TypeWithAnnotations>.GetInstance(type.Signature.ParameterCount);

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

519if (additionalParameterCount + method.ParameterCount != candidate.ParameterCount) 551candidate.Parameters.AsSpan(additionalParameterCount, candidate.ParameterCount - additionalParameterCount),

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

214if (type.Signature.ParameterCount > 0) 216var paramsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(type.Signature.ParameterCount); 218for (int i = type.Signature.ParameterCount - 1; i >= 0; i--)

Symbols\MethodSymbol.cs (1)

1247int IMethodSymbolInternal.ParameterCount => ParameterCount;

Symbols\MethodSymbolExtensions.cs (3)

18return method.ParameterCount != 0 && method.Parameters[method.ParameterCount - 1].IsParams; 46method.ParameterCount != 0 || method.Arity != 0 || !method.IsMetadataVirtual(MethodSymbol.IsMetadataVirtualOption.IgnoreInterfaceImplementationChanges))

Symbols\NamedTypeSymbol.cs (2)

1967ParameterCount: 1, 2002return ctor is { DeclaredAccessibility: Accessibility.Public, ParameterCount: 1, Parameters: [{ RefKind: RefKind.In or RefKind.None }] };

Symbols\NativeIntegerTypeSymbol.cs (1)

120if (underlyingMethod.ParameterCount == 0)

Symbols\ReducedExtensionMethodSymbol.cs (5)

41Debug.Assert(method.ParameterCount > 0); 98Debug.Assert(reducedFrom.ParameterCount > 0); 118Debug.Assert(method.ParameterCount > 0); 149var paramCount = method.ParameterCount; 515get { return _reducedFrom.ParameterCount - 1; }

Symbols\Retargeting\RetargetingSymbolTranslator.cs (1)

769var paramCount = signature.ParameterCount;

Symbols\Source\SourceDelegateMethodSymbol.cs (1)

370int paramCount = invoke.ParameterCount;

Symbols\Source\SourceMemberContainerSymbol.cs (9)

2072if (ctor.DeclaredAccessibility == Accessibility.Public && ctor.ParameterCount == 1 && ctor is not SynthesizedUnionCtor) 2354Debug.Assert(method1.ParameterCount == method2.ParameterCount); 2356for (int i = 0; i < method1.ParameterCount; i++) 2961if (op1.ParameterCount != op2.ParameterCount) 2966for (int p = 0; p < op1.ParameterCount; ++p) 4841if (m.MethodKind == MethodKind.Constructor && m.ParameterCount == 0) 5648hasParameterlessInstanceConstructor = hasParameterlessInstanceConstructor || method.ParameterCount == 0;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (6)

1297Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset); 1501Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset); 1552Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset);

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

980if (!IsStatic || ParameterCount > 0 || !ReturnsVoid || IsAbstract || IsVirtual)

Symbols\Source\SourceNamedTypeSymbol.cs (2)

1837var parameterlessConstructor = InstanceConstructors.FirstOrDefault(c => c.ParameterCount == 0); 2084|| !InstanceConstructors.Any(c => c is { ParameterCount: 0, DeclaredAccessibility: Accessibility.Internal or Accessibility.Public })

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

124if (ctor.ParameterCount == 1 && ctor.Parameters[0].RefKind == RefKind.None && 164ParameterCount: 0,

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

146return member is MethodSymbol { IsStatic: false, ParameterCount: 1, Arity: 0 } method &&

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

45if (member is MethodSymbol candidate && candidate.ParameterCount == 1 && candidate.Parameters[0].RefKind == RefKind.None &&

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (6)

355Debug.Assert(userMain.ParameterCount == 0 || userMain.ParameterCount == 1); 517Debug.Assert(ctor.ParameterCount == 0); 520Debug.Assert(initializer.ParameterCount == 0); 609Debug.Assert(ctor.ParameterCount == 1); 612Debug.Assert(initializer.ParameterCount == 0);

Symbols\TypeSymbolExtensions.cs (4)

1002if (currentPointer.ParameterCount == 0) 1024for (i = 0; i < currentPointer.ParameterCount - 1; i++) 2133if (funcPtrType.Signature.ParameterCount > 0) 2135var paramsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(funcPtrType.Signature.ParameterCount);

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

68get { return UnderlyingMethod.ParameterCount; }