Type

Binder\Binder.CapturedParametersFinder.cs (2)

168if (IsTypeOrValueReceiver(enclosingBinder, id, parameter.Type, out SyntaxNode? memberAccessNode, out string? memberName, out int targetMemberArity, out bool invoked)) 171if (TreatAsInstanceMemberAccess(enclosingBinder, parameter.Type, memberAccessNode, memberName, targetMemberArity, invoked, lookupResult))

Binder\Binder.ValueChecks.cs (11)

368Debug.Assert(parameter.RefKind.IsWritableReference() && parameter.Type.IsRefLikeOrAllowsRefLikeType()); 2369(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2597(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2745parameter.Type.IsRefLikeOrAllowsRefLikeType() && 2964parameter.Type.IsRefLikeOrAllowsRefLikeType(); 3047if (parameter.Type.IsRefLikeOrAllowsRefLikeType() && parameter.RefKind != RefKind.Out && GetParameterValEscapeLevel(parameter) is { } valEscapeLevel) 3107if (parameter.Type.IsRefLikeOrAllowsRefLikeType()) 3778Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4073Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4385Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 5082Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything));

Binder\Binder_Attributes.cs (2)

736parameter.Type.TypeKind == TypeKind.Array && 737!((TypeSymbol)reorderedArgument.TypeInternal!).Equals(parameter.Type, TypeCompareKind.AllIgnoreOptions))

Binder\Binder_Await.cs (2)

374BoundExpression argument = CreateConversion(placeholder, argumentConversion, destination: method.Parameters[0].Type, diagnostics); 474method.Parameters[0].Type,

Binder\Binder_Conversions.cs (17)

657method.Parameters[0].Type is ArrayTypeSymbol { IsSZArray: true, ElementType: TypeParameterSymbol }); 667static (readonlySpanType, method) => method.Parameters[0].Type.IsSpan() && 717arg.source.Equals(parameter.Type.OriginalDefinition, TypeCompareKind.ConsiderEverything) && 723((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(typeArgument.Type, TypeCompareKind.ConsiderEverything) && 746Parameters: [{ Type.SpecialType: SpecialType.System_String }] 1436var collectionBuilderElementsPlaceholder = new BoundCollectionBuilderElementsPlaceholder(syntax, readonlySpanParameter.Type) { WasCompilerGenerated = true }; 1568if (method.Parameters is not [.., { RefKind: RefKind.None, Type: NamedTypeSymbol parameterType }] 1596parameterType = (NamedTypeSymbol)methodWithTargetTypeParameters.Parameters.Last().Type; 1636var parameterType = (NamedTypeSymbol)collectionBuilderMethod.Parameters.Last().Type; 2092bool thisTypeIsOpen = typeParameters.Any((typeParameter, parameter) => parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[0]); 2105if (!typeParameters.Any((typeParameter, parameter) => parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[1])) 2127TypeSymbol secondArgumentType = (constructed ?? member).Parameters[1].Type; 2154var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 2161else if (typeParameters.Any((typeParameter, parameter) => !parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[0])) 3551(Conversions.ConvertExtensionMethodThisArg(GetReceiverParameter(method)!.Type, receiverOpt!.Type, ref useSiteInfo, isMethodGroupConversion: true).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty())); 3575source: delegateParameter.Type, 3576destination: methodParameter.Type,

Binder\Binder_Crefs.cs (2)

705if (ContainsNestedTypeOfUnconstructedGenericType(parameterSymbols[i].Type)) 768if (ContainsNestedTypeOfUnconstructedGenericType(param.Type))

Binder\Binder_Expressions.cs (17)

550defaultValueBinder.GenerateConversionForAssignment(parameter.Type, valueBeforeConversion, diagnostics, ConversionForAssignmentFlags.DefaultParameter)); 2118if (IsBadLocalOrParameterCapture(parameter, parameter.Type, parameter.RefKind)) 2126else if (parameter.Type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2128Error(diagnostics, ErrorCode.ERR_SpecialByRefInLambda, node, parameter.Type); 2132Debug.Assert(parameter.Type.IsRefLikeOrAllowsRefLikeType()); 2142(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) && 2149else if (parameter.Type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2151Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRefAny, node, parameter.Type); 2155Debug.Assert(parameter.Type.IsRefLikeOrAllowsRefLikeType()); 3662if (parameters[paramsIndex].Type.IsSZArray()) 3875placeholderType = receiverParameter.Type; 3896placeholderType = parameter.Type; 3915placeholderType = parameter.Type; 7727leftType = ((ParameterSymbol)leftSymbol).Type; 10689original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10790original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10791original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None };

Binder\Binder_Invocation.cs (8)

690!candidate.Member.GetParameters().Last().Type.IsSZArray()) 1382receiver = CreateConversion(receiver, extensionParameter.Type, diagnostics); 1430var parameterType = parameter.Type; 1667TypeSymbol parameterType = parameter.Type; 1838TypeSymbol collectionType = paramsParameter.Type; 1972!shadowedParameter.Type.Equals(typeOrValue.Type, TypeCompareKind.AllIgnoreOptions)) // If the type and the name match, we would resolve to the same type rather than a value at the end. 2303if (parameter.Name == name) return parameter.Type; 2309return (i < parameterList.Length) ? parameterList[i].Type : null;

