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

146Debug.Assert(parameter.RefKind.IsWritableReference() && parameter.Type.IsRefLikeOrAllowsRefLikeType()); 2457parameter.Type.IsRefLikeOrAllowsRefLikeType() && 3487Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 3813Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4157Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4661Debug.Assert(parameter.Type.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions)); 4666if (LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, ((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type)) 4863Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything));

Binder\Binder_Attributes.cs (2)

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

Binder\Binder_Conversions.cs (13)

580method.Parameters[0].Type is ArrayTypeSymbol { IsSZArray: true, ElementType: TypeParameterSymbol }); 590static (readonlySpanType, method) => method.Parameters[0].Type.IsSpan() && 640arg.source.Equals(parameter.Type.OriginalDefinition, TypeCompareKind.ConsiderEverything) && 646((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(typeArgument.Type, TypeCompareKind.ConsiderEverything) && 669Parameters: [{ Type.SpecialType: SpecialType.System_String }] 1061var parameterType = (NamedTypeSymbol)collectionBuilderMethod.Parameters[0].Type; 1515TypeSymbol secondArgumentType = (constructed ?? member).Parameters[1].Type; 1542var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 1893if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 1911var spanTypeArg = ((NamedTypeSymbol)methodWithTargetTypeParameters.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2853(Conversions.ConvertExtensionMethodThisArg(GetReceiverParameter(method)!.Type, receiverOpt!.Type, ref useSiteInfo, isMethodGroupConversion: true).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty())); 2877source: delegateParameter.Type, 2878destination: methodParameter.Type,

Binder\Binder_Crefs.cs (2)

665if (ContainsNestedTypeOfUnconstructedGenericType(parameterSymbols[i].Type)) 728if (ContainsNestedTypeOfUnconstructedGenericType(param.Type))

Binder\Binder_Expressions.cs (15)

518defaultValueBinder.GenerateConversionForAssignment(parameter.Type, valueBeforeConversion, diagnostics, ConversionForAssignmentFlags.DefaultParameter)); 2140if (IsBadLocalOrParameterCapture(parameter, parameter.Type, parameter.RefKind)) 2148else if (parameter.Type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2150Error(diagnostics, ErrorCode.ERR_SpecialByRefInLambda, node, parameter.Type); 2154Debug.Assert(parameter.Type.IsRefLikeOrAllowsRefLikeType()); 2164(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) && 2171else if (parameter.Type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2173Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRefAny, node, parameter.Type); 2177Debug.Assert(parameter.Type.IsRefLikeOrAllowsRefLikeType()); 3586if (parameters[paramsIndex].Type.IsSZArray()) 3809placeholderType = parameter.Type; 3828placeholderType = parameter.Type; 10424original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10524original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10525original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None };

Binder\Binder_Invocation.cs (9)

683!candidate.Member.GetParameters().Last().Type.IsSZArray()) 1262receiverParameter.Type, diagnostics); 1375receiver = CreateConversion(receiver, extensionParameter.Type, diagnostics); 1423var parameterType = parameter.Type; 1657TypeSymbol parameterType = parameter.Type; 1776TypeSymbol collectionType = paramsParameter.Type; 1905!(d.Arguments is [ParameterSymbol shadowedParameter] && shadowedParameter.Type.Equals(typeOrValue.Data.ValueExpression.Type, TypeCompareKind.AllIgnoreOptions))) // If the type and the name match, we would resolve to the same type rather than a value at the end. 2230if (parameter.Name == name) return parameter.Type; 2236return (i < parameterList.Length) ? parameterList[i].Type : null;

Binder\Binder_Operators.cs (8)

