Arity

Symbols\AnonymousTypes\PublicSymbols\AnonymousManager.TypeOrDelegatePublicSymbol.cs (1)

91public sealed override int Arity

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

266public sealed override int Arity

Symbols\ErrorTypeSymbol.cs (1)

285public override int Arity

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

604public abstract override int Arity

Symbols\Source\SourceMemberContainerSymbol.cs (1)

1071public override int Arity

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (1)

129public override int Arity => 0;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (1)

842public override int Arity => 1;

Symbols\Synthesized\SynthesizedContainer.cs (1)

176public override int Arity => TypeParameters.Length;

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (1)

55public override int Arity => 0;

Symbols\Synthesized\SynthesizedHotReloadExceptionSymbol.cs (1)

96public override int Arity => 0;

Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (1)

46public override int Arity => 1;

Symbols\Synthesized\SynthesizedPrivateImplementationDetailsType.cs (1)

39public override int Arity => 0;

Symbols\Wrapped\WrappedNamedTypeSymbol.cs (1)

52public override int Arity

Binder\Binder_Await.cs (2)

345if (expression.Type is not NamedTypeSymbol { Arity: 0 or 1 } exprType) 421|| method.Arity != exprType.Arity

Binder\Binder_Crefs.cs (4)

296|| nested.Arity != extensionArity 307typeParameters: IndexedTypeParameterSymbol.TakeSymbols(constructedNested.Arity), 620if (containerType.Name == memberName && (hasParameterList || containerType.Arity == 0 || !TypeSymbol.Equals(this.ContainingType, containerType.OriginalDefinition, TypeCompareKind.ConsiderEverything2))) 809if (containing.Arity > 0 && containing.IsDefinition)

Binder\Binder_Lookup.cs (3)

1825if (namedType.Arity != arity) 1827if (namedType.Arity == 0) 1835diagInfo = diagnose ? new CSDiagnosticInfo(ErrorCode.ERR_BadArity, namedType, MessageID.IDS_SK_TYPE.Localize(), namedType.Arity) : null;

Binder\BinderFactory.BinderFactoryVisitor.cs (1)

1345if (curr.Arity > 0)

Binder\LockBinder.cs (1)

91if (scopeType is not NamedTypeSymbol { Name: WellKnownMemberNames.LockScopeTypeName, Arity: 0, IsValueType: true, IsRefLikeType: true, DeclaredAccessibility: Accessibility.Public } ||

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

1723if (targetType is NamedTypeSymbol { Arity: 1 } namedType

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

1520if (extension.Arity == 0)

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

161if (extension.Arity == 0) 276if (extension.Arity != 0) 278extension = extension.Construct(IndexedTypeParameterSymbol.Take(extension.Arity));

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

3195Debug.Assert(extension.Arity > 0);

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

4457if (member.ContainingType.Arity > 0)

BoundTree\BoundInlineArrayAccess.cs (1)

57Arity: 1

BoundTree\UnboundLambda.cs (2)

332var resultType = taskType?.Arity == 0 ? 347var taskTypeT = taskType?.Arity == 1 ?

Compiler\ClsComplianceChecker.cs (1)

1079sawGeneric = sawGeneric || containingType.Arity > 0;

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (1)

593if (typeSymbol.Arity > 0)

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (3)

165ordinalOffset += curr.Arity; 186if (symbol.Arity != 0) 193builder.Append(symbol.Arity.ToString(System.Globalization.CultureInfo.InvariantCulture));

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (2)

523Debug.Assert(type.Arity == otherType.Arity);

Emitter\EditAndContinue\PEDeltaAssemblyBuilder.cs (1)

196anonymousDelegatesWithIndexedNames.AddPooled(new AnonymousDelegateWithIndexedNamePartialKey(type.Arity, parameterCount), value);

Emitter\Model\NamedTypeReference.cs (1)

32return (ushort)UnderlyingNamedType.Arity;

Emitter\Model\NamedTypeSymbolAdapter.cs (4)

101AdaptedNamedTypeSymbol.Arity > 0) 190(AdaptedNamedTypeSymbol.Arity == 0 || PEModuleBuilder.IsGenericType(AdaptedNamedTypeSymbol.ContainingType))) 481get { return (ushort)AdaptedNamedTypeSymbol.Arity; } 555return AdaptedNamedTypeSymbol.Arity != 0;

Emitter\Model\PEModuleBuilder.cs (2)

1170if (namedTypeSymbol.Arity > 0) 1268if (toCheck.Arity > 0)

FlowAnalysis\NullableWalker.cs (5)

4707if (extension.Arity == 0) 5209Debug.Assert(namedType.OriginalDefinition.Arity == 1); 5216Debug.Assert(namedType.OriginalDefinition.Arity == 1); 5716else if (method.ContainingType.Arity != 0) 12812else if (method.ContainingType.Arity != 0)

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