Binder\Binder_Operators.cs (7)

476BoundExpression rightConverted = CreateConversion(right, overloadResolutionResult.ValidResult.Result.ConversionForArg(isExtension ? 1 : 0), method.Parameters[0].Type, diagnostics); 506leftConversion = CreateConversion(node, leftPlaceholder, conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, method.ContainingType.ExtensionParameter.Type, diagnostics); 515rightType: method.Parameters[0].Type, 1649TypeSymbol parameterType = userDefinedOperator.Parameters[0].Type; 3612operandConversion = CreateConversion(node, operandPlaceholder, conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, method.ContainingType.ExtensionParameter.Type, diagnostics); 3925if (!((extensionParameter.Type.IsValueType && extensionParameter.RefKind == RefKind.Ref) || 3926(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None)))

Binder\Binder_Patterns.cs (3)

290Conversion conversion = conversions.ClassifyBuiltInConversion(type, candidate.Parameters[0].Type, isChecked: false, ref discardedUseSiteInfo); 325typeSet.Contains(declaredMethod.Parameters[0].Type); 433method.Parameters[0].Type);

Binder\Binder_Statements.cs (2)

2219Error(diagnostics, ErrorFacts.GetStaticClassParameterCode(useWarning: false), anonymousFunction.ParameterLocation(i), delegateParameters[i].Type); 2244var delegateParameterType = delegateParameters[i].Type;

Binder\Binder_Symbols.cs (2)

1499CheckWhatCandidatesWeHave(members, parameter.Type, plainName, 1512Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, receiver.Syntax, parameter.Name, parameter.Type, parameter);

Binder\DecisionDagBuilder.cs (1)

674targetType = deconstructMethod.Parameters[0].Type;

Binder\ExecutableCodeBinder.cs (1)

120else if (parameter.Type.IsPointerOrFunctionPointer() && !isReceiverParameter)

Binder\ForEachLoopBinder.cs (4)

1043builder.CollectionType = builder.GetEnumeratorInfo.Method.Parameters[0].Type; 1047builder.CollectionType = builder.GetEnumeratorInfo.Method.ContainingType.ExtensionParameter.Type; 1562var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1577result.Parameters[0].Type);

Binder\InMethodBinder.cs (1)

211if ((this.Flags & BinderFlags.InEEMethodBinder) != 0 && parameter.Type.IsDisplayClassType())

Binder\RefSafetyAnalysis.cs (1)

1026if (parameter?.Type?.IsRefLikeOrAllowsRefLikeType() != true ||

Binder\Semantics\AccessCheck.cs (1)

175if (!IsSymbolAccessibleCore(param.Type, within, throughTypeOpt: null, out failedThroughTypeCheck, compilation, ref useSiteInfo, basesBeingResolved))

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

363if (thisParameter?.Type.IsReferenceType == false) 370thisParameter.Type); 445if (parameter.Type.IsDynamic()) 486if (!(method.IsExtensionBlockMember() && method.IsStatic) && !Binder.GetReceiverParameter(method).Type.IsReferenceType)

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

