ParameterCount

Binder\Binder.ValueChecks.cs (2)

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

Binder\Binder_Attributes.cs (2)

312if (hasErrors || attributeConstructor.ParameterCount == 0) 326Debug.Assert(rewrittenArguments.Length == attributeConstructor.ParameterCount);

Binder\Binder_Await.cs (2)

481if (method.ParameterCount != 0) 483var parameter = method.Parameters[method.ParameterCount - 1];

Binder\Binder_Conversions.cs (6)

600ParameterCount: 1, 632ParameterCount: 1, 665ParameterCount: 1, 2328Debug.Assert(lambdaSymbol.ParameterCount == delegateParameters.Length); 2329for (int p = 0; p < lambdaSymbol.ParameterCount; p++) 2387if (lambdaParameter.IsParams && !delegateParameter.IsParams && p == lambdaSymbol.ParameterCount - 1)

Binder\Binder_Expressions.cs (2)

5041if (baseParameter.Ordinal == resultMember.ParameterCount - 1) 10514original.ParameterCount == 2 &&

Binder\Binder_Invocation.cs (1)

2026if (!IsUnboundGeneric(m) && m.ParameterCount > 0)

Binder\Binder_Patterns.cs (1)

1072if (parameterIndex < deconstructMethod!.ParameterCount)

Binder\Binder_Statements.cs (3)

1339!(patternMethodSymbol.ParameterCount == 0 || patternMethodSymbol.IsStatic && patternMethodSymbol.ParameterCount == 1)) 3939if (ctor.ParameterCount == 0)

Binder\BinderFactory.BinderFactoryVisitor.cs (1)

1275Debug.Assert(property.SetMethod.ParameterCount > 0);

Binder\DecisionDagBuilder.cs (1)

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

Binder\ForEachLoopBinder.cs (6)

1113Debug.Assert(getEnumeratorMethod is null or { ParameterCount: 1 }); 1231var argsBuilder = ArrayBuilder<BoundExpression>.GetInstance(patternDisposeMethod.ParameterCount); 1427if (method.ParameterCount == 0 || isAsync) 1946Debug.Assert(resolvedMember is null or { ParameterCount: 0 }); 1957if (method.ParameterCount == 0) 1962var argsBuilder = ArrayBuilder<BoundExpression>.GetInstance(method.ParameterCount);

Binder\InMethodBinder.cs (1)

198if (_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)

967if (op.ParameterCount != 2 || op.ReturnsVoid)

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

98Debug.Assert(Method.ParameterCount == 2); 118Debug.Assert(Method.ParameterCount == 2);

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

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

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

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

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

1892else if (source.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int sourceParameterCount } sourceSignature } && 1893target.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int targetParameterCount } targetSignature } && 2431if (sourceSignature.ParameterCount != targetSignature.ParameterCount) 2443for (int i = 0; i < sourceSignature.ParameterCount; i++) 2781if (sourceSignature.ParameterCount != targetSignature.ParameterCount) 2793for (int i = 0; i < sourceSignature.ParameterCount; i++) 3266if ((method.ParameterCount < 1) || (arguments.Length < 1))

Binder\UsingStatementBinder.cs (1)

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

BoundTree\Constructors.cs (1)

190if (i < method.ParameterCount)

BoundTree\NullabilityRewriter.cs (3)

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

BoundTree\UnboundLambda.cs (1)

1124int parameterCount = invoke.ParameterCount;

CodeGen\EmitExpression.cs (4)

3706if (getMethod.ParameterCount == 1) 3712Debug.Assert(getMethod.ParameterCount == 2); 3733if (getField.ParameterCount == 1) 3739Debug.Assert(getField.ParameterCount == 2);

CodeGen\Optimizer.cs (1)