350if (builderType.IsUnboundGenericType && builderType.ContainingType?.IsGenericType != true && builderType.Arity == 1)

Lowering\ClosureConversion\ClosureConversion.cs (2)

916if (frameType.Arity > 0) 919Debug.Assert(typeParameters.Length == frameType.Arity);

Lowering\LocalRewriter\DelegateCacheContainer.cs (1)

40Debug.Assert(owner is NamedTypeSymbol { Arity: > 0 } or MethodSymbol { Arity: > 0 });

Lowering\LocalRewriter\DelegateCacheRewriter.cs (2)

151if (enclosingSymbol is NamedTypeSymbol { IsExtension: true, Arity: > 0 }) 192if (enclosingSymbol is NamedTypeSymbol { IsExtension: true, Arity: > 0 } extensionType &&

Lowering\LocalRewriter\LocalRewriter_TupleCreationExpression.cs (2)

56smallestType.Arity); 58NamedTypeSymbol.GetTupleCtor(smallestType.Arity),

Symbols\AssemblySymbol.cs (1)

889Debug.Assert(remainingTypeArguments >= symbol.Arity);

Symbols\Compilation_WellKnownMembers.cs (2)

1144if (named.Arity <= argumentIndex) 1166if (named.Arity == 0)

Symbols\ConstraintsHelper.cs (3)

683Debug.Assert(typeArgumentsSyntax.Count == 0 /*omitted*/ || typeArgumentsSyntax.Count == type.Arity); 935if (constructedContainingSymbol.IsExtensionBlockMember() && constructedContainingSymbol.ContainingType is { Arity: > 0 } extension 1578if (type.Arity == 0)

Symbols\ConstructedNamedTypeSymbol.cs (3)

26unbound: newContainer.IsUnboundGenericType && originalDefinition.Arity == 0) 71Debug.Assert(constructedFrom.Arity == typeArgumentsWithAnnotations.Length); 72Debug.Assert(constructedFrom.Arity != 0);

Symbols\ExtendedErrorTypeSymbol.cs (1)

318return ((NamedTypeSymbol)symbol).Arity;

Symbols\FieldSymbol.cs (1)

485int arity = ContainingType.Arity;

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (1)

211&& modifierType.Arity == 0

Symbols\MemberSymbolExtensions.cs (9)

125return member.ContainingType.Arity + member.GetMemberArity(); 157if (method.IsExtensionBlockMember() && method.Arity > 0 && method.ContainingType.Arity > 0) 159Debug.Assert(originalTypeParameters.Length == method.Arity + method.ContainingType.Arity); 212if (extension.Arity > 0) 214extension = extension.Construct(typeArguments[..extension.Arity]); 220return (TMember)(Symbol)method.Construct(typeArguments[extension.Arity..]); 233Debug.Assert(extension.Arity > 0); 234Debug.Assert(extension.Arity == typeArguments.Length); 544return ((NamedTypeSymbol)symbol).Arity;

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

88cumulativeArity = namedType.Arity;

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

2062return GetTypeMembers(name).WhereAsArray((type, arity) => type.Arity == arity, arity);

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

167return GetTypeMembers(name).WhereAsArray((type, arity) => type.Arity == arity, arity);

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

120argumentIndex -= typeToCheck.Arity;

Symbols\MethodSymbolExtensions.cs (2)

162&& method.ReturnType is NamedTypeSymbol { Arity: 0 } 172&& method.ReturnType is NamedTypeSymbol { Arity: 1 }

Symbols\NamedTypeSymbol.cs (7)

636Debug.Assert(!(fileIdentifier != null && !MangleName && Arity > 0)); 638? MetadataHelpers.ComposeAritySuffixedMetadataName(Name, Arity, fileIdentifier) 1434if (this.Arity == 0) 1449if (typeArguments.Length != this.Arity) 1980if (type.Arity != 0) 2022int arity = Arity; 2042arity = (typeToCheck as NamedTypeSymbol)?.Arity ?? 0;

Symbols\NamespaceOrTypeSymbol.cs (4)

181return GetTypeMembers(name).WhereAsArray(static (t, arity) => t.Arity == arity, arity); 286if (emittedTypeName.InferredArity == named.Arity && 335(forcedArity == -1 || forcedArity == named.Arity) && 367&& named.Arity == emittedTypeName.InferredArity)

Symbols\PublicModel\NamedTypeSymbol.cs (1)

28return UnderlyingNamedTypeSymbol.Arity;

Symbols\Retargeting\RetargetingSymbolTranslator.cs (8)