1540if (!delegateParameters[p].Type.Equals(anonymousFunction.ParameterType(p), TypeCompareKind.AllIgnoreOptions))

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

1378op1Left = p[0].Type; 1379op1Right = p[1].Type; 1395op2Left = p[0].Type; 1396op2Right = p[1].Type; 1609return SourceUserDefinedOperatorSymbolBase.ExtensionOperatorParameterTypeMatchesExtendedType(method.Parameters[paramIndex].Type, extensionParameter.Type); 1619if (!candidate.Method.ContainingType.ExtensionParameter.Type.IsValidNullableTypeArgument() || 1620!Conversions.ConvertExtensionMethodThisArg(MakeNullable(candidate.Method.ContainingType.ExtensionParameter.Type), operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 1625else if (!Conversions.ConvertExtensionMethodThisArg(candidate.Method.ContainingType.ExtensionParameter.Type, operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists)

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

227if (!candidate.Method.ContainingType.ExtensionParameter.Type.IsValidNullableTypeArgument() || 228!Conversions.ConvertExtensionMethodThisArg(MakeNullable(candidate.Method.ContainingType.ExtensionParameter.Type), operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 233else if (!Conversions.ConvertExtensionMethodThisArg(candidate.Method.ContainingType.ExtensionParameter.Type, operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 297result = Hash.Combine(result, typeComparer.GetHashCode(parameter.Type));

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

1037if (parameter.Type.ContainsTypeParameter(typeParameter)) 2451if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2801if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 3126if (!anonymousFunction.ParameterType(p).Equals(fixedDelegateParameters[p].Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)) 3197Debug.Assert(!extension.ExtensionParameter.Type.IsDynamic());

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

1321if ((final.IsParamsArray && final.Type.IsSZArray()) || 1322(final.IsParamsCollection && !final.Type.IsSZArray() && !disallowExpandedNonArrayParams && 1325return TryInferParamsCollectionIterationType(binder, final.OriginalDefinition.Type, out definitionElementType); 2560TypeSymbol t1 = m1LastParameter.Type; 2561TypeSymbol t2 = m2LastParameter.Type; 2584var type = parameter.Type; 3801if (!Conversions.HasIdentityConversion(param1.Type, param2.Type))

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

1253TypeSymbol parameterType = unwrapIfParamsCollection(badArg, parameter, isLastParameter) is TypeSymbol t ? t : parameter.Type; 1411parameter.Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true };

BoundTree\BoundDagEvaluation.cs (2)

328builder.Add(new BoundDagTemp(Syntax, parameter.Type, this, i)); 340return new BoundDagTemp(Syntax, parameter.Type, this, 0);

BoundTree\Constructors.cs (2)

472: this(syntax, parameterSymbol, parameterSymbol.Type, hasErrors) 477: this(syntax, parameterSymbol, parameterSymbol.Type)

CodeGen\CodeGenerator_RefSafety.cs (1)

97if (parameter.Type.IsRefLikeOrAllowsRefLikeType() && parameter.EffectiveScope != ScopedKind.ScopedValue)

CodeGen\EmitConversion.cs (2)

416if (parameters[0].Type.SpecialType != SpecialType.System_Object) continue; 417var p1t = parameters[1].Type.SpecialType;

CodeGen\EmitExpression.cs (2)

1437var parameterType = parameter.ParameterSymbol.Type; 3345EmitIndirectStore(parameter.ParameterSymbol.Type, parameter.Syntax);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

287retExpression = F.StaticCall(manager.System_String, formatMethod, F.Null(formatMethod.Parameters[0].Type), format, F.ArrayOrEmpty(manager.System_Object, arguments));

Compiler\ClsComplianceChecker.cs (2)

578if (!IsCompliantType(parameter.Type, context)) 580this.AddDiagnostic(ErrorCode.WRN_CLS_BadArgType, parameter.GetFirstLocation(), parameter.Type);

Compiler\MethodBodySynthesizer.cs (3)

186thisReference = new BoundThisReference(syntax, thisSymbol.Type) { WasCompilerGenerated = true }; 282field.IsStatic || field.ContainingSymbol is NamedTypeSymbol { IsExtension: true } ? null : new BoundThisReference(syntax, accessor.ThisParameter.Type), 380new BoundThisReference(syntax, thisParameter.Type) { WasCompilerGenerated = true };

Compiler\MethodBodySynthesizer.Lowered.cs (1)

87F.Null(text.Type)),

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

245Visit(symbol.Type, builder);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (4)

424var otherType = (TypeSymbol?)Visit(param.Type); 672_comparer.Equals(parameter.Type, other.Type); 940var translatedParamType = (TypeSymbol)Visit(param.Type);

Emitter\Model\ParameterSymbolAdapter.cs (2)

55return ((PEModuleBuilder)context.Module).Translate(AdaptedParameterSymbol.Type, 95type = AdaptedParameterSymbol.Type;

Emitter\Model\ParameterTypeInformation.cs (1)

53return ((PEModuleBuilder)context.Module).Translate(_underlyingParameter.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);

Emitter\NoPia\EmbeddedTypesManager.cs (1)

189ImmutableArray.Create(new TypedConstant(ctor.Parameters[0].Type, TypedConstantKind.Type, ctor.ContainingAssembly.GetSpecialType(SpecialType.System_Object))),

FlowAnalysis\AbstractFlowPass.cs (2)

1441&& !TypeIsImmutable(thisParameter.Type)) 3048return param.Type.IsNonNullableValueType();

FlowAnalysis\DefiniteAssignment.cs (2)

365if (methodThisParameter.Type.SpecialType.CanOptimizeBehavior()) 434TypeSymbol parameterType = parameter.Type;

FlowAnalysis\NullableWalker.cs (4)

3858(p1, p2) => p1.Type.Equals(p2.Type, TypeCompareKind.AllNullableIgnoreOptions | TypeCompareKind.IgnoreTupleNames)) && 12074parameterOpt?.Type.IsNonNullableValueType() == true && parameterType.IsNullableType() ? parameterOpt.Type : parameterType, // Compensate for operator lifting

Lowering\AsyncRewriter\AsyncRewriter.AsyncIteratorRewriter.cs (1)

216parameter.Type.Equals(F.Compilation.GetWellKnownType(WellKnownType.System_Threading_CancellationToken), TypeCompareKind.ConsiderEverything))

Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (2)

70if (thisParameter is { Type.IsValueType: true, RefKind: not RefKind.None }) 415Debug.Assert(thisParameter is not { Type.IsValueType: true, RefKind: RefKind.Ref });

Lowering\ClosureConversion\ClosureConversion.Analysis.Tree.cs (1)

689type = ((ParameterSymbol)capturedVariable).Type;

Lowering\ClosureConversion\ClosureConversion.cs (4)

247Debug.Assert(thisParameter is null || TypeSymbol.Equals(thisParameter.Type, thisType, TypeCompareKind.ConsiderEverything2)); 612if ((object)_currentFrameThis != null && TypeSymbol.Equals(_currentFrameThis.Type, frameClass, TypeCompareKind.ConsiderEverything2)) 625if (TypeSymbol.Equals(potentialParameter.Type.OriginalDefinition, frameClass, TypeCompareKind.ConsiderEverything2)) 912var frameType = (NamedTypeSymbol)loweredSymbol.Parameters[i].Type.OriginalDefinition;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (6)

712var conversionInputType = method.Parameters[0].Type; 719? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 787unquoted = _bound.Call(_bound.MethodInfo(method, createDelegate.ContainingType), createDelegate, _bound.Typeof(delegateType, createDelegate.Parameters[0].Type), receiver); 794_bound.Typeof(delegateType, createDelegate.Parameters[0].Type), 796_bound.MethodInfo(method, createDelegate.Parameters[2].Type)); 867_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name));

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

627_diagnostics.Add(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, p.GetFirstLocation(), p.Type.Name);

Lowering\DiagnosticsPass_Warnings.cs (2)

369if (parameters.Length == 2 && TypeSymbol.Equals(parameters[0].Type, t, TypeCompareKind.ConsiderEverything2) && TypeSymbol.Equals(parameters[1].Type, t, TypeCompareKind.ConsiderEverything2))

Lowering\ExtensionMethodReferenceRewriter.cs (1)

123Debug.Assert(receiverOpt.Type!.Equals(method.Parameters[0].Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (10)

314var parameterLogger = GetLocalOrParameterStoreLogger(parameter.Type, parameter, refAssignmentSourceIsLocal: null, _factory.Syntax); 322MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)ordinal))))); 430type = parameterSymbol.Type; 457if (parameter.Type.IsVoidPointer() && !targetType.IsPointerOrFunctionPointer()) 460Debug.Assert(!parameter.Type.IsManagedTypeNoUseSiteDiagnostics); 463(BoundExpression)new BoundAddressOfOperator(_factory.Syntax, value, isManaged: false, parameter.Type) : 464_factory.Sequence(new[] { value }, new BoundAddressOfOperator(_factory.Syntax, VariableRead(targetSymbol), isManaged: false, parameter.Type)); 469if (parameter.Type.SpecialType == SpecialType.System_String && targetType.SpecialType != SpecialType.System_String) 489Conversion c = _factory.ClassifyEmitConversion(value, parameter.Type); 491return ImmutableArray.Create(_factory.Convert(parameter.Type, value, c), index);

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (1)