952((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)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (7)

402if (sig.ParameterCount > 0) 404var otherParamsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(sig.ParameterCount); 405var otherParamRefCustomModifiersBuilder = ArrayBuilder<ImmutableArray<CustomModifier>>.GetInstance(sig.ParameterCount); 486var key = new AnonymousDelegateWithIndexedNamePartialKey(delegateTemplate.Arity, delegateTemplate.DelegateInvokeMethod.ParameterCount); 919if (sig.ParameterCount > 0) 921var translatedParamsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(sig.ParameterCount); 922var translatedParamRefCustomModifiersBuilder = ArrayBuilder<ImmutableArray<CustomModifier>>.GetInstance(sig.ParameterCount);

Emitter\Model\MethodReference.cs (1)

54return (ushort)UnderlyingMethod.ParameterCount;

Emitter\Model\MethodSymbolAdapter.cs (1)

150return (ushort)AdaptedMethodSymbol.ParameterCount;

Emitter\Model\PEModuleBuilder.cs (1)

1223int ordinal = methodSymbol.ParameterCount;

FlowAnalysis\AbstractFlowPass.cs (1)

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

FlowAnalysis\NullableWalker.cs (13)

4142else if (constructor?.ParameterCount == 1) 4987if (methodOpt?.ParameterCount == 2) 5237method?.ParameterCount == 2) 6457var parameterCount = method.ParameterCount; 8837targetInvokeMethod.ParameterCount != sourceMethod.ParameterCount) 9542Debug.Assert(method.ParameterCount == 1); 10604MethodSymbol? incrementOperator = (node.OperatorKind.IsUserDefined() && node.MethodOpt?.ParameterCount == 1) ? node.MethodOpt : null; 10611if (node.OperandConversion is BoundConversion { Conversion: var operandConversion } && operandConversion.IsUserDefined && operandConversion.Method?.ParameterCount == 1) 11434method.ParameterCount == 1) 11523if ((object)node.LogicalOperator != null && node.LogicalOperator.ParameterCount == 2) 11549if (binary.LogicalOperator != null && binary.LogicalOperator.ParameterCount == 2) 11555if ((object)trueFalseOperator != null && trueFalseOperator.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)

39bool haveExtraParameter = sourceMethod.ParameterCount != implementationMethod.ParameterCount; 42Debug.Assert(implementationMethod.ParameterCount - 1 == sourceMethod.ParameterCount);

Lowering\ExtensionMethodReferenceRewriter.cs (2)

97if (receiverOpt is not null && arguments.Length == method.ParameterCount - 1) 108var 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)

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

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (2)

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

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

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

Symbols\Attributes\SourceAttributeData.cs (2)

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

Symbols\ConstraintsHelper.cs (1)

1494if (constructor.ParameterCount == 0)

Symbols\ConversionSignatureComparer.cs (3)

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

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (1)

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

Symbols\MemberSymbolExtensions.cs (3)

275return ((MethodSymbol)member).ParameterCount; 589if (constructor.ParameterCount != 0) 612return 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 (4)

414methodSymbol.ParameterCount != 1) // Tracked by https://github.com/dotnet/roslyn/issues/76130 : Should we accept more than one parameter (in case new versions add more info)? 483if (additionalParameterCount + method.ParameterCount != candidate.ParameterCount) 515candidate.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)

1230int 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)

114if (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; 510get { return _reducedFrom.ParameterCount - 1; }

Symbols\Retargeting\RetargetingSymbolTranslator.cs (1)

769var paramCount = signature.ParameterCount;

Symbols\Source\SourceDelegateMethodSymbol.cs (1)

364int paramCount = invoke.ParameterCount;

Symbols\Source\SourceMemberContainerSymbol.cs (3)

2195Debug.Assert(method1.ParameterCount == method2.ParameterCount); 2197for (int i = 0; i < method1.ParameterCount; i++)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (6)

1262Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset); 1465Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset); 1516Debug.Assert(baseMethod.ParameterCount == overrideMethod.ParameterCount - overrideParameterOffset);

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

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

Symbols\Source\SourceNamedTypeSymbol.cs (2)

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

346Debug.Assert(userMain.ParameterCount == 0 || userMain.ParameterCount == 1); 477Debug.Assert(ctor.ParameterCount == 0); 480Debug.Assert(initializer.ParameterCount == 0); 568Debug.Assert(ctor.ParameterCount == 1); 571Debug.Assert(initializer.ParameterCount == 0);

Symbols\TypeSymbolExtensions.cs (4)

956if (currentPointer.ParameterCount == 0) 978for (i = 0; i < currentPointer.ParameterCount - 1; i++) 2049if (funcPtrType.Signature.ParameterCount > 0) 2051var paramsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(funcPtrType.Signature.ParameterCount);

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

66get { return UnderlyingMethod.ParameterCount; }