461BoundExpression rightConverted = CreateConversion(right, overloadResolutionResult.ValidResult.Result.ConversionForArg(isExtension ? 1 : 0), method.Parameters[0].Type, diagnostics); 490leftConversion = CreateConversion(node, leftPlaceholder, conversion, isCast: false, conversionGroupOpt: null, method.ContainingType.ExtensionParameter.Type, diagnostics); 499rightType: method.Parameters[0].Type, 1444var trueFalseParameterType = (resultKind.Operator() == BinaryOperatorKind.And ? falseOperator : trueOperator).Parameters[0].Type; 1561TypeSymbol parameterType = userDefinedOperator.Parameters[0].Type; 3366operandConversion = CreateConversion(node, operandPlaceholder, conversion, isCast: false, conversionGroupOpt: null, method.ContainingType.ExtensionParameter.Type, diagnostics); 3648!((extensionParameter.Type.IsValueType && extensionParameter.RefKind == RefKind.Ref) || 3649(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None)))

Binder\Binder_Statements.cs (2)

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

Binder\Binder_Symbols.cs (2)

1455CheckWhatCandidatesWeHave(members, parameter.Type, plainName, 1467Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, colorColorValueReceiver.Syntax, parameter.Name, parameter.Type, parameter);

Binder\DecisionDagBuilder.cs (1)

541var element = new BoundDagTemp(syntax, method.Parameters[i + extensionExtra].Type, evaluation, i);

Binder\ExecutableCodeBinder.cs (1)

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

Binder\ForEachLoopBinder.cs (4)

1044builder.CollectionType = builder.GetEnumeratorInfo.Method.Parameters[0].Type; 1048builder.CollectionType = builder.GetEnumeratorInfo.Method.ContainingType.ExtensionParameter.Type; 1569var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1582result.Parameters[0].Type);

Binder\InMethodBinder.cs (1)

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

Binder\PatternExplainer.cs (1)

547var elementTemp = new BoundDagTemp(e.Syntax, method.Parameters[j + extensionExtra].Type, e, j);

Binder\Semantics\AccessCheck.cs (1)

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

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

350if (thisParameter?.Type.IsReferenceType == false) 357thisParameter.Type); 432if (parameter.Type.IsDynamic()) 473if (!(method.GetIsNewExtensionMember() && method.IsStatic) && !Binder.GetReceiverParameter(method).Type.IsReferenceType)

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

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

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

1370op1Left = p[0].Type; 1371op1Right = p[1].Type; 1387op2Left = p[0].Type; 1388op2Right = p[1].Type; 1607return SourceUserDefinedOperatorSymbolBase.ExtensionOperatorParameterTypeMatchesExtendedType(method.Parameters[paramIndex].Type, extensionParameter.Type); 1617if (!candidate.Method.ContainingType.ExtensionParameter.Type.IsValidNullableTypeArgument() || 1618!Conversions.ConvertExtensionMethodThisArg(MakeNullable(candidate.Method.ContainingType.ExtensionParameter.Type), operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 1623else if (!Conversions.ConvertExtensionMethodThisArg(candidate.Method.ContainingType.ExtensionParameter.Type, operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists)

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

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

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

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

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

1313if ((final.IsParamsArray && final.Type.IsSZArray()) || 1314(final.IsParamsCollection && !final.Type.IsSZArray() && !disallowExpandedNonArrayParams && 1317return TryInferParamsCollectionIterationType(binder, final.OriginalDefinition.Type, out definitionElementType); 2573TypeSymbol t1 = m1LeastOverriddenParameters[^1].Type; 2574TypeSymbol t2 = m2LeastOverriddenParameters[^1].Type; 2597var type = parameter.Type; 3782if (!Conversions.HasIdentityConversion(param1.Type, param2.Type))

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

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

BoundTree\Constructors.cs (2)

460: this(syntax, parameterSymbol, parameterSymbol.Type, hasErrors) 465: this(syntax, parameterSymbol, parameterSymbol.Type)

CodeGen\EmitConversion.cs (2)

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

CodeGen\EmitExpression.cs (2)

1426var parameterType = parameter.ParameterSymbol.Type; 3301EmitIndirectStore(parameter.ParameterSymbol.Type, parameter.Syntax);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

283retExpression = 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)

184thisReference = new BoundThisReference(syntax, thisSymbol.Type) { WasCompilerGenerated = true }; 280field.IsStatic ? null : new BoundThisReference(syntax, accessor.ThisParameter.Type), 378new 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)

416var otherType = (TypeSymbol?)Visit(param.Type); 665_comparer.Equals(parameter.Type, other.Type); 933var 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)

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

FlowAnalysis\AbstractFlowPass.cs (2)

1439&& !TypeIsImmutable(thisParameter.Type)) 3046return param.Type.IsNonNullableValueType();

FlowAnalysis\DefiniteAssignment.cs (2)

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

FlowAnalysis\NullableWalker.cs (4)

3772(p1, p2) => p1.Type.Equals(p2.Type, TypeCompareKind.AllNullableIgnoreOptions | TypeCompareKind.IgnoreTupleNames)) && 11291parameterOpt?.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\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)); 602if ((object)_currentFrameThis != null && TypeSymbol.Equals(_currentFrameThis.Type, frameClass, TypeCompareKind.ConsiderEverything2)) 615if (TypeSymbol.Equals(potentialParameter.Type.OriginalDefinition, frameClass, TypeCompareKind.ConsiderEverything2)) 902var frameType = (NamedTypeSymbol)loweredSymbol.Parameters[i].Type.OriginalDefinition;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (6)