323type.Arity == 0) 338MetadataTypeName name = MetadataTypeName.FromFullName(type.ToDisplayString(SymbolDisplayFormat.QualifiedNameOnlyFormat), forcedArity: type.Arity); 459mdName = MetadataTypeName.FromTypeName(type.MetadataName, forcedArity: type.Arity); 468mdName = MetadataTypeName.FromNamespaceAndTypeName(namespaceName, type.MetadataName, forcedArity: type.Arity); 472Debug.Assert(result1.Arity == type.Arity); 499Debug.Assert(originalDefinition.Arity == 0 || !ReferenceEquals(type.ConstructedFrom, type)); 570if (genericType.Arity > 0)

Symbols\Source\ParameterHelpers.cs (3)

535if (extension.ExtensionParameter is not { } extensionParameter || extension.ContainingType?.Arity != 0) 541if (extension.Arity == 0) 554int extensionArity = extension.Arity;

Symbols\Source\SourceAssemblySymbol.cs (7)

1088if (x.Arity == y.Arity && x.Name == y.Name) 1093if (x.Arity != 0 || !x.ContainingNamespace.IsGlobalNamespace || x.Name != "<Module>") 1134result = x.Arity - y.Arity; 2881if ((forcedArity == -1 || result.Arity == forcedArity) && 2882(!emittedName.UseCLSCompliantNameArityEncoding || result.Arity == 0 || result.MangleName))

Symbols\Source\SourceMemberContainerSymbol.cs (3)

1413return GetTypeMembers(name).WhereAsArray((t, arity) => t.Arity == arity, arity); 2437if (!indexer.IsExtensionBlockMember() && indexer.ContainingType.Arity > 0) 2607if (extension.Arity != 0)

Symbols\Source\SourceNamedTypeSymbol.cs (1)

2097if (ContainingType is null || !ContainingType.IsStatic || ContainingType.Arity != 0 || ContainingType.ContainingType is not null)

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

1217if (extension.Arity == 0)

Symbols\Source\SourceNamespaceSymbol.cs (1)

205return GetTypeMembers(name).WhereAsArray((s, arity) => s.Arity == arity, arity);

Symbols\Source\SourceOrdinaryMethodSymbol.cs (1)

234else if (!ContainingType.IsScriptClass && !(ContainingType.IsStatic && ContainingType.Arity == 0))

Symbols\SymbolExtensions.cs (1)

338return ((NamedTypeSymbol)symbol).Arity;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (1)

946=> GetTypeMembers(name).WhereAsArray(static (type, arity) => type.Arity == arity, arity);

Symbols\Tuples\TupleTypeSymbol.cs (9)

133if (Arity < NamedTypeSymbol.ValueTupleRestPosition) 146while (underlyingType.Arity >= NamedTypeSymbol.ValueTupleRestPosition); 210if (currentType.Arity == NamedTypeSymbol.ValueTupleRestPosition) 581var currentFieldsForElements = ArrayBuilder<FieldSymbol?>.GetInstance(currentValueTuple.Arity); 584collectTargetTupleFields(currentValueTuple.Arity, getOriginalFields(currentMembers), currentFieldsForElements); 705if (currentValueTuple.Arity != ValueTupleRestPosition) 714if (currentValueTuple.Arity != ValueTupleRestPosition) 719collectTargetTupleFields(currentValueTuple.Arity, getOriginalFields(currentMembers), currentFieldsForElements); 981if (tuple.Arity == ValueTupleRestPosition)

Symbols\TypeSymbolExtensions.cs (14)

526if (type.Arity == 0) 531if (type.Arity == 1 && 541type.Arity == 0) 1457Arity: 1, 1470Arity: 1, 1915if (namedType is null || namedType.Arity != 0) 1932if (!(type is NamedTypeSymbol { Arity: 1 } namedType)) 1945if (!(type is NamedTypeSymbol { Arity: 1 } namedType)) 1955if (!(type is NamedTypeSymbol { Arity: 1 } namedType)) 1977var arity = type.Arity; 2081int arity = type.Arity; 2220return typeSymbol is NamedTypeSymbol { Name: WellKnownMemberNames.LockTypeName, Arity: 0, ContainingType: null } && 2229Arity: 0, 2264return type is NamedTypeSymbol { Name: "INumberBase", IsInterface: true, Arity: 1, ContainingType: null } &&

Symbols\TypeUnification.cs (2)

177int arity = nt1.Arity; 179if (nt2.Arity != arity || !TypeSymbol.Equals(nt2.OriginalDefinition, nt1.OriginalDefinition, TypeCompareKind.ConsiderEverything))

Symbols\UnboundGenericType.cs (1)

28int n = original.Arity;

Symbols\VarianceSafety.cs (1)

386for (int i = 0; i < namedType.Arity; i++)

Symbols\Wrapped\WrappedNamedTypeSymbol.cs (1)

56return _underlyingType.Arity;