186member is MethodSymbol { Parameters: [.., { RefKind: RefKind.None, Type: { } lastParamType }] parametersWithCancellationToken } overload &&

Lowering\LocalRewriter\LocalRewriter.cs (2)

1171Debug.Assert(Conversions.IsValidExtensionMethodThisArgConversion(this._compilation.Conversions.ClassifyConversionFromType(receiver.Type, extensionParameter.Type, isChecked: false, ref discardedUseSiteInfo))); 1175return MakeConversionNode(receiver, extensionParameter.Type, @checked: false, acceptFailingConversion: false, markAsChecked: markAsChecked);

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

262Debug.Assert(e.Property.GetMethod.Parameters[0].Type.SpecialType == SpecialType.System_Int32);

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (1)

770var parameterType = leftTruthOperator.Parameters[0].Type;

Lowering\LocalRewriter\LocalRewriter_Call.cs (9)

253case (not null, not null) when !methodThisParameter.Type.Equals(interceptorThisParameterForCompare.Type, TypeCompareKind.ObliviousNullableModifierMatchesAny) 296Debug.Assert(receiverOpt.Type.Equals(interceptor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions) 297|| (!receiverOpt.Type.IsReferenceType && interceptor.Parameters[0].Type.IsReferenceType)); 298receiverOpt = MakeConversionNode(receiverOpt, interceptor.Parameters[0].Type, @checked: false, markAsChecked: true); 1227var effectiveArgRefKind = GetEffectiveRefKind(paramRefKind, currentArgRefKind, parameters[i].Type, comRefKindMismatchPossible: false); 1331return ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol; 1337return methodOrIndexer.ContainingType.ExtensionParameter.Type as NamedTypeSymbol; 1457refKinds[p] = GetEffectiveRefKind(paramRefKind, argRefKind, parameters[p].Type, comRefKindMismatchPossible: true);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (6)