702var conversionInputType = method.Parameters[0].Type; 709? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 767unquoted = _bound.Call(_bound.MethodInfo(method, createDelegate.ContainingType), createDelegate, _bound.Typeof(delegateType, createDelegate.Parameters[0].Type), receiver); 774_bound.Typeof(delegateType, createDelegate.Parameters[0].Type), 776_bound.MethodInfo(method, createDelegate.Parameters[2].Type)); 847_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name));

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

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

Lowering\DiagnosticsPass_Warnings.cs (2)

370if (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 (9)

312var parameterLogger = GetLocalOrParameterStoreLogger(parameter.Type, parameter, refAssignmentSourceIsLocal: null, _factory.Syntax); 316MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)parameter.Ordinal))))); 424type = parameterSymbol.Type; 450if (parameter.Type.IsVoidPointer() && !targetType.IsPointerOrFunctionPointer()) 453Debug.Assert(!parameter.Type.IsManagedTypeNoUseSiteDiagnostics); 456(BoundExpression)new BoundAddressOfOperator(_factory.Syntax, value, isManaged: false, parameter.Type) : 457_factory.Sequence(new[] { value }, new BoundAddressOfOperator(_factory.Syntax, VariableRead(targetSymbol), isManaged: false, parameter.Type)); 462if (parameter.Type.SpecialType == SpecialType.System_String && targetType.SpecialType != SpecialType.System_String) 482return ImmutableArray.Create(_factory.Convert(parameter.Type, value), index);

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (1)

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

Lowering\LocalRewriter\LocalRewriter.cs (2)

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

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

191var outputTemp = new BoundDagTemp(d.Syntax, parameter.Type, d, i - extensionExtra); 247Debug.Assert(e.Property.GetMethod.Parameters[0].Type.SpecialType == SpecialType.System_Int32);

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_Call.cs (8)

252case (not null, not null) when !methodThisParameter.Type.Equals(interceptorThisParameterForCompare.Type, TypeCompareKind.ObliviousNullableModifierMatchesAny) 295Debug.Assert(receiverOpt.Type.Equals(interceptor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions) 296|| (!receiverOpt.Type.IsReferenceType && interceptor.Parameters[0].Type.IsReferenceType)); 297receiverOpt = MakeConversionNode(receiverOpt, interceptor.Parameters[0].Type, @checked: false, markAsChecked: true); 1190Debug.Assert(parameters[i].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }); 1261return ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol; 1267return methodOrIndexer.ContainingType.ExtensionParameter.Type as NamedTypeSymbol;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (5)

