Type

Binder\Binder.CapturedParametersFinder.cs (2)

167if (isTypeOrValueReceiver(enclosingBinder, id, parameter.Type, out SyntaxNode? memberAccessNode, out string? memberName, out int targetMemberArity, out bool invoked)) 170if (TreatAsInstanceMemberAccess(enclosingBinder, parameter.Type, memberAccessNode, memberName, targetMemberArity, invoked, lookupResult))

Binder\Binder.ValueChecks.cs (8)

145Debug.Assert(parameter.RefKind.IsWritableReference() && parameter.Type.IsRefLikeOrAllowsRefLikeType()); 2453parameter.Type.IsRefLikeOrAllowsRefLikeType() && 3483Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 3809Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4153Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4657Debug.Assert(parameter.Type.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions)); 4662if (LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, ((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type)) 4859Debug.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 (12)

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; 1538var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 1888if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 1906var spanTypeArg = ((NamedTypeSymbol)methodWithTargetTypeParameters.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2848(Conversions.ConvertExtensionMethodThisArg(GetReceiverParameter(method)!.Type, receiverOpt!.Type, ref useSiteInfo, isMethodGroupConversion: true).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty())); 2872source: delegateParameter.Type, 2873destination: methodParameter.Type,

Binder\Binder_Crefs.cs (2)

525if (ContainsNestedTypeOfUnconstructedGenericType(parameterSymbols[i].Type)) 588if (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; 10415original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10515original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10516original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None };

Binder\Binder_Invocation.cs (9)

682!candidate.Member.GetParameters().Last().Type.IsSZArray()) 1261receiverParameter.Type, diagnostics); 1373receiver = CreateConversion(receiver, extensionParameter.Type, diagnostics); 1421var parameterType = parameter.Type; 1655TypeSymbol parameterType = parameter.Type; 1774TypeSymbol collectionType = paramsParameter.Type; 1903!(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. 2228if (parameter.Name == name) return parameter.Type; 2234return (i < parameterList.Length) ? parameterList[i].Type : null;

Binder\Binder_Operators.cs (2)

333BoundExpression rightConverted = CreateConversion(right, overloadResolutionResult.ValidResult.Result.ConversionForArg(0), method.Parameters[0].Type, diagnostics); 343rightType: method.Parameters[0].Type,

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)

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

Binder\InMethodBinder.cs (1)

210if ((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 (3)

350if (thisParameter?.Type.IsReferenceType == false) 357thisParameter.Type); 432if (parameter.Type.IsDynamic())

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

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

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

1326op1Left = p[0].Type; 1327op1Right = p[1].Type; 1343op2Left = p[0].Type; 1344op2Right = p[1].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)

493: this(syntax, parameterSymbol, parameterSymbol.Type, hasErrors) 498: 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)

408var otherType = (TypeSymbol?)Visit(param.Type); 657_comparer.Equals(parameter.Type, other.Type); 925var 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)) 3025return param.Type.IsNonNullableValueType();

FlowAnalysis\DefiniteAssignment.cs (2)

364if (methodThisParameter.Type.SpecialType.CanOptimizeBehavior()) 482TypeSymbol parameterType = parameter.Type;

FlowAnalysis\NullableWalker.cs (4)

3772(p1, p2) => p1.Type.Equals(p2.Type, TypeCompareKind.AllNullableIgnoreOptions | TypeCompareKind.IgnoreTupleNames)) && 10986parameterOpt?.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)

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

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.PatternLocalRewriter.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_Call.cs (4)

237case (not null, not null) when !methodThisParameter.Type.Equals(interceptorThisParameterForCompare.Type, TypeCompareKind.ObliviousNullableModifierMatchesAny) 1175Debug.Assert(parameters[i].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }); 1246return ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol; 1252return methodOrIndexer.ContainingType.ExtensionParameter.Type as NamedTypeSymbol;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (3)

226ConversionsBase.HasIdentityConversion(builder.Parameters[0].Type, spreadType) && 328Debug.Assert(TypeSymbol.Equals(array.Type, spanConstructor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions)); 480var spanType = (NamedTypeSymbol)constructMethod.Parameters[0].Type;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (2)

1760Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1866Conversion 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\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\Extensions\SynthesizedExtensionMarker.cs (1)

118var underlyingType = 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)

359if ((thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) || 360(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 (1)

865TypeSymbol parameterType = parameter.Type;

Symbols\Source\SourceComplexParameterSymbol.cs (19)

349new BoundLiteral(parameterSyntax, defaultValue, Type)); 403if (Type.IsNullableType()) 405convertedExpression = binder.GenerateConversionForAssignment(Type.GetNullableUnderlyingType(), 877return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 987if (this.Type.IsReferenceType) 1011else if (!compilation.Conversions.ClassifyConversionFromType((TypeSymbol)arg.TypeInternal, this.Type, isChecked: false, ref useSiteInfo).Kind.IsImplicitConversion()) 1220if (!Type.Equals(this.DeclaringCompilation.GetWellKnownType(WellKnownType.System_Threading_CancellationToken))) 1243if (Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true } handlerType) 1246diagnostics.Add(ErrorCode.ERR_TypeIsNotAnInterpolatedStringHandlerType, arguments.AttributeSyntaxOpt.Location, Type); 1505public sealed override bool IsParamsArray => (_parameterSyntaxKind & ParameterFlags.ParamsParameter) != 0 && this.Type.IsSZArray(); 1507public sealed override bool IsParamsCollection => (_parameterSyntaxKind & ParameterFlags.ParamsParameter) != 0 && !this.Type.IsSZArray(); 1535if (DeclaredScope == ScopedKind.ScopedValue && !Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 1552var collectionTypeKind = ConversionsBase.GetCollectionExpressionTypeKind(DeclaringCompilation, Type, out TypeWithAnnotations elementTypeWithAnnotations); 1566binder.TryGetCollectionIterationType(syntax, Type, out elementTypeWithAnnotations); 1574if (!binder.HasCollectionExpressionApplicableConstructor(syntax, Type, out MethodSymbol? constructor, isExpanded: out _, diagnostics, isParamsModifierValidation: true)) 1584if (!binder.HasCollectionExpressionApplicableAddMethod(syntax, Type, out ImmutableArray<MethodSymbol> addMethods, diagnostics)) 1593diagnostics.Add(ErrorCode.ERR_ParamsCollectionExtensionAddMethod, syntax, Type); 1624binder.TryGetCollectionIterationType(syntax, Type, out elementTypeWithAnnotations); 1632MethodSymbol? collectionBuilderMethod = binder.GetAndValidateCollectionBuilderMethod(syntax, (NamedTypeSymbol)Type, diagnostics, elementType: out _);

Symbols\Source\SourceConstructorSymbolBase.cs (1)

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

Symbols\Source\SourceDelegateMethodSymbol.cs (3)

119diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, delegateType.GetFirstLocation(), delegateType, parameterSymbol.Type); 121else if (!delegateTypeIsFile && parameterSymbol.Type.HasFileLocalTypes()) 123diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, delegateType.GetFirstLocation(), parameterSymbol.Type, delegateType);

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (3)

1397p.Type.IsRefLikeOrAllowsRefLikeType())) 1412else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeOrAllowsRefLikeType())) 1428else 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)

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

Symbols\Source\SourceNamedTypeSymbol.cs (2)

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

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

173Conversion 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)

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

Symbols\Source\SourcePropertySymbolBase.cs (1)

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

Symbols\SubstitutedMethodSymbol.cs (1)

169return reduced.Parameters[0].Type;

Symbols\SymbolDistinguisher.cs (1)

147symbol = ((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)

444if (!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,