187if (!ShouldUseIEnumerableBulkAddMethod(singleSpread.Expression.Type, toListOfElementType.Parameters[0].Type, singleSpread.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 235ConversionsBase.HasIdentityConversion(parameter.Type, spreadType) && 376assertTypesAreCompatible(_compilation, arrayType, spanConstructor.Parameters[0].Type, isReadOnlySpan); 592var spanType = (NamedTypeSymbol)readonlySpanParameter.Type; 787&& ShouldUseIEnumerableBulkAddMethod(spreadExpression.Type!, linqToArrayMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 1350if (!ShouldUseIEnumerableBulkAddMethod(rewrittenSpreadOperand.Type, addRangeMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

258return symbol.IsExtensionBlockMember() && !symbol.IsStatic && symbol.ContainingType.ExtensionParameter is { RefKind: RefKind.None, Type.IsReferenceType: false };

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (4)

719Debug.Assert(method.Parameters[0].Type.IsStringType()); 1563Debug.Assert(conversion.Method.Parameters[0].Type.Equals(rewrittenOperand.Type, TypeCompareKind.AllIgnoreOptions)); 1879Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1992Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked);

Lowering\LocalRewriter\LocalRewriter_Event.cs (3)

310TypeSymbol parameters0Type = addRemove.Parameters[0].Type; 316TypeSymbol parameters1Type = addRemove.Parameters[1].Type; 322BoundExpression eventInfo = _factory.New(ctor, _factory.Typeof(node.Event.ContainingType, ctor.Parameters[0].Type), _factory.Literal(node.Event.MetadataName));

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (1)

283MethodSymbol createSpan = getCreateSpanHelper(node, spanType: getItemOrSliceHelper.ContainingType, intType: (NamedTypeSymbol)getItemOrSliceHelper.Parameters[0].Type);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

701(memberSymbol.IsExtensionBlockMember() && !memberSymbol.IsStatic && ConversionsBase.IsValidExtensionMethodThisArgConversion(_compilation.Conversions.ClassifyConversionFromType(rewrittenReceiver.Type, memberSymbol.ContainingType.ExtensionParameter!.Type, isChecked: false, ref discardedUseSiteInfo))) ||

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (2)

149!parameter.Type.IsRestrictedType(), 230var type = (variable.Kind == SymbolKind.Local) ? ((LocalSymbol)variable).Type : ((ParameterSymbol)variable).Type;

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

147thisParameter.Type.IsReferenceType &&

Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)

259var proxyField = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, parameter, isPublic: !PreserveInitialParameterValuesAndThreadId); 264var field = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), parameter, isPublic: true); 448if (method.IsStatic || method.ThisParameter.Type.IsReferenceType)

