ParameterCount

Binder\Binder.ValueChecks.cs (2)

642var argumentsBuilder = ArrayBuilder<BoundExpression>.GetInstance(accessorForDefaultArguments.ParameterCount); 648refKindsBuilderOpt = 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) 744if (method.ParameterCount != 0) 746var parameter = method.Parameters[method.ParameterCount - 1];

Binder\Binder_Conversions.cs (7)

606ParameterCount: 1, 638ParameterCount: 1, 671ParameterCount: 1, 1675if (collectionInitializer.Expanded && argIndex == collectionInitializer.AddMethod.ParameterCount - 1) 2321Debug.Assert(lambdaSymbol.ParameterCount == delegateParameters.Length); 2322for (int p = 0; p < lambdaSymbol.ParameterCount; p++) 2380if (lambdaParameter.IsParams && !delegateParameter.IsParams && p == lambdaSymbol.ParameterCount - 1)

Binder\Binder_Expressions.cs (2)

5109if (baseParameter.Ordinal == resultMember.ParameterCount - 1) 10621original.ParameterCount == 2 &&

Binder\Binder_Operators.cs (1)

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

Binder\Binder_Patterns.cs (1)

1084if (parameterIndex < deconstructMethod!.ParameterCount)

Binder\Binder_Statements.cs (3)

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

Binder\BinderFactory.BinderFactoryVisitor.cs (2)

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

Binder\DecisionDagBuilder.cs (1)

582int count = Math.Min(method.ParameterCount - extensionExtra, recursive.Deconstruction.Length);

Binder\ForEachLoopBinder.cs (6)

1106Debug.Assert(getEnumeratorMethod is null or { ParameterCount: 1 }); 1214var argsBuilder = ArrayBuilder<BoundExpression>.GetInstance(patternDisposeMethod.ParameterCount); 1412if (method.ParameterCount == 0 || isAsync) 1937Debug.Assert(resolvedMember is null or { ParameterCount: 0 }); 1949if (method.ParameterCount == 0) 1954var argsBuilder = ArrayBuilder<BoundExpression>.GetInstance(method.ParameterCount);

Binder\InMethodBinder.cs (1)

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

Binder\LockBinder.cs (1)

118ParameterCount: 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); 414var conversion = ToConversion(result, methodGroup, delegateType.DelegateInvokeMethod.ParameterCount); 502Debug.Assert(method.ParameterCount == parameterCount + (isExtensionMethod ? 1 : 0));

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

1502if (anonymousFunction.ParameterCount != invokeMethod.ParameterCount) 3382if (sourceSig.ParameterCount != destinationSig.ParameterCount || 3394for (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++) 3272if ((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\BoundExpression.cs (3)

424Debug.Assert(LogicalOperator.ParameterCount == 2); 425Debug.Assert(TrueOperator.ParameterCount == 1); 426Debug.Assert(FalseOperator.ParameterCount == 1);

BoundTree\Constructors.cs (1)

197if (i < method.ParameterCount)

BoundTree\NullabilityRewriter.cs (3)

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

BoundTree\UnboundLambda.cs (1)

1160int parameterCount = invoke.ParameterCount;

CodeGen\EmitExpression.cs (4)

3718if (getMethod.ParameterCount == 1) 3724Debug.Assert(getMethod.ParameterCount == 2); 3745if (getField.ParameterCount == 1) 3751Debug.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); 605baseTypeMethod.ParameterCount == 0 &&

Compiler\MethodCompiler.cs (1)

1255Debug.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)

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

FlowAnalysis\NullableWalker.cs (10)

4232else if (constructor?.ParameterCount == 1) 5115if (methodOpt?.ParameterCount == 2) 5365method?.ParameterCount == 2) 6823var parameterCount = method.ParameterCount; 9311targetInvokeMethod.ParameterCount != sourceMethod.ParameterCount) 10022Debug.Assert(method.ParameterCount == 1); 11158MethodSymbol? incrementOperator = (node.OperatorKind.IsUserDefined() && node.MethodOpt?.ParameterCount == 1) ? node.MethodOpt : null; 11173if (node.OperandConversion is BoundConversion { Conversion: var operandConversion } && operandConversion.IsUserDefined && operandConversion.Method?.ParameterCount == 1) 12107method.ParameterCount == 1)

FlowAnalysis\NullableWalker_Patterns.cs (1)

449for (int i = 0; i < method.ParameterCount - extensionExtra; i++)

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)

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

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

187for (int i = extensionExtra; i < method.ParameterCount; i++) 246Debug.Assert(e.Property.GetMethod.ParameterCount == 1);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (2)

1346Debug.Assert(conversion.Method is { } && !conversion.Method.ReturnsVoid && conversion.Method.ParameterCount == 1); 1507Debug.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)

746var ctor = type.InstanceConstructors.Single(c => c.ParameterCount == args.Length); 755var ctor = type.InstanceConstructors.Single(c => c.ParameterCount == args.Length); 862Debug.Assert(method.ParameterCount == args.Length); 904Debug.Assert(method.ParameterCount == args.Length); 1206var ctor = baseType.InstanceConstructors.Single(c => c.ParameterCount == 0);

Operations\CSharpOperationFactory.cs (1)

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

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

666keySelector: 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; 657if (constructor.ParameterCount != 0) 680return 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)

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

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

511if (additionalParameterCount + method.ParameterCount != candidate.ParameterCount) 543candidate.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)

1240int 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\NativeIntegerTypeSymbol.cs (1)

115if (underlyingMethod.ParameterCount == 0)

Symbols\ReducedExtensionMethodSymbol.cs (5)

40Debug.Assert(method.ParameterCount > 0); 97Debug.Assert(reducedFrom.ParameterCount > 0); 117Debug.Assert(method.ParameterCount > 0); 148var paramCount = method.ParameterCount; 512get { return _reducedFrom.ParameterCount - 1; }

Symbols\Retargeting\RetargetingSymbolTranslator.cs (1)

769var paramCount = signature.ParameterCount;

Symbols\Source\SourceDelegateMethodSymbol.cs (1)

367int paramCount = invoke.ParameterCount;

Symbols\Source\SourceMemberContainerSymbol.cs (8)

2233Debug.Assert(method1.ParameterCount == method2.ParameterCount); 2235for (int i = 0; i < method1.ParameterCount; i++) 2840if (op1.ParameterCount != op2.ParameterCount) 2845for (int p = 0; p < op1.ParameterCount; ++p) 4692if (m.MethodKind == MethodKind.Constructor && m.ParameterCount == 0) 5407hasParameterlessInstanceConstructor = hasParameterlessInstanceConstructor || method.ParameterCount == 0;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (6)

1266Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset); 1470Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset); 1521Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset);

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

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

Symbols\Source\SourceNamedTypeSymbol.cs (2)

1783var parameterlessConstructor = InstanceConstructors.FirstOrDefault(c => c.ParameterCount == 0); 1994|| !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)

351Debug.Assert(userMain.ParameterCount == 0 || userMain.ParameterCount == 1); 513Debug.Assert(ctor.ParameterCount == 0); 516Debug.Assert(initializer.ParameterCount == 0); 605Debug.Assert(ctor.ParameterCount == 1); 608Debug.Assert(initializer.ParameterCount == 0);

Symbols\TypeSymbolExtensions.cs (4)

967if (currentPointer.ParameterCount == 0) 989for (i = 0; i < currentPointer.ParameterCount - 1; i++) 2060if (funcPtrType.Signature.ParameterCount > 0) 2062var paramsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(funcPtrType.Signature.ParameterCount);

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

66get { return UnderlyingMethod.ParameterCount; }