177if (!ShouldUseIEnumerableBulkAddMethod(singleSpread.Expression.Type, toListOfElementType.Parameters[0].Type, singleSpread.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 225ConversionsBase.HasIdentityConversion(builder.Parameters[0].Type, spreadType) && 327Debug.Assert(TypeSymbol.Equals(array.Type, spanConstructor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions)); 479var spanType = (NamedTypeSymbol)constructMethod.Parameters[0].Type; 680&& ShouldUseIEnumerableBulkAddMethod(spreadExpression.Type!, linqToArrayMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (2)

1764Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1870Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked);

Lowering\LocalRewriter\LocalRewriter_Event.cs (3)

310BoundExpression eventInfo = _factory.New(ctor, _factory.Typeof(node.Event.ContainingType, ctor.Parameters[0].Type), _factory.Literal(node.Event.MetadataName)); 312_factory.Convert(addRemove.Parameters[0].Type, rewrittenReceiver), 313_factory.Convert(addRemove.Parameters[1].Type, rewrittenArgument));

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

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

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (2)

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

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

145thisParameter.Type.IsReferenceType &&

Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)

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

Lowering\SyntheticBoundNodeFactory.cs (5)

225return new BoundThisReference(Syntax, CurrentFunction.ThisParameter.Type) { WasCompilerGenerated = true }; 246return new BoundParameter(Syntax, p, p.Type) { WasCompilerGenerated = true }; 1205NamedTypeSymbol baseType = CurrentFunction.ThisParameter.Type.BaseTypeNoUseSiteDiagnostics; 1514if (conversion.Method is { } && !TypeSymbol.Equals(conversion.Method.Parameters[0].Type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1516arg = Convert(conversion.Method.Parameters[0].Type, arg);

Symbols\Attributes\SourceAttributeData.cs (1)

282TypeSymbol parameterType = parameters[parameterIndex].Type;

Symbols\Compilation_WellKnownMembers.cs (1)

1143return parameter.Type;

Symbols\MemberSymbolExtensions.cs (1)

850return method.ReturnType.ContainsTupleNames() || method.Parameters.Any(static p => p.Type.ContainsTupleNames());

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

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

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

693&& ContainingAssembly.TypeConversions.HasCallerLineNumberConversion(this.Type, ref discardedUseSiteInfo); 713&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 734&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 757&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 867else if (paramNames.IsDefault || Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true })

Symbols\NamedTypeSymbol.cs (2)

363if ((thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) || 364(thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter && thisParam.Type.TypeKind != TypeKind.Struct))

Symbols\OverriddenOrHiddenMembersHelpers.cs (1)

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

Symbols\ParameterSymbol.cs (1)

456ITypeSymbolInternal IParameterSymbolInternal.Type => Type;

Symbols\ReducedExtensionMethodSymbol.cs (2)

52var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 250return _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)

550extensionParameter.Type.VisitType(collectTypeParameters, arg: usedTypeParameters); 559parameter.Type.VisitType(collectTypeParameters, arg: usedTypeParameters); 930TypeSymbol parameterType = parameter.Type;

Symbols\Source\SourceComplexParameterSymbol.cs (19)