Lowering\SyntheticBoundNodeFactory.cs (3)

230return new BoundThisReference(Syntax, CurrentFunction.ThisParameter.Type) { WasCompilerGenerated = true }; 251return new BoundParameter(Syntax, p, p.Type) { WasCompilerGenerated = true }; 1226NamedTypeSymbol baseType = CurrentFunction.ThisParameter.Type.BaseTypeNoUseSiteDiagnostics;

Symbols\Attributes\SourceAttributeData.cs (1)

282TypeSymbol parameterType = parameters[parameterIndex].Type;

Symbols\Compilation_WellKnownMembers.cs (1)

1185return parameter.Type;

Symbols\MemberSymbolExtensions.cs (2)

365extensionParameter.Type.ContainsPointerOrFunctionPointer()) 862return method.ReturnType.ContainsTupleNames() || method.Parameters.Any(static p => p.Type.ContainsTupleNames());

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

208TypeSymbol.Equals(_removeMethod.Parameters[0].Type, token, TypeCompareKind.ConsiderEverything2);

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

714&& ContainingAssembly.TypeConversions.HasCallerLineNumberConversion(this.Type, ref discardedUseSiteInfo); 734&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 755&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 778&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 882else if (paramNames.IsDefault || Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true })

Symbols\NamedTypeSymbol.cs (4)

386if (!thisParam.Type.IsValidExtensionParameterType()) 392if (thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) 398&& !thisParam.Type.IsValidInOrRefReadonlyExtensionParameterType()) 1900var candidate = factory.Parameters[0].Type;

Symbols\OverriddenOrHiddenMembersHelpers.cs (1)

670Debug.Assert(!param.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: false));

Symbols\ParameterSymbol.cs (1)

474ITypeSymbolInternal IParameterSymbolInternal.Type => Type;

Symbols\ReducedExtensionMethodSymbol.cs (2)

53var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 251return _reducedFrom.Parameters[0].Type;

Symbols\Source\CustomModifierUtils.cs (3)

132sourceParameter.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: true) || 134destinationParameter.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: true) || // Could happen if the associated property has custom modifiers. 144builder.Add(destinationParameter.WithCustomModifiersAndParams(sourceParameter.Type,

Symbols\Source\ParameterHelpers.cs (3)

558extensionParameter.Type.FindTypeParameters(usedTypeParameters); 567parameter.Type.FindTypeParameters(usedTypeParameters); 946TypeSymbol parameterType = parameter.Type;

Symbols\Source\SourceComplexParameterSymbol.cs (19)

356new BoundLiteral(parameterSyntax, defaultValue, Type)); 410if (Type.IsNullableType()) 412convertedExpression = binder.GenerateConversionForAssignment(Type.GetNullableUnderlyingType(), 905return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 1015if (this.Type.IsReferenceType) 1039else if (!compilation.Conversions.ClassifyConversionFromType((TypeSymbol)arg.TypeInternal, this.Type, isChecked: false, ref useSiteInfo).Kind.IsImplicitConversion()) 1264if (!Type.Equals(this.DeclaringCompilation.GetWellKnownType(WellKnownType.System_Threading_CancellationToken))) 1287if (Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true } handlerType) 1290diagnostics.Add(ErrorCode.ERR_TypeIsNotAnInterpolatedStringHandlerType, arguments.AttributeSyntaxOpt.Location, Type); 1566public sealed override bool IsParamsArray => (_parameterSyntaxKind & ParameterFlags.ParamsParameter) != 0 && this.Type.IsSZArray(); 1568public sealed override bool IsParamsCollection => (_parameterSyntaxKind & ParameterFlags.ParamsParameter) != 0 && !this.Type.IsSZArray(); 1596if (DeclaredScope == ScopedKind.ScopedValue && !Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 1613var collectionTypeKind = ConversionsBase.GetCollectionExpressionTypeKind(DeclaringCompilation, Type, out TypeWithAnnotations elementTypeWithAnnotations); 1629binder.TryGetCollectionIterationType(syntax, Type, out elementTypeWithAnnotations); 1638withElement: null, syntax, Type, out MethodSymbol? constructor, isExpanded: out _, diagnostics, isParamsModifierValidation: true)) 1648if (!binder.HasCollectionExpressionApplicableAddMethod(syntax, Type, out ImmutableArray<MethodSymbol> addMethods, diagnostics)) 1657diagnostics.Add(ErrorCode.ERR_ParamsCollectionExtensionAddMethod, syntax, Type); 1690binder.TryGetCollectionIterationType(syntax, Type, out elementTypeWithAnnotations); 1699syntax, (NamedTypeSymbol)Type, diagnostics, forParams: true);

Symbols\Source\SourceConstructorSymbolBase.cs (1)

99parameter.Type.CheckAllConstraints(compilation, conversions, parameter.GetFirstLocation(), diagnostics);

Symbols\Source\SourceDelegateMethodSymbol.cs (3)

120diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, delegateType.GetFirstLocation(), delegateType, parameterSymbol.Type); 122else if (!delegateTypeIsFile && parameterSymbol.Type.HasFileLocalTypes()) 124diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, delegateType.GetFirstLocation(), parameterSymbol.Type, delegateType);

Symbols\Source\SourceMemberContainerSymbol.cs (4)

1518if (this.ExtensionParameter is { Type: NamedTypeSymbol { Name: var extendedTypeName } }) 4645if (!propertyParamType.Equals(methodParam.Type, TypeCompareKind.AllIgnoreOptions)) 4663eventSymbol.Type.Equals(methodParams[0].Type, TypeCompareKind.AllIgnoreOptions); 5088primaryAndCopyCtorAmbiguity = ctor.ParameterCount == 1 && ctor.Parameters[0].Type.Equals(this, TypeCompareKind.AllIgnoreOptions);

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (4)

1428p.Type.IsRefLikeOrAllowsRefLikeType())) 1438if ((overrideThisParameter is { RefKind: RefKind.Ref or RefKind.Out } && overrideThisParameter.Type.IsRefLikeOrAllowsRefLikeType()) || 1444else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeOrAllowsRefLikeType())) 1460else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeOrAllowsRefLikeType()))

Symbols\Source\SourceMemberMethodSymbol.cs (4)

377diagnostics.Add(code, GetFirstLocation(), this, parameter.Type); 386diagnostics.Add(code, GetFirstLocation(), this, extensionParameter.Type); 414if (param.Type.HasFileLocalTypes()) 416diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, GetFirstLocation(), param.Type, containingType);

Symbols\Source\SourceMethodSymbol.cs (3)

73else if (parameter.Type.IsPointerOrFunctionPointer() && !isExtensionParameter) 78else if (parameter.Type.IsRestrictedType()) 80diagnostics.Add(ErrorCode.ERR_BadSpecialByRefParameter, getLocation(parameter, location, isExtensionParameter), parameter.Type);

Symbols\Source\SourceMethodSymbolWithAttributes.cs (3)