350new BoundLiteral(parameterSyntax, defaultValue, Type)); 404if (Type.IsNullableType()) 406convertedExpression = binder.GenerateConversionForAssignment(Type.GetNullableUnderlyingType(), 878return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 988if (this.Type.IsReferenceType) 1012else if (!compilation.Conversions.ClassifyConversionFromType((TypeSymbol)arg.TypeInternal, this.Type, isChecked: false, ref useSiteInfo).Kind.IsImplicitConversion()) 1221if (!Type.Equals(this.DeclaringCompilation.GetWellKnownType(WellKnownType.System_Threading_CancellationToken))) 1244if (Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true } handlerType) 1247diagnostics.Add(ErrorCode.ERR_TypeIsNotAnInterpolatedStringHandlerType, arguments.AttributeSyntaxOpt.Location, Type); 1506public sealed override bool IsParamsArray => (_parameterSyntaxKind & ParameterFlags.ParamsParameter) != 0 && this.Type.IsSZArray(); 1508public sealed override bool IsParamsCollection => (_parameterSyntaxKind & ParameterFlags.ParamsParameter) != 0 && !this.Type.IsSZArray(); 1536if (DeclaredScope == ScopedKind.ScopedValue && !Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 1553var collectionTypeKind = ConversionsBase.GetCollectionExpressionTypeKind(DeclaringCompilation, Type, out TypeWithAnnotations elementTypeWithAnnotations); 1567binder.TryGetCollectionIterationType(syntax, Type, out elementTypeWithAnnotations); 1575if (!binder.HasCollectionExpressionApplicableConstructor(syntax, Type, out MethodSymbol? constructor, isExpanded: out _, diagnostics, isParamsModifierValidation: true)) 1585if (!binder.HasCollectionExpressionApplicableAddMethod(syntax, Type, out ImmutableArray<MethodSymbol> addMethods, diagnostics)) 1594diagnostics.Add(ErrorCode.ERR_ParamsCollectionExtensionAddMethod, syntax, Type); 1625binder.TryGetCollectionIterationType(syntax, Type, out elementTypeWithAnnotations); 1633MethodSymbol? collectionBuilderMethod = binder.GetAndValidateCollectionBuilderMethod(syntax, (NamedTypeSymbol)Type, diagnostics, elementType: out _);

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)

2511return receiverParameter.Type; 4500if (!propertyParamType.Equals(methodParam.Type, TypeCompareKind.AllIgnoreOptions)) 4518eventSymbol.Type.Equals(methodParams[0].Type, TypeCompareKind.AllIgnoreOptions); 4851primaryAndCopyCtorAmbiguity = ctor.ParameterCount == 1 && ctor.Parameters[0].Type.Equals(this, TypeCompareKind.AllIgnoreOptions);

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (4)

1397p.Type.IsRefLikeOrAllowsRefLikeType())) 1407if ((overrideThisParameter is { RefKind: RefKind.Ref or RefKind.Out } && overrideThisParameter.Type.IsRefLikeOrAllowsRefLikeType()) || 1413else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeOrAllowsRefLikeType())) 1429else 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)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

1399checkAndReportManagedTypes(param.Type, param.RefKind, param.GetNonNullSyntaxNode(), isParam: true, diagnostics);

Symbols\Source\SourceNamedTypeSymbol.cs (2)

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

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

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

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (1)

237parameter.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)

681if (!IsExplicitInterfaceImplementation && !this.IsNoMoreVisibleThan(param.Type, ref useSiteInfo)) 683diagnostics.Add(ErrorCode.ERR_BadVisIndexerParam, Location, this, param.Type); 685else if (param.Type.HasFileLocalTypes() && !containingTypeForFileTypeCheck.HasFileLocalTypes()) 687diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Location, param.Type, containingTypeForFileTypeCheck); 709!this.IsNoMoreVisibleThan(extensionParameter.Type, ref useSiteInfo)) 711diagnostics.Add(ErrorCode.ERR_BadVisIndexerParam, Location, this, extensionParameter.Type);

Symbols\Source\SourcePropertySymbolBase.cs (1)

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

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (5)

81if (this.ContainingType is { IsExtension: true, ExtensionParameter.Type.IsStatic: true }) 390if (ContainingType is { IsExtension: true, ExtensionParameter: { Type.IsStatic: false } extensionParameter } && !IsStatic && 413if (extensionParameter.Type.IsStructType()) 421switch (extensionParameter.Type) 900if (ContainingType is { IsExtension: true, ExtensionParameter.Type: var extendedType })

Symbols\SubstitutedMethodSymbol.cs (1)

169return 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)

126F.Convert(baseEquals.Parameters[0].Type, other));

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedParameterSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedThrowSwitchExpressionExceptionMethod.cs (1)

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

Symbols\VarianceSafety.cs (1)

244param.Type,