1019Debug.Assert(arguments.Attribute.AttributeConstructor.Parameters is [{ Type.SpecialType: SpecialType.System_Int32 }, { Type.SpecialType: SpecialType.System_String }]); 1414checkAndReportManagedTypes(param.Type, param.RefKind, param.GetNonNullSyntaxNode(), isParam: true, diagnostics);

Symbols\Source\SourceNamedTypeSymbol.cs (2)

1992if (indexer.Parameters is [{ Type: { } type }] && 2023conversion.Parameters[0].Type.Equals(this, TypeCompareKind.AllIgnoreOptions) &&

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

1207Conversion conversion = conversions.ConvertExtensionMethodThisArg(parameterType: result.ContainingType.ExtensionParameter.Type, receiverType, ref discardedUseSiteInfo, isMethodGroupConversion: false);

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (1)

241parameter.Type.CheckAllConstraints(compilation, conversions, parameter.GetFirstLocation(), diagnostics);

Symbols\Source\SourceParameterSymbol.cs (2)

125newType = CustomModifierUtils.CopyTypeCustomModifiers(newType, this.Type, this.ContainingAssembly); 245else if (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType())

Symbols\Source\SourcePropertySymbol.cs (6)

680if (!IsExplicitInterfaceImplementation && !this.IsNoMoreVisibleThan(param.Type, ref useSiteInfo)) 682diagnostics.Add(ErrorCode.ERR_BadVisIndexerParam, Location, this, param.Type); 684else if (param.Type.HasFileLocalTypes() && !containingTypeForFileTypeCheck.HasFileLocalTypes()) 686diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Location, param.Type, containingTypeForFileTypeCheck); 708!this.IsNoMoreVisibleThan(extensionParameter.Type, ref useSiteInfo)) 710diagnostics.Add(ErrorCode.ERR_BadVisIndexerParam, Location, this, extensionParameter.Type);

Symbols\Source\SourcePropertySymbolBase.cs (1)

1840parameter.Type.CheckAllConstraints(DeclaringCompilation, conversions, parameter.GetFirstLocation(), diagnostics);

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (5)

81if (this.ContainingType is { IsExtension: true, ExtensionParameter.Type.IsStatic: true }) 385if (ContainingType is { IsExtension: true, ExtensionParameter: { Type.IsStatic: false } extensionParameter } && !IsStatic && 408if (extensionParameter.Type.IsStructType()) 416switch (extensionParameter.Type) 895if (ContainingType is { IsExtension: true, ExtensionParameter.Type: var extendedType })

Symbols\SubstitutedMethodSymbol.cs (1)

170return reduced.Parameters[0].Type;

Symbols\SymbolDistinguisher.cs (1)

145symbol = ((ParameterSymbol)symbol).Type;

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

59if (parameter.Type.IsErrorType())

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

125ctor.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))

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

147method.Parameters[0].Type.Equals(containingType, TypeCompareKind.AllIgnoreOptions) &&

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

73if (!parameter.Type.Equals(type, TypeCompareKind.AllIgnoreOptions))

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

47candidate.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))

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

123TypeSymbol baseType = baseEquals.Parameters[0].Type;

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (2)

362var arguments = Parameters.SelectAsArray((p, s) => (BoundExpression)new BoundParameter(s, p, p.Type), _userMainReturnTypeSyntax); 388&& handleAsyncEntryPointMethod.Parameters[0].Type.Equals(userMain.ReturnType, TypeCompareKind.AllIgnoreOptions))

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (1)

59!parameter.Type.Equals(exceptionConstructor.ContainingType))

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedParameterSymbol.cs (2)

390public override bool IsParamsArray => _isParams && Type.IsSZArray(); 392public override bool IsParamsCollection => _isParams && !Type.IsSZArray();

Symbols\Synthesized\SynthesizedThrowSwitchExpressionExceptionMethod.cs (1)

33Debug.Assert(unmatchedValue.Type.SpecialType == SpecialType.System_Object);

Symbols\Synthesized\SynthesizedUnionCtor.cs (1)

84this.Parameters[0].Type.CheckAllConstraints(DeclaringCompilation, conversions, GetFirstLocation(), diagnostics);

Symbols\VarianceSafety.cs (1)

244param.Type,