416this.Type = type; 422this.Type = type;

912RoslynDebug.Assert(expression.Type is object); 913return expression.Type;

944Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter()); 971if ((expr.ConstantValueOpt != null) || (expr.Type.GetSpecialTypeSafe() == SpecialType.System_Void)) 1161getItemOrSliceHelper = getItemOrSliceHelper.AsMember(getItemOrSliceHelper.ContainingType.Construct(ImmutableArray.Create(elementAccess.Expression.Type.TryGetInlineArrayElementField().TypeWithAnnotations))); 1233indices[0].Type, 1271Error(diagnostics, ErrorCode.ERR_BadSKunknown, expr.Syntax, expr.Type, MessageID.IDS_SK_TYPE.Localize()); 1940&& receiver?.Type?.IsValueType == true; 2174if (receiver is BoundObjectOrCollectionValuePlaceholder && receiver.Type.IsAnonymousType) 2336if (methodInvocationInfo.MethodInfo.Method?.RequiresInstanceReceiver == true && methodInvocationInfo.Receiver?.Type?.IsRefLikeOrAllowsRefLikeType() == true) 2559if (receiver?.Type?.IsRefLikeOrAllowsRefLikeType() == true) 2670Debug.Assert(receiver.Type is { }); 2675Debug.Assert(receiver is not BoundValuePlaceholderBase && method is not null && receiver.Type?.IsReferenceType == false); 2680receiver = new BoundCapturedReceiverPlaceholder(receiver.Syntax, receiver, receiver.Type).MakeCompilerGenerated(); 2799if (receiver.Type is TypeParameterSymbol typeParameter) 3038if (argument.Type?.IsRefLikeOrAllowsRefLikeType() == true) 3098if (argument.Type?.IsRefLikeOrAllowsRefLikeType() == true) 3234&& argument.Type?.IsRefLikeOrAllowsRefLikeType() == true) 3695Debug.Assert(expr.Type is not null); 3727if (expr.Type?.GetSpecialTypeSafe() == SpecialType.System_Void) 3997Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter()); 4012if (expr.Type?.GetSpecialTypeSafe() == SpecialType.System_Void) 4373if (expr.Type?.IsRefLikeOrAllowsRefLikeType() != true) 4780RoslynDebug.Assert(false, $"{expr.Kind} expression of {expr.Type} type"); 5012Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter()); 5033if (expr.Type?.IsRefLikeOrAllowsRefLikeType() != true) 5100Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeStackAlloc : ErrorCode.ERR_EscapeStackAlloc, node, expr.Type); 5355Error(diagnostics, ErrorCode.ERR_CollectionExpressionEscape, node, expr.Type); 5541RoslynDebug.Assert(false, $"{expr.Kind} expression of {expr.Type} type"); 5714TypeWithAnnotations.Create(elementAccess.Expression.Type), 5754TypeWithAnnotations.Create(inlineArray.Type),

66return new BoundRangeVariable(node, qv, translation, translation.Type); 74var receiverType = receiver.Type as NamedTypeSymbol; 80if (receiver.Type?.IsErrorType() != true) 96LookupMembersWithFallback(lookupResult, receiver.Type, name, 0, ref useSiteInfo, basesBeingResolved: null, options: options);

214TypeSymbol? expressionType = expression.Type;

847RoslynDebug.Assert(node.Type is object); 848var typedConstantKind = node.Type.GetAttributeParameterTypedConstantKind(_binder.Compilation); 901return new TypedConstant(spread.Expression.Type, TypedConstantKind.Error, value: null); 920var operandType = operand.Type; 1023var type = node.Type;

32var placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type); 87var type = expression.Type; 281Debug.Assert(TypeSymbol.Equals(expression.Type, getAwaiterArgument.Type, TypeCompareKind.ConsiderEverything)); 317TypeSymbol awaiterType = getAwaiter.Type!; 318return GetIsCompletedProperty(awaiterType, node, expression.Type!, diagnostics, out isCompleted) 320&& GetGetResultMethod(getAwaiter, node, expression.Type!, diagnostics, out getResult, out getAwaiterGetResultCall) 345if (expression.Type is not NamedTypeSymbol { Arity: 0 or 1 } exprType) 372placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type); 563if (expression.Type is null) 585RoslynDebug.Assert(expression.Type is object); 586if (expression.Type.IsVoidType()) 602Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type); 615Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type); 706var awaiterType = awaiterExpression.Type;

77else if (source.Type is not null && filterConversion(conversion, result)) 79var placeholder2 = new BoundValuePlaceholder(source.Syntax, source.Type); 160RoslynDebug.Assert(source.Type is object); 164if (!isCast && source.Type.Equals(destination, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)) 254TypeSymbol? type = source.Type; 299Debug.Assert(source.Type is null); 333source.Type is { } sourceType && 382switch (source.Type?.IsNullableType()) 387new BoundValuePlaceholder(source.Syntax, source.Type.GetNullableUnderlyingType()), 414else if (source.Type?.IsNullableType() == true) 418new BoundValuePlaceholder(source.Syntax, source.Type.GetNullableUnderlyingType()), 436if (source.Type?.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) == true && 514Debug.Assert(source.Type is { }); 516FieldSymbol? elementField = source.Type.TryGetInlineArrayElementField(); 550CheckInlineArrayTypeIsSupported(syntax, source.Type, elementField.Type, diagnostics); 554Debug.Assert(source.Type is not null); 563if (source.Type is ArrayTypeSymbol) 574if (source.Type.IsSpan()) 578TryFindImplicitOperatorFromSpan(source.Type.OriginalDefinition, destination.OriginalDefinition), 579source.Type.OriginalDefinition, 586if (source.Type.IsSpan() || source.Type.IsReadOnlySpan()) 589if (NeedsSpanCastUp(source.Type, destination)) 594TypeSymbol sourceForCastUp = source.Type.IsSpan() 596: source.Type.OriginalDefinition; 607.Construct([((NamedTypeSymbol)source.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0]]) 613if (source.Type.IsStringType()) 791unconvertedSource.Type, 1930Debug.Assert(methodGroup.ReceiverOpt.Type is not null); 2000diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, syntax, methodGroup.ReceiverOpt.Type); 2065TypeSymbol? receiverType = methodGroup.ReceiverOpt.Type; 2470Debug.Assert(targetTyped || destination.IsErrorType() || destination.Equals(source.Type, TypeCompareKind.ConsiderEverything)); 2489source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.ReachabilityDecisionDag, 2575Conversion toParameterTypeConversion = Conversions.ClassifyStandardConversion(convertedOperand.Type, conversionParameterType, ref useSiteInfo); 3317RoslynDebug.Assert(receiverOpt.Type is object); 3319diagnostics.Add(ErrorCode.ERR_QueryNoProvider, node.Location, receiverOpt.Type, memberSymbol.Name); 3337RoslynDebug.Assert(receiverOpt.Type is object); 3338diagnostics.Add(ErrorCode.ERR_BadAwaitArg, node.Location, receiverOpt.Type); 3473(Conversions.ConvertExtensionMethodThisArg(GetReceiverParameter(method)!.Type, receiverOpt!.Type, ref useSiteInfo, isMethodGroupConversion: true).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty()));

122if ((object?)boundRHS.Type == null || boundRHS.Type.IsErrorType()) 128var type = boundRHS.Type ?? voidType; 143boundRHS.Type, 158Debug.Assert(hasErrors || lhsTuple.Type is object); 159TypeSymbol returnType = hasErrors ? CreateErrorType() : lhsTuple.Type!; 227else if ((object?)boundRHS.Type == null) 323Debug.Assert(single.Type is not null); 325nestedConversion = this.Conversions.ClassifyConversionFromType(tupleOrDeconstructedTypes[i], single.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 331GenerateImplicitConversionError(diagnostics, Compilation, single.Syntax, nestedConversion, tupleOrDeconstructedTypes[i], single.Type); 338nestedConversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, single.Type, diagnostics))); 359if ((object?)pending.Type != null) 423Debug.Assert((object?)variables[i].Single!.Type != null); 483TypeSymbol? mergedType = element.Type; 504if ((object?)variable.Single.Type != null) 507mergedType = variable.Single.Type; 571typesWithAnnotationsBuilder.Add(TypeWithAnnotations.Create(value.Type)); 624if (receiver.Type?.IsDynamic() ?? false) 720if (receiver.Type?.IsErrorType() == false) 722Error(diagnostics, ErrorCode.ERR_MissingDeconstruct, rightSyntax, receiver.Type, numParameters);

223TypeSymbol resultType = expr.Type; 321var commonType = expr.Type; 401case BoundStackAllocArrayCreation { Type: null } boundStackAlloc: 602TypeSymbol exprType = expr.Type; 1019subExpressions.SelectAsArray(e => TypeWithAnnotations.Create(e.Type)), 1076if (boundArgument.Type?.SpecialType == SpecialType.System_Void) 1086var elementTypeWithAnnotations = TypeWithAnnotations.Create(boundArgument.Type); 1285if ((object)argument.Type != null && argument.Type.IsRestrictedType()) 1288Error(diagnostics, ErrorCode.ERR_MethodArgCantBeRefAny, node, argument.Type); 1743type: expression.Type, 2666(object)operand.Type != null && 2667!operand.Type.IsNullableType() && 2668!TypeSymbol.Equals(targetType.GetNullableUnderlyingType(), operand.Type, TypeCompareKind.ConsiderEverything2)) 2689if ((object)boundOperand.Type != null && boundOperand.Type.IsNullableType()) 2768if (left?.Type.IsNullableType() == true || right?.Type.IsNullableType() == true) 2796if (boundOperand.Type?.IsNullableType() == true) 2888SymbolDistinguisher distinguisher1 = new SymbolDistinguisher(this.Compilation, operand.Type, targetType); 2937case BoundKind.UnconvertedConditionalOperator when operand.Type is null: 2938case BoundKind.UnconvertedSwitchExpression when operand.Type is null: 2962Debug.Assert((object)operand.Type != null); 2963SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, operand.Type, targetType); 3004Debug.Assert((object)operand.Type != null && !operand.Type.IsNullableType()); 3010var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3866Debug.Assert(receiver!.Type is not null); 3868placeholderType = receiver.Type; 4314if ((object)boundExpression.Type == null || !boundExpression.Type.IsErrorType()) 4398Debug.Assert(init.Type.IsErrorType()); 4808if (constantValue == null || constantValue.IsBad || expression.Type.SpecialType != SpecialType.System_Int32) 4831var type = expression.Type.SpecialType; 5407Debug.Assert(expression.Type is { }); 5409var expressionPlaceholder = new BoundCollectionExpressionSpreadExpressionPlaceholder(syntax.Expression, expression.Type); 5422_ = expression.Type.HasInlineArrayAttribute(out int length); 5462if (arg.Type is { TypeKind: TypeKind.Dynamic }) 5611else if ((object)argument.Type == null) 5623else if (argument.Type.TypeKind == TypeKind.Delegate) 5625var sourceDelegate = (NamedTypeSymbol)argument.Type; 5629if (ReportDelegateInvokeUseSiteDiagnostic(diagnostics, argument.Type, node: node)) 5889Debug.Assert((object)boundLeft.Type != null); 5898type: boundLeft.Type, 6183type: boundMember.Type, 6596({ Type: null } or BoundLiteral or BoundUnconvertedInterpolatedString or BoundBinaryOperator { IsUnconvertedInterpolatedStringAddition: true }) && 7726leftType = BindRangeVariable(left, (RangeVariableSymbol)leftSymbol, BindingDiagnosticBag.Discarded).Type; 7741if (TypeSymbol.Equals(boundType.Type, leftType, TypeCompareKind.AllIgnoreOptions)) 7753Debug.Assert(leftType.Equals(boundValue.Type, TypeCompareKind.ConsiderEverything)); 7771TypeSymbol.Equals(BindNamespaceOrType(id, BindingDiagnosticBag.Discarded).Type, type, TypeCompareKind.AllIgnoreOptions); 7881TypeSymbol leftType = boundLeft.Type; 7919leftType = boundLeft.Type; 8163Error(diagnostics, ErrorCode.WRN_DotOnDefault, node, boundLeft.Type); 8290var leftType = boundLeft.Type; 8425if ((object)boundLeft.Type == null) 8434Error(diagnostics, ErrorCode.ERR_NoSuchMember, name, boundLeft.Type, plainName); 8436else if (WouldUsingSystemFindExtension(boundLeft.Type, plainName)) 8438Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtensionNeedUsing, name, boundLeft.Type, plainName, "System"); 8440else if (boundLeft.Kind == BoundKind.AwaitableValuePlaceholder && boundLeft.Type.IsIAsyncEnumerableType(Compilation)) 8442Error(diagnostics, ErrorCode.ERR_NoAwaitOnAsyncEnumerable, name, boundLeft.Type, plainName); 8446Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtension, name, boundLeft.Type, plainName); 8747Debug.Assert(left.Type is not null); 8748Debug.Assert(!left.Type.IsDynamic()); 8840Debug.Assert(left.Type is not null); 8952TypeSymbol? receiverType = left.Type; 9084errorInfo = new CSDiagnosticInfo(ErrorCode.ERR_ExtensionResolutionFailed, left.Type, memberName); 9137TypeSymbol receiverType = receiver.Type; 9333if (receiverOpt is { Type: TypeParameterSymbol { AllowsRefLikeType: true } } && 9375bool isUsableAsField = eventSymbol.HasAssociatedField && this.IsAccessible(eventSymbol.AssociatedField, ref useSiteInfo, (receiver != null) ? receiver.Type : null); 9597if (!result.HasErrors && receiver.Type?.IsPointerOrFunctionPointer() == true) 9599Debug.Assert(receiver.Type?.IsFunctionPointer() != true, "There should have been an error reported for indexing into a function pointer."); 9633if ((object)expr.Type == null) 9654expr.Type.HasInlineArrayAttribute(out int length) && expr.Type.TryGetPossiblyUnsupportedByLanguageInlineArrayElementField() is FieldSymbol elementField) 9666Debug.Assert(expr.Type.TryGetInlineArrayElementField() is not null); 9686{ Code: (int)ErrorCode.ERR_BadIndexLHS, Arguments: [TypeSymbol type] } && type.Equals(expr.Type, TypeCompareKind.ConsiderEverything)) 9813CheckInlineArrayTypeIsSupported(node, expr.Type, elementField.Type, diagnostics); 9865if (TypeSymbol.Equals(convertedIndex.Type, compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.AllIgnoreOptions)) 9913Debug.Assert((object)expr.Type != null); 9916var exprType = expr.Type; 9959var arrayType = (ArrayTypeSymbol)expr.Type; 10006var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(expr.Syntax, isEquivalentToThisReference: expr.IsEquivalentToThisReference, expr.Type) { WasCompilerGenerated = true }; 10170Debug.Assert(expr.Type.IsPointerType()); 10171PointerTypeSymbol pointerType = (PointerTypeSymbol)expr.Type; 10217Debug.Assert((object)expr.Type != null); 10223this.LookupMembersWithFallback(lookupResult, expr.Type, WellKnownMemberNames.Indexer, arity: 0, useSiteInfo: ref useSiteInfo, options: lookupOptions); 10539var argType = argument.Type; 10545Debug.Assert(receiver.Type is not null); 10552var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(receiver.Syntax, isEquivalentToThisReference: receiver.IsEquivalentToThisReference, receiver.Type) { WasCompilerGenerated = true }; 10561Debug.Assert(indexerOrSliceAccess.Type is not null); 10571indexerOrSliceAccess.Type); 10785Debug.Assert(receiverPlaceholder.Type is not null); 10786if (TryLookupLengthOrCount(syntax, receiverPlaceholder.Type, lookupResult, out var lengthOrCountProperty, diagnostics)) 11145Debug.Assert(node.ReceiverOpt!.Type is not null); // extensions are only considered on member access 11176var substituted = (MethodSymbol?)extensionMember.GetReducedAndFilteredSymbol(typeArguments, receiver.Type, Compilation, checkFullyInferred: true); 11182else if (m.ReduceExtensionMethod(receiver.Type, Compilation) is { } reduced) 11361Debug.Assert(node.ReceiverOpt!.Type is not null); // extensions are only considered on member access 11387var substituted = (MethodSymbol?)extensionMember.GetReducedAndFilteredSymbol(typeArguments, receiver.Type, Compilation, checkFullyInferred: true); 11636var receiverType = receiver.Type; 11645var accessType = access.Type; 11784var receiverType = receiver.Type; 11815var receiverType = receiver.Type;

259((object?)expression.Type == null || !expression.Type.IsVoidType()))

219Debug.Assert(unconvertedInterpolatedString.Type?.SpecialType == SpecialType.System_String); 245Debug.Assert(unconvertedInterpolatedString.Parts.All(static part => part.Type is null or { SpecialType: SpecialType.System_String })); 259if (unconvertedInterpolatedString.Type.IsErrorType() || haveErrors || canLowerToStringConcatenation(parts)) 264return BindUnconvertedInterpolatedExpressionToFactory(unconvertedInterpolatedString, parts, (NamedTypeSymbol)unconvertedInterpolatedString.Type, factoryMethod: "Format", unconvertedInterpolatedString.Type, diagnostics); 272unconvertedInterpolatedString.Type, 304fillin.Value.Type?.SpecialType != SpecialType.System_String || 367unconvertedSource.Type, 397if (value.Type?.TypeKind == TypeKind.Dynamic) 433&& unconvertedInterpolatedString.Parts.All(p => p is not BoundStringInsert { Value.Type.TypeKind: TypeKind.Dynamic }); 436=> parts.All(p => p is BoundLiteral or BoundStringInsert { Value.Type.SpecialType: SpecialType.System_String, Alignment: null, Format: null }); 536expression.Type, 597unconvertedInterpolatedString.Type, 684if (value.Type is not null) 860if (insert.Value.Type is null) 887Debug.Assert(part is BoundLiteral { Type: { SpecialType: SpecialType.System_String }, ConstantValueOpt.IsString: true }); 955argumentsBuilder.Add(boundLiteral.Update(ConstantValue.Create(literalText), boundLiteral.Type));

285else if ((object)argument.Type == null && !argument.HasAnyErrors) 296else if (argument.Type.IsVoidType()) 350if ((object)boundExpression.Type != null && boundExpression.Type.IsDynamic()) 378else if (boundExpression.Type?.Kind == SymbolKind.FunctionPointerType) 565Debug.Assert(receiver.Type is not null); 566Error(diagnostics, ErrorCode.ERR_CannotDynamicInvokeOnExpression, receiver.Syntax, receiver.Type); 617Debug.Assert((object?)arg.Type != null); 620Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, arg.Type); 856Debug.Assert(methodGroup.ReceiverOpt != null && (object)methodGroup.ReceiverOpt.Type != null); 858Error(diagnostics, ErrorCode.ERR_BadArgTypeDynamicExtension, syntax, methodGroup.ReceiverOpt.Type, methodGroup.Name); 1085if (!call.HasAnyErrors && call.ReceiverOpt != null && (object)call.ReceiverOpt.Type != null && !call.Method.IsExtensionBlockMember()) 1090if (call.ReceiverOpt.Type.IsRestrictedType() && !call.Method.ContainingType.IsInterface && !TypeSymbol.Equals(call.Method.ContainingType, call.ReceiverOpt.Type, TypeCompareKind.ConsiderEverything2)) 1092SymbolDistinguisher distinguisher = new SymbolDistinguisher(compilation, call.ReceiverOpt.Type, call.Method.ContainingType); 1108(object)dynInvoke.Expression.Type != null && 1109dynInvoke.Expression.Type.IsRestrictedType()) 1113Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, dynInvoke.Expression.Syntax, dynInvoke.Expression.Type); 1401if (receiver is BoundValuePlaceholderBase || receiver?.Type is null or { IsReferenceType: true }) 1912receiver.Type.IsValueType && 1983Debug.Assert(typeOrValue.Type.Equals(boundValue.Type, TypeCompareKind.ConsiderEverything)); 2030var type = expr.Type as NamedTypeSymbol; 2085var methodContainer = (object)receiver != null && (object)receiver.Type != null 2086? receiver.Type 2328var methodContainer = expr.Type ?? this.ContainingType; 2534RoslynDebug.Assert(boundExpression.Type is FunctionPointerTypeSymbol); 2536var funcPtr = (FunctionPointerTypeSymbol)boundExpression.Type;

72Debug.Assert(left.Type is { }); 75var placeholder = new BoundValuePlaceholder(right.Syntax, left.HasDynamicType() ? left.Type : right.Type).MakeCompilerGenerated(); 76var finalDynamicConversion = this.Compilation.Conversions.ClassifyConversionFromExpression(placeholder, left.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 78var conversion = (BoundConversion)CreateConversion(node, placeholder, finalDynamicConversion, isCast: true, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, left.Type, diagnostics); 87left.Type, 88right.Type, 96left.Type, 267var leftType = left.Type; 340var leftType = left.Type; 383var leftType = left.Type; 434var leftType = left.Type; 780TypeSymbol type = operand.Type; 808Debug.Assert((object)left.Type != null && left.Type.IsDynamic() || (object)right.Type != null && right.Type.IsDynamic()); 832Error(diagnostics, ErrorCode.ERR_InvalidDynamicCondition, node.Left, left.Type, kind == BinaryOperatorKind.LogicalAnd ? "false" : "true"); 838Debug.Assert(left.Type is not TypeParameterSymbol); 952TypeSymbol leftType = left.Type; 953TypeSymbol rightType = right.Type; 988Debug.Assert(right.Type.SpecialType == SpecialType.System_String); 989var stringConstant = FoldBinaryOperator(node, BinaryOperatorKind.StringConcatenation, left, right, right.Type, diagnostics); 990return new BoundBinaryOperator(node, BinaryOperatorKind.StringConcatenation, BoundBinaryOperator.UncommonData.UnconvertedInterpolatedStringAddition(stringConstant), LookupResultKind.Empty, left, right, right.Type); 1191TypeSymbol leftType = left.Type; 1192TypeSymbol rightType = right.Type; 1309(object?)left.Type != null && left.Type.TypeKind == TypeKind.Delegate) 1313var conversion = this.Conversions.ClassifyConversionFromExpression(right, left.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 1315GenerateImplicitConversionError(diagnostics, right.Syntax, conversion, right, left.Type); 1343case (BoundKind.DefaultLiteral, _) when right.Type is TypeParameterSymbol: 1344Debug.Assert(!right.Type.IsReferenceType); 1345Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnUnconstrainedDefault, node, operatorToken.Text, right.Type); 1347case (_, BoundKind.DefaultLiteral) when left.Type is TypeParameterSymbol: 1348Debug.Assert(!left.Type.IsReferenceType); 1349Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnUnconstrainedDefault, node, operatorToken.Text, left.Type); 1367case LookupResultKind.OverloadResolutionFailure when operatorToken.Kind() is SyntaxKind.PlusToken && isReadOnlySpanOfByte(left.Type) && isReadOnlySpanOfByte(right.Type): 1441if ((object)left.Type != null && left.Type.SpecialType == SpecialType.System_Boolean && 1442(object)right.Type != null && right.Type.SpecialType == SpecialType.System_Boolean) 1444var constantValue = FoldBinaryOperator(node, kind | BinaryOperatorKind.Bool, left, right, left.Type, diagnostics); 1448resultKind: LookupResultKind.Viable, left, right, type: left.Type, hasErrors: constantValue != null && constantValue.IsBad); 1535Debug.Assert(resultLeft.Type.Equals(signature.LeftType, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 1536var operandPlaceholder = new BoundValuePlaceholder(resultLeft.Syntax, resultLeft.Type).MakeCompilerGenerated(); 1592var type = left.Type; 1609if (left.Type is not null) 1611CreateConversion(left.Syntax, new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated(), implicitConversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, booleanType, diagnostics); 2101if (left.Type is null && right.Type is null) 2361(object)operand.Type != null && 2362(operand.Type.SpecialType == SpecialType.System_UInt64 || isNuint(operand.Type))) 2414operand.Type is null) // GetUserDefinedOperators performs this check too, let's optimize early 2647return left.Type; 2650return right.Type; 2714BinaryOperatorKind newKind = kind.Operator().WithType(newLeftOperand.Type!.SpecialType); 3274var operandType = operand.Type; 3428var operandType = operand.Type; 3475Debug.Assert(operand.Type is not null); 3481operand.Type, 3518var operandType = operand.Type; 3670Debug.Assert(operand.Type is not null); 4074var operandType = operand.Type as PointerTypeSymbol; 4129TypeSymbol operandType = operand.Type; 4208if (receiver.Type.IsReferenceType) 4334if (isOperandNullOrNew || operand.Type?.IsErrorType() == true) 4362type: operand.Type!); 4416var underlyingType = operand.Type.GetEnumUnderlyingType()!; 4775if ((object)operand.Type == null && !operand.IsLiteralNull()) 4826TypeSymbol inputType = operand.Type; 4846inputType = operand.Type; 4885node.Right, convertedExpression, constantValueOpt ?? ConstantValue.Bad, isUnionMatching: unionMatchingInputType is not null, inputType: unionMatchingInputType ?? inputType, convertedExpression.Type ?? inputType, hasErrors).MakeCompilerGenerated(); 5373if ((object)operand.Type == null) 5435Debug.Assert(operand.Type is null); 5436operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 5450var operandType = operand.Type; 5483operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 5662TypeSymbol optLeftType = leftOperand.Type; // "A" 5663TypeSymbol optRightType = rightOperand.Type; // "B" 5836TypeSymbol leftType = leftOperand.Type; 5854if (underlyingRightConversion.Exists && rightOperand.Type?.IsDynamic() != true) 5995TypeSymbol trueType = trueExpr.Type; 5996TypeSymbol falseType = falseExpr.Type;

209TypeSymbol? expressionType = expression.Type; 222Debug.Assert(expression.Type is { }); 224BoundPattern pattern = BindPattern(node.Pattern, ref unionType, expression.Type, permitDesignations: true, hasErrors, diagnostics, out bool hasUnionMatching, underIsPattern: true); 253Debug.Assert(expression.Type is object); 254diagnostics.Add(ErrorCode.ERR_IsPatternImpossible, node.Location, expression.Type); 271Debug.Assert(expression.Type is object); 272diagnostics.Add(ErrorCode.WRN_IsPatternAlways, node.Location, expression.Type); 452Debug.Assert(indexerAccess.Type is not null); 453sliceType = indexerAccess.Type; 541Debug.Assert(indexerAccess!.Type is not null); 542elementType = indexerAccess.Type; 656var convertedType = convertedExpression.Type ?? inputType; 768Debug.Assert(originalExpression is { Kind: BoundKind.TypeExpression, Type: { } }); 769hasErrors |= CheckValidPatternType(patternExpression, unionType, inputType, originalExpression.Type, diagnostics: diagnostics); 834if (convertedExpression.Type is null && constantValueOpt != ConstantValue.Null) 877RoslynDebug.Assert(expression.Type is { }); 878ConstantValue match = ExpressionOfTypeMatchesPatternType(Conversions, inputType, expression.Type, ref useSiteInfo, out _, operandConstantValue: null); 910if (expression.Type?.SpecialType == SpecialType.System_String && inputType.IsSpanOrReadOnlySpanChar()) 965(conversion.ConversionKind == ConversionKind.NoConversion && convertedExpression.Type?.IsErrorType() == true)) 974if (!hasErrors && unionType is not null && !convertedExpression.HasErrors && constantValue is { IsBad: false } && expression.Type is not null) 2068var type = value.Type ?? inputType;

300Debug.Assert(state.fromExpression.Type is { }); 303ImmutableArray.Create(state.fromExpression), state.fromExpression.Type); 743else if (!yExpression.HasAnyErrors && yExpression.Type!.IsVoidType()) 745Error(d, ErrorCode.ERR_QueryRangeVariableAssignedBadValue, errorLocation, yExpression.Type!); 746Debug.Assert(yExpression.Type is { }); 747yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), yExpression.Type); 808field2Value = new BoundBadExpression(field2Value.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(field2Value), field2Value.Type, true); 828return e.Type ?? CreateErrorType(); 933Debug.Assert(receiver.Type is object || ultimateReceiver.Type is null); 934if ((object?)ultimateReceiver.Type == null) 968if (ultimateReceiver.Type.TypeKind == TypeKind.TypeParameter) 971Error(diagnostics, ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax, ultimateReceiver.Type, MessageID.IDS_SK_TYVAR.Localize()); 979else if (receiver.Type!.IsVoidType())

45if (instanceArgument.Type.IsDynamic()) 52else if (ImplementsStandardQueryInterface(instanceArgument.Type, name, ref useSiteInfo)) 57new object[] { instanceArgument.Type, name }, 60else if (fromClause != null && fromClause.Type == null && HasCastToQueryProvider(instanceArgument.Type, ref useSiteInfo)) 65new object[] { instanceArgument.Type, name, fromClause.Identifier.ValueText }, 73new object[] { instanceArgument.Type, name }, 238TypeSymbol receiverType = receiver?.Type;

407var type = boundExpr.Type; 764Debug.Assert(expr.Type is object); 765Debug.Assert(expr.Type.IsRefLikeType || hasAwait); // pattern dispose lookup is only valid on ref structs or asynchronous usings 1027TypeSymbol initializerType = initializerOpt?.Type; 1237TypeSymbol initializerType = initializerOpt.Type; 1253elementType = ((BoundAddressOfOperator)initializerOpt).Operand.Type; 1327if (initializer.Type.IsVoidType()) 1347additionalDiagnostics.Add(ErrorCode.WRN_PatternBadSignature, initializer.Syntax.Location, initializer.Type, "fixed", patternMethodSymbol); 1465var inferredType = op2.Type; 1491if (op1.Type is { } lhsType && !lhsType.IsErrorType()) 1539type = op1.Type; 1560Debug.Assert(op1.Type is { }); 1593Debug.Assert(leftEscape.Equals(rightEscape) || op1.Type.IsRefLikeOrAllowsRefLikeType()); 1628if (!hasErrors && op1.Type.IsRefLikeOrAllowsRefLikeType()) 1860Debug.Assert((object)receiver.Type != null); 1861return receiver.Type; 1987this.Conversions.ClassifyConversionFromType(expression.Type, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 2019expression.Type, 2479var sourceType = operand.Type; 3090hasErrors |= arg.HasErrors || ((object)arg.Type != null && arg.Type.IsErrorType()); 3165if ((object)arg?.Type != null && arg.Type.IsVoidType()) 3230&& TypeSymbol.Equals(argument.Type, this.GetCurrentReturnType(out unusedRefKind), TypeCompareKind.ConsiderEverything2)) 3233Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType, argument.Type); 3582else if (expression.Type?.SpecialType == SpecialType.System_Void)

1522receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Ambiguous, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(receiver), receiver.Type, hasErrors: true).MakeCompilerGenerated(); 1531Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtension, right, receiver.Type, plainName); 1532receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, childBoundNodes: [AdjustBadExpressionChild(receiver)], receiver.Type, hasErrors: true).MakeCompilerGenerated();

85TypeSymbol leftType = left.Type; 86TypeSymbol rightType = right.Type; 112return new TupleBinaryOperatorInfo.Single(binary.Left.Type, binary.Right.Type, binary.OperatorKind, binary.BinaryOperatorMethod, binary.ConstrainedToType, 187Debug.Assert((object)left.Type != null && left.Type.IsDynamic() || (object)right.Type != null && right.Type.IsDynamic()); 209left = GiveTupleTypeToDefaultLiteralIfNeeded(left, right.Type); 210right = GiveTupleTypeToDefaultLiteralIfNeeded(right, left.Type); 224Debug.Assert((object)left.Type != null || left.Kind == BoundKind.TupleLiteral); 225Debug.Assert((object)right.Type != null || right.Kind == BoundKind.TupleLiteral); 254bool leftNullable = left.Type?.IsNullableType() == true; 255bool rightNullable = right.Type?.IsNullableType() == true; 363TypeSymbol type = expr.Type; 390TypeSymbol tupleType = expr.Type.StrippedType();

20var receiverType = receiver.Type;

594Debug.Assert(variableAccess.Type!.Equals(input.Type, TypeCompareKind.AllIgnoreOptions) || variableAccess.Type.IsErrorType()); 893Debug.Assert(constant.Value.Type is not null || constant.HasErrors); 894if (constant.Value.Type is { } type) 1151var type = rel.Value.Type ?? inputInfo.GetInputType();

558(builder.ElementType.IsPointerOrFunctionPointer() && collectionExpr.Type.IsArray()) || 559(builder.ElementType.IsNullableType() && builder.ElementType.GetMemberTypeArgumentsNoUseSiteDiagnostics().Single().IsErrorType() && collectionExpr.Type.IsArray())); 595(collectionConversionClassification.Kind == ConversionKind.ExplicitReference && collectionExpr.Type.SpecialType == SpecialType.System_String)); 665Debug.Assert(collectionType.Equals(collectionExpr.Type, TypeCompareKind.AllIgnoreOptions)); // Should not create an Identity conversion that changes type. 705else if (collectionExpr.Type.SpecialType == SpecialType.System_String && builder.CollectionType.SpecialType == SpecialType.System_Collections_IEnumerable) 723TypeSymbol collectionExprType = collectionExpr.Type; 800TypeSymbol collectionExprType = collectionExpr.Type; 839if (!isAsync && collectionExpr.Type?.HasInlineArrayAttribute(out _) == true && collectionExpr.Type.TryGetPossiblyUnsupportedByLanguageInlineArrayElementField() is FieldSymbol elementField) 870diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type); 893builder.CollectionType = collectionExpr.Type; 910CheckInlineArrayTypeIsSupported(collectionExpr.Syntax, collectionExpr.Type, elementField.Type, diagnostics); 918diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type); 931(originalCollectionExpr.Type?.IsNullableType() == true && originalCollectionExpr.Type.StrippedType().Equals(collectionExpr.Type, TypeCompareKind.AllIgnoreOptions))); 942TypeSymbol collectionExprType = collectionExpr.Type; 982var unwrappedCollectionExprType = unwrappedCollectionExpr.Type; 1052builder.CollectionType = collectionExpr.Type; 1349getEnumeratorInfo = FindForEachPatternMethod(syntax, collectionSyntax, collectionExpr.Type, methodName, lookupResult, warningsOnly: true, diagnostics, isAsync); 1600diagnostics.Add(ErrorCode.WRN_PatternIsAmbiguous, collectionSyntax.Location, collectionExpr.Type, MessageID.IDS_Collection.Localize(),

40TypeSymbol? exprType = expr.Type;

289return placeholder.Type?.SpecialType == SpecialType.System_Int32; 582if (node.ExpressionOpt is { Type: { } } expr) 592if (node.Expression is { Type: { } } expr) 1317var elementType = ((NamedTypeSymbol)spanPlaceholder.Type!).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0];

138if (expr1.Type is { } type1) 153if (expr2.Type is { } type2)

493if (method.RequiresInstanceReceiver && methodGroup.Receiver?.Type?.IsRestrictedType() == true) 524Debug.Assert((object)sourceExpression.Type == null);

104var sourceType = sourceExpression.Type; 289if (TryGetVoidConversion(sourceExpression.Type, destination, out var conversion)) 609Debug.Assert(sourceExpression == null || (object)sourceExpression.Type == (object)source); 1048Debug.Assert(sourceExpression == null || (object)sourceExpression.Type == (object)source); 1090var innerConversion = ClassifyImplicitBuiltInConversionFromExpression(innerExpression, innerExpression.Type, destination, ref useSiteInfo); 1368if (constantValue == null || (object)source.Type == null) 1378var specialSource = source.Type.GetSpecialTypeSafe(); 1434var sourceType = sourceExpression.Type; 1477source.Type is object && 1478IsNumericType(source.Type) && 1939Debug.Assert(sourceExpressionOpt == null || (object)sourceExpressionOpt.Type == sourceType); 1976conversions.ClassifyImplicitExtensionMethodThisArgConversion(s, s.Type, d.Type, ref u, isMethodGroupConversion: false), 3065if (expressionToCheck.Type is TypeSymbol typeToCheck && IsRefLikeOrAllowsRefLikeTypeImplementingVarianceCompatibleInterface(typeToCheck, targetInterfaceType, ref useSiteInfo))

288var leftType = left.Type; 294var rightType = right.Type; 326Debug.Assert((object?)left.Type != null); 328Debug.Assert((object?)right.Type != null); 348if (left.Type.SpecialType != right.Type.SpecialType) 354if (left.Type.SpecialType == SpecialType.System_Int32 || 355left.Type.SpecialType == SpecialType.System_Boolean || 356left.Type.SpecialType == SpecialType.System_String)

78TypeSymbol leftOperatorSourceOpt = left.Type?.StrippedType(); 79TypeSymbol rightOperatorSourceOpt = right.Type?.StrippedType(); 373var leftType = left.Type; 375var rightType = right.Type; 517bool isExactSubtraction = TypeSymbol.Equals(right.Type?.StrippedType(), underlying, TypeCompareKind.ConsiderEverything2); 621var leftType = left.Type; 627var rightType = right.Type; 696var leftType = left.Type as PointerTypeSymbol; 697var rightType = right.Type as PointerTypeSymbol; 712if ((object)leftType != null || (object)rightType != null || left.Type is FunctionPointerTypeSymbol || right.Type is FunctionPointerTypeSymbol) 734if ((left.Type is TypeParameterSymbol { AllowsRefLikeType: true } && right.IsLiteralNull()) || 735(right.Type is TypeParameterSymbol { AllowsRefLikeType: true } && left.IsLiteralNull())) 754this.Compilation.BuiltInOperators.GetSimpleBuiltInOperators(kind, operators, skipNativeIntegerOperators: !left.Type.IsNativeIntegerOrNullableThereof() && !right.Type.IsNativeIntegerOrNullableThereof()); 769this.Compilation.BuiltInOperators.GetUtf8ConcatenationBuiltInOperator(left.Type, operators); 780BuiltInOperators.IsValidObjectEquality(conversions, left.Type, left.IsLiteralNull(), leftIsDefault: false, right.Type, right.IsLiteralNull(), rightIsDefault: false, ref useSiteInfo) && 781((object)left.Type == null || (!left.Type.IsDelegateType() && left.Type.SpecialType != SpecialType.System_String && left.Type.SpecialType != SpecialType.System_Delegate)) && 782((object)right.Type == null || (!right.Type.IsDelegateType() && right.Type.SpecialType != SpecialType.System_String && right.Type.SpecialType != SpecialType.System_Delegate)); 792return (operand.Type is TypeParameterSymbol { AllowsRefLikeType: true }) ? Conversion.Boxing : Conversions.ClassifyConversionFromExpression(operand, objectType, isChecked: isChecked, ref useSiteInfo); 1448if (left.Type?.IsNullableType() == true || right.Type?.IsNullableType() == true) // Wouldn't be applicable to the receiver type otherwise 1590if (left.Type is not null && parameterMatchesReceiver(in candidate, 0) && isOperandApplicableToReceiver(in candidate, left, ref useSiteInfo)) 1595if (!kind.IsShift() && right.Type is not null && parameterMatchesReceiver(in candidate, 1) && isOperandApplicableToReceiver(in candidate, right, ref useSiteInfo)) 1614Debug.Assert(operand.Type is not null); 1617if (candidate.Kind.IsLifted() && operand.Type.IsNullableType()) 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)

99var operandType = operand.Type;

83Debug.Assert(operand.Type is not null); 89if (operand.Type.IsNullableType()) // Wouldn't be applicable to the receiver type otherwise 220Debug.Assert(operand.Type is not null); 225Debug.Assert(operand.Type.IsNullableType()); 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) 514this.Compilation.BuiltInOperators.GetSimpleBuiltInOperators(kind, operators, skipNativeIntegerOperators: !operand.Type.IsNativeIntegerOrNullableThereof()); 553var enumType = operand.Type; 584var pointerType = operand.Type as PointerTypeSymbol; 615if ((object)operand.Type == null) 643return GetUserDefinedOperators(operand.Type.StrippedType(), kind, isChecked, name1, name2Opt, operand, results, ref useSiteInfo);

101if ((object?)argument.Type != null && argument.Type.IsDynamic() && (!hasRefKinds || RefKinds[i] == Microsoft.CodeAnalysis.RefKind.None))

381sb.AppendFormat("Argument types ({0})\n", string.Join(", ", from a in _arguments select a.Type)); 879if (argument.Kind == BoundKind.TupleLiteral && (object)argument.Type == null) 3307TypeSymbol source = argument.Type;

3270if ((object)node.Type != null && Conversions.HasIdentityConversion(node.Type, t)) 4731var argType = argument.Type; 4745Conversions.ClassifyImplicitExtensionMethodThisArgConversion(argument, argument.Type, parameterType, ref useSiteInfo, isMethodGroupConversion: isMethodGroupConversion) : 4746((!dynamicConvertsToAnything || !argument.Type.IsDynamic()) ?

545diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, location, receiver.Type); 685diagnostics.Add(ErrorCode.ERR_QueryNoProvider, location, receiverOpt.Type, symbol.Name); 693diagnostics.Add(ErrorCode.ERR_BadAwaitArg, location, receiverOpt.Type); 813new object[] { instanceArgument.Type, inferenceFailed.Member.Name }, 1171diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, location, receiver.Type); 1410=> argument is BoundLiteral { Type.SpecialType: SpecialType.System_String } && 1449diagnostics.Add(ErrorCode.ERR_QueryMultipleProviders, location, receiver.Type, name);

48protected TypeSymbol SwitchGoverningType => SwitchGoverningExpression.Type; 402var switchGoverningType = switchGoverningExpression.Type; 464Debug.Assert((object)switchGoverningExpression.Type == null || switchGoverningExpression.Type.IsVoidType());

156var type = @case.Value.Type; 193Debug.Assert(inputExpression.Type is not null); 204Debug.Assert(inputExpression.Type is not null); 205return inputExpression.Type; 211if (switchGoverningExpression.Type == (object?)null || switchGoverningExpression.Type.IsVoidType())

120if (expressionOpt.Type is not null) 122CheckRestrictedTypeInAsyncMethod(originalBinder.ContainingMemberOrLambda, expressionOpt.Type, diagnostics, expressionOpt.Syntax); 189TypeSymbol? type = fromExpression ? expressionOpt!.Type : declarationTypeOpt; 302(fromExpression ? expressionOpt!.Type : declarationTypeOpt)!.ContainingModule != originalBinder.Compilation.SourceModule)

23Debug.Assert(collectionBuilderElementsPlaceholder.Type is not null); 27Debug.Assert(collectionBuilderElementsPlaceholder.Type.IsReadOnlySpan());

17NarrowedType.Equals(Value.Type, TypeCompareKind.AllIgnoreOptions) || 23NarrowedType.Equals(Value.Type, TypeCompareKind.AllIgnoreOptions));

73return arrayAccess.Expression.Type; 77return arrayAccess.Expression.Type;

193var f = ValueSetFactory.ForType(input.Type);

93return this.Type is null; 150=> Type?.GetITypeSymbol(TopLevelNullability.FlowState.ToAnnotation());

126return node.Type is { }; 131var type = node.Type; 156if (expr.Type is { } type) 274TypeSymbol? receiverType = expressionOpt.Type;

16Debug.Assert(InvokedExpression.Type is FunctionPointerTypeSymbol); 17return (FunctionPointerTypeSymbol)InvokedExpression.Type;

18Debug.Assert(Argument.Type is 33if (Argument.Type.Name == "Range") 62Debug.Assert(((NamedTypeSymbol)Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Equals(Expression.Type?.TryGetInlineArrayElementField()?.TypeWithAnnotations ?? default, TypeCompareKind.ConsiderEverything)); 70Debug.Assert(Type.Equals(Expression.Type?.TryGetInlineArrayElementField()?.Type, TypeCompareKind.ConsiderEverything));

111return expression?.Type?.IsErrorType() == true;

15var leftType = LeftOperand.Type; 22return nullableUnderlying.Equals(RightOperand.Type);

17NarrowedType.Equals(Value.Type, TypeCompareKind.AllIgnoreOptions)); 22NarrowedType.Equals(Value.Type, TypeCompareKind.AllIgnoreOptions));

649public static BoundDagTemp ForOriginalInput(BoundExpression expr) => new BoundDagTemp(expr.Syntax, expr.Type!, source: null);

21RoslynDebug.Assert(this.Type is { }, $"Unexpected null type in {this.GetType().Name}"); 22return this.Type; 155=> (Type is null) ? FormattableStringFactory.Create("stackalloc {0}[{1}]", ElementType, Count.WasCompilerGenerated ? null : Count.Syntax.ToString()) : base.Display; 161=> (Type is null) ? MessageID.IDS_FeatureSwitchExpression.Localize() : base.Display;

394expression.Type?.SetUnknownNullabilityForReferenceTypes();

54if (addressKind == AddressKind.ReadOnly && !expression.Type.IsValueType && peVerifyCompatEnabled) 68var type = expression.Type; 229if (receiver?.Type.IsValueType == true)

41Debug.Assert(!expression.Type.IsReferenceType); 42Debug.Assert(!expression.Type.IsValueType || expression.Type.IsNullableType()); 65Debug.Assert(expression.Type.IsValueType || IsAnyReadOnly(addressKind), "'this' is readonly in classes"); 67if (expression.Type.IsValueType) 102Debug.Assert(operand.Type.IsPointerType()); 134var type = expression.Type; 331var value = this.AllocateTemp(expression.Type, expression.Syntax); 372if (!receiver.Type.IsReferenceType) 389TreatLongsAsNative(index.Type.PrimitiveTypeCode); 403if (((ArrayTypeSymbol)arrayAccess.Expression.Type).IsSZArray) 411_builder.EmitArrayElementAddress(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), 504var receiverType = receiver.Type; 524EmitBox(receiver.Type, receiver.Syntax);

225TypeSymbol type = init.Type.EnumUnderlyingTypeOrSelf();

73Debug.Assert((operand.Type.IsArray()) && 142var fromType = conversion.Operand.Type; 245var fromType = conversion.Operand.Type; 261if (!conversion.Operand.Type.IsVerifierReference()) 263EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 293if (!conversion.Operand.Type.IsVerifierReference()) 295EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 321var fromType = conversion.Operand.Type; 368EmitSymbolToken(receiver.Type, receiver.Syntax); 374if (!receiver.Type.IsVerifierReference()) 376EmitBox(receiver.Type, receiver.Syntax);

52if ((object)expression.Type == null || 53(expression.Type.SpecialType != SpecialType.System_Decimal && 54!expression.Type.IsNullableType())) 56EmitConstantExpression(expression.Type, constantValue, used, expression.Syntax); 374EmitDefaultValue(node.Type, used, node.Syntax); 409var receiverType = receiver.Type; 522Debug.Assert(receiver.Type.IsNullableType()); 680EmitSymbolToken(expression.Operand.Type, expression.Operand.Syntax); 730Debug.Assert(refKind is RefKind.In || argument.Type.IsDynamic() || argument is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None }, "passing args byref should not clone them into temps"); 803EmitLoadIndirect(expression.Type, expression.Syntax); 812var meth = expression.MethodOpt ?? receiver.Type.DelegateInvokeMethod(); 1025if (((ArrayTypeSymbol)arrayAccess.Expression.Type).IsSZArray) 1112_builder.EmitArrayElementLoad(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Expression.Syntax); 1143if (!field.IsVolatile && !field.IsStatic && fieldAccess.ReceiverOpt.Type.IsVerifierValue() && field.RefKind == RefKind.None) 1182if (fieldType.IsValueType && (object)fieldType == (object)receiver.Type) 1238if (receiver == null || !receiver.Type.IsValueType) 1249EmitSymbolToken(receiver.Type, receiver.Syntax); 1278if (!receiver.Type.IsVerifierValue()) 1330var type = expr.Type; 1521if (receiver.Type.IsTypeParameter()) 1526Debug.Assert(receiver.Type.IsVerifierReference(), "this is not a reference"); 1656Debug.Assert(TypeSymbol.Equals(method.ContainingType, receiver.Type, TypeCompareKind.ConsiderEverything2)); 1691EmitSymbolToken(receiver.Type, receiver.Syntax); 1858var receiverType = receiver.Type; 1948var receiverType = receiver.Type; 2008Debug.Assert(receiver.Type.IsVerifierReference()); 2019Debug.Assert(receiver.Type.IsVerifierReference()); 2039EmitSymbolToken(receiver.Type, receiver.Syntax); 2054var receiverType = receiver.Type; 2117var receiverType = receiver.Type; 2635var rightType = right.Type; 2691if (left.Kind == BoundKind.ArrayAccess && left.Type.TypeKind == TypeKind.TypeParameter && !left.Type.IsValueType) 2715EmitSymbolToken(target.Type, target.Syntax); 3094assignmentOperator.Left.Type, 3141var arrayType = (ArrayTypeSymbol)array.Type; 3155EmitIndirectStore(expression.Type, expression.Syntax); 3160EmitIndirectStore(expression.Type, expression.Syntax); 3166EmitIndirectStore(expression.Type, expression.Syntax); 3178EmitIndirectStore(expression.Type, expression.Syntax); 3183EmitIndirectStore(expression.Type, expression.Syntax); 3429Debug.Assert((object)operand.Type != null); 3430if (!operand.Type.IsVerifierReference()) 3433EmitBox(operand.Type, operand.Syntax); 3456var operandType = operand.Type; 3950if (!(expr.Type.IsInterfaceType() || expr.Type.IsDelegateType())) 3952return expr.Type; 3997return expr.Type; 4068temp = AllocateTemp(ptrInvocation.InvokedExpression.Type, ptrInvocation.Syntax);

305Debug.Assert(binOp.Left.Type.SpecialType == SpecialType.System_Boolean); 306Debug.Assert(binOp.Right.Type.SpecialType == SpecialType.System_Boolean); 314Debug.Assert(binOp.Left.Type.SpecialType == SpecialType.System_Boolean); 315Debug.Assert(binOp.Right.Type.SpecialType == SpecialType.System_Boolean); 331Debug.Assert(binOp.Left.Type.SpecialType == SpecialType.System_Boolean); 332Debug.Assert(binOp.Right.Type.SpecialType == SpecialType.System_Boolean); 337Debug.Assert(binOp.Left.Type.SpecialType == SpecialType.System_Boolean); 338Debug.Assert(binOp.Right.Type.SpecialType == SpecialType.System_Boolean); 343Debug.Assert(binOp.Left.Type.SpecialType == SpecialType.System_Boolean); 344Debug.Assert(binOp.Right.Type.SpecialType == SpecialType.System_Boolean); 375if (comparand is BoundConversion { Type.SpecialType: SpecialType.System_Object, ConversionKind: ConversionKind.Boxing, Operand.Type: TypeParameterSymbol { AllowsRefLikeType: true } } && 458var comparandType = comparand.Type; 472var comparandType = comparand.Type; 496Debug.Assert(condition.Type.SpecialType == SpecialType.System_Boolean); 531Debug.Assert(condition.Type.SpecialType == SpecialType.System_Boolean); 654enumType = expression.Left.Type; 659Debug.Assert(TypeSymbol.Equals(expression.Left.Type, expression.Right.Type, TypeCompareKind.ConsiderEverything2)); 664enumType = expression.Right.Type; 786return IsUnsigned(Binder.GetEnumPromotedType(op.Left.Type.GetEnumUnderlyingType().SpecialType)); 789return IsUnsigned(Binder.GetEnumPromotedType(op.Right.Type.GetEnumUnderlyingType().SpecialType));

178var exprType = thrown.Type; 252var nonConstType = nonConstOp.Type; 530var receiverType = receiver.Type; 589Debug.Assert((object)operand.Type != null); 590if (!operand.Type.IsVerifierReference()) 593EmitBox(operand.Type, operand.Syntax); 610var conditionType = condition.Type; 925_module.Translate(expressionOpt.Type, boundReturnStatement.Syntax, _diagnostics.DiagnosticBag); 1150if (!exceptionSourceOpt.Type.IsVerifierReference()) 1152Debug.Assert(exceptionSourceOpt.Type.IsTypeParameter()); // only expecting type parameters 1154EmitSymbolToken(exceptionSourceOpt.Type, exceptionSourceOpt.Syntax); 1181Debug.Assert(!left.ReceiverOpt.Type.IsTypeParameter()); 1192var temp = AllocateTemp(exceptionSource.Type, exceptionSource.Syntax); 1259Debug.Assert((object)dispatch.Expression.Type != null); 1260Debug.Assert(dispatch.Expression.Type.IsValidV6SwitchGoverningType() || dispatch.Expression.Type.IsSpanOrReadOnlySpanChar()); 1263Debug.Assert(!dispatch.Expression.Type.IsNullableType()); 1282Debug.Assert((object)expression.Type != null && 1283(expression.Type.IsValidV6SwitchGoverningType() || expression.Type.IsSpanOrReadOnlySpanChar())); 1328temp = AllocateTemp(expression.Type, expression.Syntax); 1335expression.Type.SpecialType == SpecialType.System_String || expression.Type.IsSpanOrReadOnlySpanChar()); 1338if (expression.Type.SpecialType == SpecialType.System_String || expression.Type.IsSpanOrReadOnlySpanChar()) 1342this.EmitStringSwitchJumpTable(switchCaseLabels, fallThroughLabel, key, expression.Syntax, expression.Type); 1346this.EmitLengthBasedStringSwitchJumpTable(lengthBasedSwitchStringJumpTableOpt, fallThroughLabel, key, expression.Syntax, expression.Type); 1351_builder.EmitIntegerSwitchJumpTable(switchCaseLabels, fallThroughLabel, key, expression.Type.EnumUnderlyingTypeOrSelf().PrimitiveTypeCode, expression.Syntax);

609node.Type); 950right.Type.IsVerifierValue() && 973node.Left.Type.Equals(node.Right.Type, TypeCompareKind.AllIgnoreOptions) || 1029left.Type.Equals(((PointerTypeSymbol)right.Type).PointedAtType, TypeCompareKind.AllIgnoreOptions); 1046Debug.Assert(lhs.Type.IsValueType, "'this' is assignable only in structs"); 1204var receiverType = receiver.Type; 1239var receiverType = receiver.Type; 1357if (receiver.Type.IsTypeParameter()) 1366if (receiver.Type.IsValueType && ( 1669PushEvalStack(new BoundDefaultExpression(node.Syntax, node.Operand.Type), ExprContext.Value);

2298Debug.Assert(result is { Type: not null } || runtimeAwaitCall is { Type: not null }); 2299var returnType = result?.Type ?? runtimeAwaitCall!.Type;

2062type = boundExpr.Type; 2181convertedType = highestBoundExpr.Type; 2187convertedType = highestBoundExpr.Type; 2276static (TypeSymbol, NullabilityInfo) getTypeAndNullability(BoundExpression expr) => (expr.Type, expr.TopLevelNullability); 3388else if (expr.Type.IsDelegateType()) 3711var thisParam = GetThisParameter(boundNode.Type, containingType, containingMember, out resultKind); 3840symbols = OneOrMany.Create<Symbol>(new SynthesizedIntrinsicOperatorSymbol(unaryOperator.Operand.Type.StrippedType(), 3863TypeSymbol opType = increment.Operand.Type.StrippedType(); 3890((binaryOperator.Left.IsLiteralNull() && binaryOperator.Right.Type.IsNullableType()) || 3891(binaryOperator.Right.IsLiteralNull() && binaryOperator.Left.Type.IsNullableType())) && 3905binaryOperator.Left.Type, 3906binaryOperator.Right.Type, 4116TypeSymbol type = boundNode.Type; 4640if (node.SearchExtensions && receiver.Type is { } receiverType) 4782receiverType = call.ReceiverOpt.Type; 4786receiverType = call.Arguments[0].Type; 4816MethodSymbol reduced = method.ReduceExtensionMethod(receiver.Type, Compilation); 4831MethodSymbol reduced = method.ReduceExtensionMethod(receiverOpt.Type, Compilation);

1183return (bound as BoundTupleExpression)?.Type as NamedTypeSymbol;

360TypeSymbol system_Int32 = currentHashValue.Type!; 385NamedTypeSymbol constructedEqualityComparer = equalityComparerType.Construct(valueToHash.Type);

1381Translate(optArgList.Arguments[i].Type, syntaxNodeOpt, diagnostics));

644else if ((object)node.Type == null || node.Type.SpecialType != SpecialType.System_Boolean) 1723&& node.Type.SpecialType == SpecialType.System_Boolean) 2295(object)receiverOpt.Type != null && 2296!receiverOpt.Type.IsPrimitiveRecursiveStruct()); 2713&& conv.Operand.Type!.IsNonNullableValueType());

101if (!node.Expression.Type.IsValidV6SwitchGoverningType())

1078MayRequireTrackingReceiverType(receiver.Type); 1095MayRequireTrackingReceiverType(receiverOpt.Type) && 1096!receiverOpt.Type.IsPrimitiveRecursiveStruct(); 1334if (_emptyStructTypeCache.IsEmptyStructType(node.Type)) return true; 1547if (elementAccess.Expression.Type.HasInlineArrayAttribute(out int length) && 1551int slot = MakeMemberSlot(elementAccess.Expression, elementAccess.Expression.Type.TryGetInlineArrayElementField()); 2540if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type)

436expr.Type?.Equals(result.RValueType.Type, TypeCompareKind.AllIgnoreOptions) == true ? result.RValueType.Type : expr.Type); 574Debug.Assert(AreCloseEnough(placeholder.Type, result.RValueType.Type)); 2117receiver.Type is object; 2128TypeSymbol? nodeType = node.Type; 2164var operandType = operand.Type; 2182TypeSymbol.Equals(conv.Type, conv.Operand.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes): 3755Debug.Assert(AreCloseEnough(resultType.Type, node.Type)); 3983collectionBuilderElementsPlaceholder.Type, 4856SetAnalyzedNullability(node.ImplicitReceiverOpt, new VisitResult(node.ImplicitReceiverOpt.Type, NullableAnnotation.NotAnnotated, NullableFlowState.NotNull)); 4914SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull)); 4919var resultType = TypeWithState.Create(node.Type, NullableFlowState.NotNull); 4966Debug.Assert(node.Type is object); 4967if (IsEmptyStructType(node.Type)) 4972return GetOrCreatePlaceholderSlot(node, TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated)); 5290Debug.Assert(!node.Expression.Type!.IsValueType); 5304TypeSymbol.Equals(node.Indices[0].Type, compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.ConsiderEverything2)) 5623if (expr.Type is null) 5633TypeWithAnnotations.Create(expr.Type), 5647Debug.Assert(binary.Type!.SpecialType == SpecialType.System_Boolean); 5910var receiverType = conditional.Receiver.Type!; 5939if (slot > 0 && PossiblyNullableType(operand.Type)) 6009LearnFromNullTest(slot, expressionWithoutConversion.Type, ref state, markDependentSlotsNotNull: false); 6123node.Type?.ContainsErrorType() == true || 6124TypeSymbol.Equals(targetType.Type.GetNullableUnderlyingType(), node.Type, TypeCompareKind.AllIgnoreOptions)); 6130targetType = TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated); 6422if (slot > 0 && receiver.Type?.IsNullableType() == true) 6423slot = GetNullableOfTValueSlot(receiver.Type, slot, out _); 6467TypeSymbol? refResultType = node.Type?.SetUnknownNullabilityForReferenceTypes(); 6533resultType ??= node.Type?.SetUnknownNullabilityForReferenceTypes(); 7729TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState.Create(argument.Type, result.RValueType.State), argument as BoundConversion, argumentNoConversion); 7847completion(TypeWithAnnotations.Create(argument.Type)); 9052if (value.Type is null || value.Type.IsDynamic() || value.ConstantValueOpt != null) 9062value.Type.HasInlineArrayAttribute(out _) == true && 9063value.Type.TryGetInlineArrayElementField() is not null) 9203if (TypeAllowsConditionalState(targetType.Type) && TypeAllowsConditionalState(operand.Type)) 9351var tupleOpt = (NamedTypeSymbol?)node.Type; 10089if (canConvertNestedNullability && trackMembers && conversionOpt is { } && conversionOperand.Type.Equals(conversionOpt.Type, TypeCompareKind.AllIgnoreOptions)) 10825case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate }: 10939Debug.Assert(arg.Type is not null); 10940TypeSymbol argType = arg.Type; 10958Debug.Assert(arg.Type is not null); 10959TypeSymbol argType = arg.Type; 11139var rvalueResult = TypeWithState.Create(node.Type, NullableFlowState.NotNull); 11140var lvalueResult = TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated); 11638if (expr.Type is NamedTypeSymbol { IsTupleType: true } tupleType) 11751targetTypeOfOperandConversion = TypeWithAnnotations.Create(node.OperandConversion.Type, nullableAnnotation: NullableAnnotation.NotAnnotated); // https://github.com/dotnet/roslyn/issues/82636: Add coverage 11985SetResultType(node.Expression, TypeWithState.Create(node.Expression.Type, ResultType.State)); 12380if (collectionExpression.Type!.SpecialType == SpecialType.System_Collections_IEnumerable) 12383targetTypeWithAnnotations = TypeWithAnnotations.Create(collectionExpression.Type); 12385else if (ForEachLoopBinder.IsIEnumerableT(collectionExpression.Type.OriginalDefinition, isAsync, compilation)) 12632var type = TypeWithAnnotations.Create(node.Type); 13147SetResultType(node, TypeWithState.Create(node.Type, node.Type?.CanContainNull() != false && node.ConstantValueOpt?.IsNull == true ? NullableFlowState.MaybeDefault : NullableFlowState.NotNull)); 13324SetResultType(expression, TypeWithState.Create(expression.Type, default)); 13358Debug.Assert(receiverOpt.Type is null || AreCloseEnough(receiverOpt.Type, resultTypeSymbol)); 13446SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull)); 13479Debug.Assert(node.Type is null || node.Type.IsErrorType() || node.Type.IsRefLikeType); 13495SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull)); 13499Debug.Assert(node.Type is not null); 13500var type = VisitArrayInitialization(node.Type, initialization, node.HasErrors);

29LearnFromAnyNullPatterns(slot, expression.Type, pattern); 279var originalInputType = node.Expression.Type; 983var originalInputType = node.Expression.Type; 1053?? node.Type?.SetUnknownNullabilityForReferenceTypes();

221if (receiver.Type.IsStructType() && receiverSyntax.Span.OverlapsWith(RegionSpan))

474if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 502if (receiver != this.Receiver || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 534public new TypeSymbol Type => base.Type!; 571public new TypeSymbol Type => base.Type!; 600public new TypeSymbol? Type => base.Type; 635public new TypeSymbol Type => base.Type!; 672public new TypeSymbol Type => base.Type!; 708public new TypeSymbol Type => base.Type!; 745public new TypeSymbol Type => base.Type!; 781public new TypeSymbol Type => base.Type!; 816public new TypeSymbol Type => base.Type!; 851public new TypeSymbol Type => base.Type!; 886public new TypeSymbol Type => base.Type!; 921if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 952if (refKind != this.RefKind || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 980if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 1017if (resultKind != this.ResultKind || symbols != this.Symbols || childBoundNodes != this.ChildBoundNodes || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 1100public new TypeSymbol Type => base.Type!; 1148public new TypeSymbol Type => base.Type!; 1189public new TypeSymbol? Type => base.Type; 1226public new TypeSymbol Type => base.Type!; 1271public new TypeSymbol Type => base.Type!; 1311public new TypeSymbol Type => base.Type!; 1342public new TypeSymbol? Type => base.Type; 1385public new TypeSymbol Type => base.Type!; 1415public new TypeSymbol Type => base.Type!; 1450public new TypeSymbol Type => base.Type!; 1487public new TypeSymbol Type => base.Type!; 1521public new TypeSymbol Type => base.Type!; 1552public new TypeSymbol Type => base.Type!; 1583public new TypeSymbol Type => base.Type!; 1615public new TypeSymbol Type => base.Type!; 1647public new TypeSymbol Type => base.Type!; 1681public new TypeSymbol Type => base.Type!; 1741public new TypeSymbol Type => base.Type!; 1836public new TypeSymbol Type => base.Type!; 1876public new TypeSymbol Type => base.Type!; 1911public new TypeSymbol Type => base.Type!; 1949public new TypeSymbol Type => base.Type!; 1993if (leftOperand != this.LeftOperand || rightOperand != this.RightOperand || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 2020public new TypeSymbol? Type => base.Type; 2062public new TypeSymbol Type => base.Type!; 2100public new TypeSymbol Type => base.Type!; 2130public new TypeSymbol? Type => base.Type; 2160public new TypeSymbol Type => base.Type!; 2234public new TypeSymbol Type => base.Type!; 2274public new TypeSymbol Type => base.Type!; 2365public new TypeSymbol Type => base.Type!; 2407public new TypeSymbol Type => base.Type!; 2450public new TypeSymbol Type => base.Type!; 2487public new TypeSymbol Type => base.Type!; 2522public new TypeSymbol Type => base.Type!; 2560public new TypeSymbol Type => base.Type!; 2595public new TypeSymbol Type => base.Type!; 2630public new TypeSymbol Type => base.Type!; 2665public new TypeSymbol Type => base.Type!; 2700public new TypeSymbol Type => base.Type!; 2739public new TypeSymbol Type => base.Type!; 2781public new TypeSymbol Type => base.Type!; 2824public new TypeSymbol Type => base.Type!; 2855public new TypeSymbol? Type => base.Type; 2878public new TypeSymbol Type => base.Type!; 2912public new TypeSymbol Type => base.Type!; 2948public new TypeSymbol Type => base.Type!; 2982public new TypeSymbol Type => base.Type!; 3024public new TypeSymbol Type => base.Type!; 3063public new TypeSymbol Type => base.Type!; 3100public new TypeSymbol Type => base.Type!; 3129public new TypeSymbol? Type => base.Type; 3165public new TypeSymbol Type => base.Type!; 4377if (constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 4409public new TypeSymbol Type => base.Type!; 4445public new TypeSymbol Type => base.Type!; 4480public new TypeSymbol Type => base.Type!; 4515public new TypeSymbol Type => base.Type!; 4544public new TypeSymbol? Type => base.Type; 4589public new TypeSymbol Type => base.Type!; 4636public new TypeSymbol Type => base.Type!; 4669public new TypeSymbol Type => base.Type!; 4710public new TypeSymbol Type => base.Type!; 4855if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(label, this.Label) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 5018if (expression != this.Expression || switchArms != this.SwitchArms || reachabilityDecisionDag != this.ReachabilityDecisionDag || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(defaultLabel, this.DefaultLabel) || reportedNotExhaustive != this.ReportedNotExhaustive || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 5043public new TypeSymbol Type => base.Type!; 5820public new TypeSymbol? Type => base.Type; 5843if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 5869public new TypeSymbol Type => base.Type!; 5905public new TypeSymbol Type => base.Type!; 5942public new TypeSymbol Type => base.Type!; 5997public new TypeSymbol Type => base.Type!; 6031public new TypeSymbol Type => base.Type!; 6068public new TypeSymbol Type => base.Type!; 6111public new TypeSymbol Type => base.Type!; 6143public new TypeSymbol Type => base.Type!; 6260public new TypeSymbol Type => base.Type!; 6307public new TypeSymbol Type => base.Type!; 6349public new TypeSymbol Type => base.Type!; 6390public new TypeSymbol? Type => base.Type; 6430public new TypeSymbol Type => base.Type!; 6513public new TypeSymbol? Type => base.Type; 6587public new TypeSymbol Type => base.Type!; 6630if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 6708public new TypeSymbol? Type => base.Type; 6745if (sourceTuple != this.SourceTuple || wasTargetTyped != this.WasTargetTyped || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || inferredNamesOpt != this.InferredNamesOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 6844public new TypeSymbol Type => base.Type!; 6899public new TypeSymbol Type => base.Type!; 6952public new TypeSymbol Type => base.Type!; 7019public new TypeSymbol Type => base.Type!; 7058public new TypeSymbol Type => base.Type!; 7094public new TypeSymbol Type => base.Type!; 7127public new TypeSymbol Type => base.Type!; 7169public new TypeSymbol Type => base.Type!; 7232public new TypeSymbol Type => base.Type!; 7266public new TypeSymbol Type => base.Type!; 7297public new TypeSymbol? Type => base.Type; 7352if (!TypeSymbol.Equals(elementType, this.ElementType, TypeCompareKind.ConsiderEverything) || count != this.Count || initializerOpt != this.InitializerOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 7374public new TypeSymbol Type => base.Type!; 7408public new TypeSymbol Type => base.Type!; 7453public new TypeSymbol Type => base.Type!; 7487public new TypeSymbol Type => base.Type!; 7524public new TypeSymbol Type => base.Type!; 7568public new TypeSymbol Type => base.Type!; 7622public new TypeSymbol Type => base.Type!; 7665public new TypeSymbol Type => base.Type!; 7704public new TypeSymbol Type => base.Type!; 7746public new TypeSymbol? Type => base.Type; 7790public new TypeSymbol? Type => base.Type; 7828public new TypeSymbol Type => base.Type!; 7895public new TypeSymbol Type => base.Type!; 7946if (parts != this.Parts || constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 7974if (!interpolationData.Equals(this.InterpolationData) || parts != this.Parts || constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 8002if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 8032public new TypeSymbol Type => base.Type!; 8064public new TypeSymbol? Type => base.Type; 8119if (expression != this.Expression || pattern != this.Pattern || hasUnionMatching != this.HasUnionMatching || isNegated != this.IsNegated || reachabilityDecisionDag != this.ReachabilityDecisionDag || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(whenTrueLabel, this.WhenTrueLabel) || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(whenFalseLabel, this.WhenFalseLabel) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 8781public new TypeSymbol? Type => base.Type; 8818if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 8840public new TypeSymbol? Type => base.Type; 8913public new TypeSymbol? Type => base.Type; 9011public new TypeSymbol? Type => base.Type; 9044if (originalExpression != this.OriginalExpression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 9069public new TypeSymbol Type => base.Type!; 11138TypeSymbol? type = this.VisitType(node.Type); 11144TypeSymbol? type = this.VisitType(node.Type); 11205TypeSymbol? type = this.VisitType(node.Type); 11210TypeSymbol? type = this.VisitType(node.Type); 11216TypeSymbol? type = this.VisitType(node.Type); 11223TypeSymbol? type = this.VisitType(node.Type); 11419TypeSymbol? type = this.VisitType(node.Type); 11837TypeSymbol? type = this.VisitType(node.Type); 11911TypeSymbol? type = this.VisitType(node.Type); 11940TypeSymbol? type = this.VisitType(node.Type); 12093TypeSymbol? type = this.VisitType(node.Type); 12235TypeSymbol? type = this.VisitType(node.Type); 12258TypeSymbol? type = this.VisitType(node.Type); 12369TypeSymbol? type = this.VisitType(node.Type); 12480TypeSymbol? type = this.VisitType(node.Type); 12486TypeSymbol? type = this.VisitType(node.Type); 12491TypeSymbol? type = this.VisitType(node.Type); 12514TypeSymbol? type = this.VisitType(node.Type); 12649TypeSymbol? type = this.VisitType(node.Type); 12695TypeSymbol? type = this.VisitType(node.Type); 12769updatedNode = node.Update(receiver, node.Type); 12947updatedNode = node.Update(expression, node.Type); 12965updatedNode = node.Update(node.ResultKind, node.Symbols, childBoundNodes, node.Type); 13342updatedNode = node.Update(leftOperand, rightOperand, node.Type); 14143updatedNode = node.Update(expression, switchArms, reachabilityDecisionDag, node.DefaultLabel, node.ReportedNotExhaustive, node.Type); 14238updatedNode = node.Update(expression, node.Type); 14600updatedNode = node.Update(sourceTuple, node.WasTargetTyped, arguments, node.ArgumentNamesOpt, node.InferredNamesOpt, node.Type); 14883updatedNode = node.Update(elementType, count, initializerOpt, node.Type); 15121updatedNode = node.Update(parts, node.ConstantValueOpt, node.Type); 15138updatedNode = node.Update(node.InterpolationData, parts, node.ConstantValueOpt, node.Type); 15200updatedNode = node.Update(expression, pattern, node.HasUnionMatching, node.IsNegated, reachabilityDecisionDag, node.WhenTrueLabel, node.WhenFalseLabel, node.Type); 15351updatedNode = node.Update(expression, node.Type); 15447updatedNode = node.Update(originalExpression, node.Type); 15510new TreeDumperNode("type", node.Type, null), 15518new TreeDumperNode("type", node.Type, null), 15606new TreeDumperNode("type", node.Type, null), 15614new TreeDumperNode("type", node.Type, null), 15622new TreeDumperNode("type", node.Type, null), 15632new TreeDumperNode("type", node.Type, null), 15905new TreeDumperNode("type", node.Type, null), 16469new TreeDumperNode("type", node.Type, null), 16571new TreeDumperNode("type", node.Type, null), 16608new TreeDumperNode("type", node.Type, null), 16802new TreeDumperNode("type", node.Type, null), 17028new TreeDumperNode("type", node.Type, null), 17062new TreeDumperNode("type", node.Type, null), 17228new TreeDumperNode("type", node.Type, null), 17395new TreeDumperNode("type", node.Type, null), 17405new TreeDumperNode("type", node.Type, null), 17412new TreeDumperNode("type", node.Type, null), 17445new TreeDumperNode("type", node.Type, null), 17618new TreeDumperNode("type", node.Type, null), 17678new TreeDumperNode("type", node.Type, null),

739TypeSymbol rewrittenSourceType = rewrittenSource.Type; 1095this.returnValue = returnValue = new SynthesizedLocal(containingMethod, TypeWithAnnotations.Create(valueOpt.Type), SynthesizedLocalKind.AsyncMethodReturnValue, _syntaxOpt);

379var awaiterTemp = F.SynthesizedLocal(getAwaiter.Type, syntax: node.Syntax, kind: SynthesizedLocalKind.Awaiter); 494Debug.Assert(awaiterFieldType.IsObjectType() || TypeSymbol.Equals(awaiterFieldType, awaiterTempRef.Type, TypeCompareKind.AllIgnoreOptions)); 536Debug.Assert(awaiterFieldRef.Type.IsObjectType() || TypeSymbol.Equals(awaiterTemp.Type, awaiterFieldRef.Type, TypeCompareKind.AllIgnoreOptions));

237F.Call(parameterProxy, WellKnownMember.System_Threading_CancellationToken__Equals, F.Default(parameterProxy.Type)),

110var nodeType = node.Expression.Type;

585Debug.Assert(TypeSymbol.Equals(result.Type, frameType, TypeCompareKind.ConsiderEverything2)); 700BoundExpression assignment = new BoundAssignmentOperator(syntax, left, right, left.Type); 793var assignToProxy = new BoundAssignmentOperator(syntax, left, value, value.Type); 1254rewrittenExceptionSource.Type);

119if (!node.Type.Equals(result.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)) 305if (!TypeSymbol.Equals(index.Type, _int32Type, TypeCompareKind.ConsiderEverything2)) 307index = ConvertIndex(index, arg.Type, _int32Type); 323if (!TypeSymbol.Equals(index.Type, _int32Type, TypeCompareKind.ConsiderEverything2)) 325index = ConvertIndex(index, arg.Type, _int32Type); 374if (node.Operand.IsLiteralNull() && (object)node.Operand.Type == null) 500if ((object)left.Type == null && left.IsLiteralNull()) 502left = _bound.Default(right.Type); 504if ((object)right.Type == null && right.IsLiteralNull()) 506right = _bound.Default(left.Type); 517var promotedType = PromotedType(enumOperand.Type.StrippedType().GetEnumUnderlyingType()); 570return Convert(loweredOperand, operand.Type, promotedType, isChecked, false); 710var operandType = node.Operand.Type; 719? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 735if (node.Operand.Type.IsNullableType()) 737return Convert(Visit(node.Operand), node.Operand.Type, node.Type, node.Checked, node.ExplicitCastInCode); 744var e1 = Convert(Visit(node.Operand), node.Operand.Type, intermediate, node.Checked, false); 750return Convert(Visit(node.Operand), node.Operand.Type, node.Type, node.Checked, node.ExplicitCastInCode); 774else if (!receiver.Type.IsReferenceType) 818var d = node.Argument.Type as NamedTypeSymbol; 839if ((object)operand.Type == null && operand.ConstantValueOpt != null && operand.ConstantValueOpt.IsNull) 910var fromType = leftPlaceholder.Type; 1111Debug.Assert(args.Type.IsSZArray()); 1169if (node.ReceiverOpt?.Type.IsTypeParameter() == true && 1170!node.ReceiverOpt.Type.IsReferenceType) 1240var promotedType = PromotedType(arg.Type.StrippedType().GetEnumUnderlyingType()); 1242loweredArg = Convert(loweredArg, arg.Type, promotedType, isChecked, false); 1262_bound.Typeof(node.Type, _bound.WellKnownType(WellKnownType.System_Type)));

66if (e != null && (object)e.Type != null && e.Type.IsPointerOrFunctionPointer()) NoteUnsafe(e); 93!node.Indices[0].Type.SpecialType.CanOptimizeBehavior()) 404expr.Type is TypeSymbol type &&

228Debug.Assert(TypeSymbol.Equals(expr1.Type, expr2.Type, TypeCompareKind.ConsiderEverything2)); 329if (node.Left.Type.SpecialType == SpecialType.System_Object && !IsExplicitCast(node.Left) && !(node.Left.ConstantValueOpt != null && node.Left.ConstantValueOpt.IsNull) && ConvertedHasEqual(node.OperatorKind, node.Right, out t)) 334else if (node.Right.Type.SpecialType == SpecialType.System_Object && !IsExplicitCast(node.Right) && !(node.Right.ConstantValueOpt != null && node.Right.ConstantValueOpt.IsNull) && ConvertedHasEqual(node.OperatorKind, node.Left, out t)) 355NamedTypeSymbol nt = conv.Operand.Type as NamedTypeSymbol; 446if (!conversion.Operand.Type.SpecialType.IsIntegralType() || !conversion.Type.SpecialType.IsIntegralType()) 451if (!Binder.CheckConstantBounds(conversion.Operand.Type.SpecialType, constantValue, out _)) 453Error(ErrorCode.WRN_VacuousIntegralComp, tree, conversion.Operand.Type); 611TypeSymbol from = conv.Operand.Type; 769Error(ErrorCode.WRN_NubExprIsConstBool, node, always, node.Left.Type.GetNullableUnderlyingType(), node.Left.Type); 773Error(ErrorCode.WRN_NubExprIsConstBool, node, always, node.Right.Type.GetNullableUnderlyingType(), node.Right.Type); 817Error(node.OperatorKind.IsUserDefined() ? ErrorCode.WRN_NubExprIsConstBool2 : ErrorCode.WRN_NubExprIsConstBool, node, always, node.Left.Type.GetNullableUnderlyingType(), GetTypeForLiftedComparisonWarning(node.Right)); 821Error(node.OperatorKind.IsUserDefined() ? ErrorCode.WRN_NubExprIsConstBool2 : ErrorCode.WRN_NubExprIsConstBool, node, always, node.Right.Type.GetNullableUnderlyingType(), GetTypeForLiftedComparisonWarning(node.Left)); 857if ((object)node.Type == null || !node.Type.IsNullableType()) 873return type ?? node.Type;

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

35if ((object)expr.Type == null) 40if (expr.Type.IsDynamic()) 45if (!expr.Type.IsNullableType()) 80if ((object)expr.Type == null && expr.ConstantValueOpt == ConstantValue.Null) 85if ((object)expr.Type == null || !expr.Type.IsNullableType()) 132if (expr.Type.IsNullableType() && expr.Type.GetNullableUnderlyingType().SpecialType != SpecialType.System_Boolean)

52(object)expression.Type != null && 53!expression.Type.IsVoidType())

483rewrittenFilter = AddConditionSequencePoint(new BoundSequencePointExpression(filterClause, rewrittenFilter, rewrittenFilter.Type), filterClause, factory); 495return new BoundSequencePointExpression(original.Syntax, base.InstrumentSwitchExpressionArmExpression(original, rewrittenExpression, factory), rewrittenExpression.Type);

173Debug.Assert(condition.Type is not null); 182var local = factory.SynthesizedLocal(condition.Type, synthesizedVariableSyntax, kind: SynthesizedLocalKind.ConditionalBranchDiscriminator); 187new BoundSequencePointExpression(syntax: null!, expression: factory.Local(local), type: condition.Type) : 195condition.Type);

577Debug.Assert(invocation.Type is not null); 587if (invocation.Type.SpecialType != SpecialType.System_Void)

130if (arguments is [.., { Type: { } lastArgumentType } lastArgument] &&

308_methodValue = F.SynthesizedLocal(result.Type);

263TypeSymbol? type = node.Type; 284Debug.Assert(visited == null || visited.HasErrors || ReferenceEquals(visited.Type, node.Type) || 285visited.Type is { } && visited.Type.Equals(node.Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes) || 306type: visited.Type); 521Debug.Assert(value.Type is { } && (value.Type.Equals(placeholder.Type, TypeCompareKind.AllIgnoreOptions) || value.HasErrors)); 586Debug.Assert(node.Type is { }); 587return BadExpression(node.Syntax, node.Type, ImmutableArray.Create(node)); 840var indexType = VisitType(node.Indices[0].Type); 852Debug.Assert(node.Expression.Type is { TypeKind: TypeKind.Array }); 853var elementType = ((ArrayTypeSymbol)node.Expression.Type).ElementTypeWithAnnotations; 1074Debug.Assert(eventAccess.ReceiverOpt.Type is { }); 1075return !eventAccess.ReceiverOpt.Type.IsValueType || CanBePassedByReference(eventAccess.ReceiverOpt); 1085Debug.Assert(fieldAccess.ReceiverOpt.Type is { }); 1086return !fieldAccess.ReceiverOpt.Type.IsValueType || CanBePassedByReference(fieldAccess.ReceiverOpt); 1170Debug.Assert(Conversions.IsValidExtensionMethodThisArgConversion(this._compilation.Conversions.ClassifyConversionFromType(receiver.Type, extensionParameter.Type, isChecked: false, ref discardedUseSiteInfo)));

173receiver.Type?.IsReferenceType == false && 746if (input.Type.IsValidV6SwitchGoverningType() || input.Type.IsSpanOrReadOnlySpanChar()) 752bool isStringInput = input.Type.SpecialType == SpecialType.System_String; 753bool isSpanInput = input.Type.IsSpanChar(); 754bool isReadOnlySpanInput = input.Type.IsReadOnlySpanChar(); 783else if (input.Type.IsNativeIntegerType) 788switch (input.Type.SpecialType) 811throw ExceptionUtilities.UnexpectedValue(input.Type); 821var lessThanOrEqualOperator = input.Type.SpecialType switch 826_ => throw ExceptionUtilities.UnexpectedValue(input.Type.SpecialType) 829var cases = node.Cases.Sort(new CasesComparer(input.Type));

214TypeSymbol inputType = input.Type; 228Conversion conversion = _factory.Compilation.Conversions.ClassifyBuiltInConversion(inputType, output.Type, isChecked: false, ref useSiteInfo); 237inputType.GetNullableUnderlyingType().Equals(output.Type, TypeCompareKind.AllIgnoreOptions) && 369Debug.Assert(input.Type is { }); 373return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullNotEqual : BinaryOperatorKind.NotEqual); 380return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullEqual : BinaryOperatorKind.Equal); 383Debug.Assert(!input.Type.IsNullableType()); 387Debug.Assert(!input.Type.IsNullableType()); 388Debug.Assert(input.Type.IsValueType); 398Debug.Assert(!rewrittenExpr.Type.IsSpanOrReadOnlySpanChar()); 400if (rewrittenExpr.Type.IsPointerOrFunctionPointer()) 418if (value.IsString && input.Type.IsSpanOrReadOnlySpanChar()) 423TypeSymbol comparisonType = input.Type.EnumUnderlyingTypeOrSelf(); 432if (input.Type.SpecialType == SpecialType.System_Double && double.IsNaN(value.DoubleValue) || 433input.Type.SpecialType == SpecialType.System_Single && float.IsNaN(value.SingleValue)) 439BoundExpression literal = _localRewriter.MakeLiteral(syntax, value, input.Type); 440TypeSymbol comparisonType = input.Type.EnumUnderlyingTypeOrSelf(); 468var isReadOnlySpan = input.Type.IsReadOnlySpanChar(); 510Debug.Assert(output.Type is { }); 512testExpression = _factory.ObjectNotEqual(output, _factory.Null(output.Type)); 546Debug.Assert(loweredInput.Type is { }); 587if (loweredInput.Type.IsTupleType && 588!loweredInput.Type.OriginalDefinition.Equals(_factory.Compilation.GetWellKnownType(WellKnownType.System_ValueTuple_TRest)) &&

51ConstantValue constantValue = Binder.GetAsOperatorConstantResult(rewrittenOperand.Type, rewrittenType, conversion.Kind, rewrittenOperand.ConstantValueOpt); 88Debug.Assert(result.Type!.Equals(rewrittenType, TypeCompareKind.ConsiderEverything));

395TypeSymbol? exprType = rewrittenRight.Type;

340Debug.Assert(loweredLeft.Type is { }); 341Debug.Assert(loweredRight.Type is { }); 343return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredRight, loweredRight.Type); 346return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredLeft, loweredLeft.Type); 354Debug.Assert(loweredLeft.Type is { }); 355Debug.Assert(loweredRight.Type is { }); 357return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredRight, loweredRight.Type); 360return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredLeft, loweredLeft.Type); 368Debug.Assert(loweredLeft.Type is { }); 369Debug.Assert(loweredRight.Type is { }); 371return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredRight, loweredRight.Type); 374return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredLeft, loweredLeft.Type); 577Debug.Assert(loweredLeft.Type is { }); 578whenNullOpt = RewriteLiftedBinaryOperator(syntax, operatorKind, _factory.Default(loweredLeft.Type), loweredRight, type, method, constrainedToTypeOpt); 588type: result.Type! 771conversion = _compilation.Conversions.ClassifyConversionFromType(loweredLeft.Type, parameterType, isChecked: operatorKind.IsChecked(), ref useSiteInfo); 909Debug.Assert(expression.Type is { }); 913if (expression.Type.IsNullableType()) 919UnsafeGetNullableMethod(syntax, expression.Type, SpecialMember.System_Nullable_T_GetValueOrDefault)); 932Debug.Assert(expression.Type is { }); 936if (expression.Type.IsNullableType()) 946Debug.Assert(expression.Type is { }); 951UnsafeGetNullableMethod(syntax, expression.Type, SpecialMember.System_Nullable_T_get_HasValue)); 1634Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2)); 1635Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2)); 1708Debug.Assert(alwaysNull.Type is { }); 1709BoundExpression nullBool = new BoundDefaultExpression(syntax, alwaysNull.Type); 1721rewrittenType: alwaysNull.Type, 1748rewrittenType: alwaysNull.Type, 1750Debug.Assert(conditionalExpression.Type is { }); 1756type: conditionalExpression.Type); 1810rewrittenType: newNullBool.Type!, 1817type: conditionalExpression.Type!); 1897rewrittenType: alternative.Type!, 1905type: conditionalExpression.Type!); 2003return conditionalAccess.Update(conditionalAccess.Receiver, conditionalAccess.HasValueMethodOpt, whenNotNull, whenNull, conditionalAccess.Id, conditionalAccess.ForceCopyOfNullableValueType, whenNotNull.Type!); 2059Debug.Assert(loweredLeft.Type is { SpecialType: SpecialType.System_Decimal }); 2060Debug.Assert(loweredRight.Type is { SpecialType: SpecialType.System_Decimal }); 2093TypeSymbol? exprType = rewrittenExpr.Type; 2156Debug.Assert(loweredRight.Type is { }); 2157TypeSymbol rightType = loweredRight.Type; 2223Debug.Assert(loweredLeft.Type is { }); 2224TypeSymbol leftType = loweredLeft.Type; 2228Debug.Assert(loweredRight.Type is { }); 2229TypeSymbol rightType = loweredRight.Type; 2279Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2280loweredRight = MakeSizeOfMultiplication(loweredRight, (PointerTypeSymbol)loweredLeft.Type, kind.IsChecked()); 2284Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer }); 2285loweredLeft = MakeSizeOfMultiplication(loweredLeft, (PointerTypeSymbol)loweredRight.Type, kind.IsChecked()); 2324Debug.Assert(sizeOfExpression.Type is { SpecialType: SpecialType.System_Int32 }); 2334Debug.Assert(numericOperand.Type is { }); 2335var numericSpecialType = numericOperand.Type.SpecialType; 2471Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2472Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer }); 2475PointerTypeSymbol pointerType = (PointerTypeSymbol)loweredLeft.Type;

103if (module != null && receiver != null && receiver.Type is { }) 105var assembly = receiver.Type.ContainingAssembly; 122if (module != null && receiver is { Type: { } }) 124var assembly = receiver.Type.ContainingAssembly; 216var symbolForCompare = needToReduce ? ReducedExtensionMethodSymbol.Create(interceptor, receiverOpt!.Type, _compilation, out _) : interceptor; 290Debug.Assert(receiverOpt?.Type is not null); 296Debug.Assert(receiverOpt.Type.Equals(interceptor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions) 297|| (!receiverOpt.Type.IsReferenceType && interceptor.Parameters[0].Type.IsReferenceType)); 525Debug.Assert(rewrittenBoundCall.Type is not null); 534type: rewrittenBoundCall.Type); 687Debug.Assert(rewrittenReceiver.Type is { }); 707refKind = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter ? RefKind.Ref : RefKind.None; 711if (rewrittenReceiver.Type.IsReferenceType) 952Debug.Assert(rewrittenReceiver.Type is { }); 958if (rewrittenReceiver.Type.IsReferenceType || 1196optimized = CreateArrayEmptyCallIfAvailable(possibleParamsArray.Syntax, ((ArrayTypeSymbol)possibleParamsArray.Type!).ElementType); 1638Debug.Assert(value.Type is { }); 1667value.Type);

185Debug.Assert(singleSpread.Expression.Type is not null); 187if (!ShouldUseIEnumerableBulkAddMethod(singleSpread.Expression.Type, toListOfElementType.Parameters[0].Type, singleSpread.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 233Elements: [BoundCollectionExpressionSpreadElement { Expression: { Type: NamedTypeSymbol spreadType } expr }], 408Debug.Assert(list.Type is { }); 409Debug.Assert(list.Type.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_Collections_Generic_List_T), TypeCompareKind.AllIgnoreOptions)); 411var listToArray = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_Collections_Generic_List_T__ToArray)).AsMember((NamedTypeSymbol)list.Type); 771var spreadTypeOriginalDefinition = spreadExpression.Type!.OriginalDefinition; 777return _factory.Call(rewrittenSpreadExpression, listToArrayMethod.AsMember((NamedTypeSymbol)spreadExpression.Type!)); 787&& ShouldUseIEnumerableBulkAddMethod(spreadExpression.Type!, linqToArrayMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 794&& TryGetSpanConversion(spreadExpression.Type, writableOnly: false, out var asSpanMethod)) 796var spanType = CallAsSpanMethod(spreadExpression, asSpanMethod).Type!.OriginalDefinition; 801return _factory.Call(rewrittenSpreadExpression, toArrayMethod.AsMember((NamedTypeSymbol)rewrittenSpreadExpression.Type!)); 904Debug.Assert(arrayTemp.Type is ArrayTypeSymbol); 907var elementType = ((ArrayTypeSymbol)arrayTemp.Type).ElementType; 1035var type = expression.Type; 1102if (spreadOperandAsSpan.Type!.OriginalDefinition.Equals(this._compilation.GetWellKnownType(wellKnownSpanType)) 1141var spreadLength = _factory.Call(spreadOperandAsSpan, getLengthMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!)); 1142var targetSlice = _factory.Call(spanTemp, spanSliceMethod.AsMember((NamedTypeSymbol)spanTemp.Type!), indexTemp, spreadLength); 1143sideEffects.Add(_factory.Call(spreadOperandAsSpan, copyToMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!), targetSlice)); 1275Debug.Assert(spanTemp.Type is NamedTypeSymbol); 1278var elementType = ((NamedTypeSymbol)spanTemp.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 1345Debug.Assert(rewrittenSpreadOperand.Type is not null); 1350if (!ShouldUseIEnumerableBulkAddMethod(rewrittenSpreadOperand.Type, addRangeMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 1485_factory.Binary(BinaryOperatorKind.Addition, sum.Type!, sum, value); 1520if (convertedExpression.Operand.Type is ArrayTypeSymbol arrayType)

24Debug.Assert(TypeSymbol.Equals(node.Right.Type, node.Operator.RightType, TypeCompareKind.ConsiderEverything2)); 39Debug.Assert(node.LeftConversion is null || (node.Left.Type!.IsReferenceType && node.Operator.Method.IsExtensionBlockMember())); 53TypeSymbol? leftType = node.Left.Type; // type of the target 153Debug.Assert(rewrittenAssignment.Type is { }); 156var condition = _factory.Conditional(isEvent, invokeEventAccessor.ToExpression(), rewrittenAssignment, rewrittenAssignment.Type); 158rewrittenAssignment = new BoundSequence(node.Syntax, eventTemps.ToImmutableAndFree(), sequence.ToImmutableAndFree(), condition, condition.Type!); 165Debug.Assert(rewrittenAssignment.Type is { }); 173rewrittenAssignment.Type); 216Debug.Assert(node.Left.Type is { }); 228Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.Left.Type, TypeCompareKind.AllIgnoreOptions)); 235Debug.Assert(assignment.Type is { }); 236return new BoundSequence(syntax, [binaryResult.LocalSymbol], [assignmentToTemp], assignment, assignment.Type); 292Debug.Assert(rewrittenReceiver.Type is { }); 312var variableRepresentsLocation = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter; 315isKnownToReferToTempIfReferenceType = !variableRepresentsLocation || rewrittenReceiver.Type.IsValueType || 544indexerAccess.Argument.Type, 551throw ExceptionUtilities.UnexpectedValue(indexerAccess.Argument.Type); 572if (isDynamicAssignment || !IsInvariantArray(arrayAccess.Expression.Type)) 600Debug.Assert(receiver is { Type: { } }); 605else if (!receiver.Type.IsReferenceType) 610Debug.Assert(receiver.Type.IsReferenceType); 614Debug.Assert(rewrittenReceiver.Type is { }); 615if (rewrittenReceiver.Type.IsTypeParameter()) 753Debug.Assert(implicitIndexerAccess.Argument.Type!.Equals(_compilation.GetWellKnownType(WellKnownType.System_Index)) 754|| implicitIndexerAccess.Argument.Type!.Equals(_compilation.GetWellKnownType(WellKnownType.System_Range))); 783if (isDynamicAssignment || !IsInvariantArray(arrayAccess.Expression.Type)) 964var type = expression.Type; 980var type = expression.Type; 1036Debug.Assert(expression.Type is { }); 1037if (expression.Type.IsNullableType())

41Debug.Assert(node.AccessExpression.Type is { }); 44Debug.Assert(loweredReceiver.Type is { }); 45var receiverType = loweredReceiver.Type; 55var lowerToConditional = node.AccessExpression.Type.IsDynamic(); 120Debug.Assert(loweredAccessExpression.Type is { }); 126TypeSymbol accessExpressionType = loweredAccessExpression.Type; 149Debug.Assert(loweredReceiver.Type is { }); 154UnsafeGetNullableMethod(node.Syntax, loweredReceiver.Type, SpecialMember.System_Nullable_T_get_HasValue) : 205Debug.Assert(newtarget is { Type: { } }); 207if (newtarget.Type.IsNullableType())

82Debug.Assert(result.Type!.Equals(toType, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 94Debug.Assert(node.Type is not null); 95Debug.Assert(_compilation.IsReadOnlySpanType(node.Type)); 96var byteType = ((NamedTypeSymbol)node.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type; 111result = BadExpression(node.Syntax, node.Type, ImmutableArray<BoundExpression>.Empty); 115result = new BoundObjectCreationExpression(node.Syntax, ctor.AsMember((NamedTypeSymbol)node.Type), utf8Bytes, _factory.Literal(0), _factory.Literal(length)); 224Debug.Assert(rewrittenNode.Type is { }); 225var type = rewrittenNode.Type; 271Debug.Assert(result.Type is { } rt && rt.Equals(rewrittenType, TypeCompareKind.AllIgnoreOptions)); 290type: result.Type); 313@checked = @checked && NeedsCheckedConversionInExpressionTree(rewrittenOperand.Type, rewrittenType, explicitCastInCode); 319Debug.Assert(rewrittenOperand.Type is { }); 332if (_inExpressionLambda || !rewrittenOperand.Type.Equals(rewrittenType, TypeCompareKind.ConsiderEverything)) 433Debug.Assert(rewrittenOperand.Type is { }); 439if (rewrittenType.SpecialType == SpecialType.System_Decimal || rewrittenOperand.Type.SpecialType == SpecialType.System_Decimal) 441return RewriteDecimalConversion(syntax, rewrittenOperand, rewrittenOperand.Type, rewrittenType, @checked, conversion.Kind.IsImplicitConversion(), constantValueOpt); 448Debug.Assert(rewrittenOperand.Type is { }); 451Debug.Assert(rewrittenOperand.Type.Equals(rewrittenType, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 494Debug.Assert(rewrittenOperand.Type is { }); 504Debug.Assert(rewrittenOperand.Type.IsEnumType()); 505var underlyingTypeFrom = rewrittenOperand.Type.GetEnumUnderlyingType()!; 509else if (rewrittenOperand.Type.SpecialType == SpecialType.System_Decimal) 517var rewrittenNode = RewriteDecimalConversion(syntax, rewrittenOperand, rewrittenOperand.Type, underlyingTypeTo, @checked, isImplicit: false, constantValueOpt: constantValueOpt); 563(symbolOpt.IsAbstract || symbolOpt.IsVirtual) ? mg.ReceiverOpt?.Type : null, 602Debug.Assert(rewrittenOperand.Type is not null); 617createSpan = createSpan.Construct(rewrittenOperand.Type, spanType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type); 618_ = rewrittenOperand.Type.HasInlineArrayAttribute(out int length); 626var sourceType = rewrittenOperand.Type; 643Debug.Assert(rewrittenOperand.Type?.IsSZArray() == true); 670Debug.Assert(implicitOperator.ParameterTypesWithAnnotations[0].Type.Equals(rewrittenOperand.Type, TypeCompareKind.AllIgnoreOptions)); 704Debug.Assert(method.ParameterTypesWithAnnotations[0].Type.Equals(rewrittenOperand.Type, TypeCompareKind.AllIgnoreOptions)); 720Debug.Assert(rewrittenOperand.Type?.IsStringType() == true); 832Debug.Assert(rewrittenOperand.Type is { }); 834Conversion conversion = compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, isChecked: @checked, ref useSiteInfo); 840rewrittenOperand.Type.SpecialType != SpecialType.System_Decimal && 841rewrittenOperand.Type.SpecialType != SpecialType.System_DateTime) 847rewrittenOperand.Type, 893if (!TypeSymbol.Equals(rewrittenOperand.Type, conversion.BestUserDefinedConversionAnalysis.FromType, TypeCompareKind.ConsiderEverything2)) 903if (!TypeSymbol.Equals(rewrittenOperand.Type, conversion.Method.GetParameterType(0), TypeCompareKind.ConsiderEverything2)) 916Debug.Assert(rewrittenOperand.Type is { }); 917if (rewrittenOperand.Type.IsNullableType() && 918conversion.Method.GetParameterType(0).Equals(rewrittenOperand.Type.GetNullableUnderlyingType(), TypeCompareKind.AllIgnoreOptions) && 922userDefinedConversionRewrittenType = ((NamedTypeSymbol)rewrittenOperand.Type.OriginalDefinition).Construct(userDefinedConversionRewrittenType); 932if (!TypeSymbol.Equals(userDefined.Type, conversion.BestUserDefinedConversionAnalysis.ToType, TypeCompareKind.ConsiderEverything2)) 941if (!TypeSymbol.Equals(userDefined.Type, rewrittenType, TypeCompareKind.ConsiderEverything2)) 965if (!TypeSymbol.Equals(rewrittenOperand.Type, analysis.FromType, TypeCompareKind.AllIgnoreOptions)) 976Debug.Assert(TypeSymbol.Equals(rewrittenOperand.Type, analysis.Operator.GetParameterType(0), TypeCompareKind.AllIgnoreOptions)); 983Debug.Assert(TypeSymbol.Equals(rewrittenOperand.Type, analysis.ToType, TypeCompareKind.AllIgnoreOptions)); 985if (!TypeSymbol.Equals(rewrittenOperand.Type, rewrittenType, TypeCompareKind.AllIgnoreOptions)) 996Debug.Assert(TypeSymbol.Equals(rewrittenOperand.Type, rewrittenType, TypeCompareKind.AllIgnoreOptions)); 1020Debug.Assert(rewrittenOperand.Type is { }); 1024var tupleTypeSymbol = (NamedTypeSymbol)rewrittenOperand.Type; 1061Debug.Assert(expression.Type is { }); 1062if (!expression.Type.IsNullableType()) 1074when convertedArgument.Type!.Equals(expression.Type.StrippedType(), TypeCompareKind.AllIgnoreOptions): 1079when underlying.Length == 1 && underlying[0].Kind == ConversionKind.ImplicitTuple && !convertedArgument.Type!.IsNullableType(): 1115TypeSymbol? rewrittenOperandType = rewrittenOperand.Type; 1165Debug.Assert(rewrittenOperand.Type is { }); 1166TypeSymbol rewrittenOperandType = rewrittenOperand.Type; 1380Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2)); 1381Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2)); 1413Debug.Assert(rewrittenOperand.Type is { }); 1414if (rewrittenOperand.Type.IsNullableType()) 1417if (parameterType.Equals(rewrittenOperand.Type.GetNullableUnderlyingType(), TypeCompareKind.AllIgnoreOptions) && 1433if ((rewrittenOperand.Type.IsArray()) && _compilation.IsReadOnlySpanType(rewrittenType)) 1445Debug.Assert(TypeSymbol.Equals(result.Type, rewrittenType, TypeCompareKind.ConsiderEverything2)); 1468Debug.Assert(rewrittenOperand.Type is { }); 1471Conversion conv = TryMakeConversion(syntax, conversion, rewrittenOperand.Type, rewrittenType, @checked: @checked); 1485Debug.Assert(rewrittenOperand.Type.IsNullableType()); 1558Debug.Assert(rewrittenOperand.Type is { }); 1560Debug.Assert(conversion.Method.Parameters[0].Type.Equals(rewrittenOperand.Type, TypeCompareKind.AllIgnoreOptions)); 1588Debug.Assert(rewrittenOperand.Type is { }); 1591TypeSymbol source = rewrittenOperand.Type; 1814Debug.Assert(operand.Type is { }); 1815return RewriteDecimalConversionCore(syntax, operand, operand.Type, toType, isImplicit, constantValueOpt);

42Debug.Assert(left.Type is { }); 43BoundExpression? result = RewriteDeconstruction(lhsTargets, conversion, left.Type, right, isUsed); 247Debug.Assert(leftTarget is { Type: { } }); 264var tupleType = NamedTypeSymbol.CreateTuple(locationOpt: null, elementTypesWithAnnotations: builder!.SelectAsArray(e => TypeWithAnnotations.Create(e.Type)), 318Debug.Assert(right.Type is { }); 319if (right.Type.IsTupleType) 337Debug.Assert(expression.Type is { }); 338Debug.Assert(expression.Type.IsTupleType); 339var tupleType = expression.Type; 462Debug.Assert(variable.Type is { }); 464effects, temps, isDynamicAssignment: variable.Type.IsDynamic());

188return new BoundSequence(syntax, tempSymbols, sideEffects.ToImmutableAndFree(), marshalCall, marshalCall.Type!);

209else if (fixedCollectionInitializer.Expression.Type is { SpecialType: SpecialType.System_String }) 213else if (fixedCollectionInitializer.Expression.Type is { TypeKind: TypeKind.Array }) 241Debug.Assert(initializerExpr.Type is { TypeKind: TypeKind.Pointer }); 247TypeSymbol initializerType = ((PointerTypeSymbol)initializerExpr.Type).PointedAtType; 308Debug.Assert(initializerExpr.Type is { }); 310var initializerType = initializerExpr.Type; 444TypeSymbol? initializerType = initializerExpr.Type; 513TypeSymbol? initializerType = initializerExpr.Type;

43TypeSymbol? nodeExpressionType = collectionExpression.Type; 507Debug.Assert(receiver.Type is { }); 508if (!receiver.Type.IsReferenceType && method.ContainingType.IsInterface) 608NamedTypeSymbol? collectionType = (NamedTypeSymbol?)collectionExpression.Type; 747Debug.Assert(rewrittenExpression.Type is not null); 876Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 904Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 908ArrayTypeSymbol arrayType = (ArrayTypeSymbol)collectionExpression.Type; 1025Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 1053Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 1057ArrayTypeSymbol arrayType = (ArrayTypeSymbol)collectionExpression.Type;

24operand = new BoundDefaultExpression(operand.Syntax, operand.Type!.GetNullableUnderlyingType()); 72Debug.Assert(TypeSymbol.Equals(targetNullableType.GetNullableUnderlyingType(), underlyingValue.Type, TypeCompareKind.AllIgnoreOptions));

122Debug.Assert(oldNode.Type is not null); 123Debug.Assert(oldNode.Type.Equals(type, TypeCompareKind.ConsiderEverything)); 219Debug.Assert(call.Type is not null); 234call.Type); 243Debug.Assert(node.Expression.Type is object); 244Debug.Assert(node.Argument.Type is object); 259_ = node.Expression.Type.HasInlineArrayAttribute(out int length); 261if (node.Argument.Type.SpecialType == SpecialType.System_Int32) 269if (TypeSymbol.Equals(node.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.AllIgnoreOptions)) 281Debug.Assert(TypeSymbol.Equals(node.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.AllIgnoreOptions)); 386Debug.Assert(node.Expression.Type is object); 398return createSpan.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type); 403Debug.Assert(node.Expression.Type is object); 404Debug.Assert(index.Type?.SpecialType == SpecialType.System_Int32); 406var intType = (NamedTypeSymbol)index.Type; 425elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type); 444elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type); 499node.Argument.Type, 508node.Argument.Type, 546node.Argument.Type, 562Debug.Assert(receiver.Type is { }); 568receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref); 626Debug.Assert(integerArgument.Type!.SpecialType == SpecialType.System_Int32); 723Debug.Assert(loweredExpr.Type!.SpecialType == SpecialType.System_Int32); 734Debug.Assert(loweredExpr.Type!.SpecialType == SpecialType.System_Int32); 741loweredExpr.Type, 774unloweredExpr.Type, 782Debug.Assert(hatExpression.Operand is { Type: { SpecialType: SpecialType.System_Int32 } }); 786else if (unloweredExpr is BoundConversion { Operand: { Type: { SpecialType: SpecialType.System_Int32 } } operand }) 795arguments[0] is { Type.SpecialType: SpecialType.System_Int32, ConstantValueOpt.Value: int _ and >= 0 } index && 796arguments[1] is { Type.SpecialType: SpecialType.System_Boolean, ConstantValueOpt.Value: bool fromEnd }) 839node.Argument.Type, 865Debug.Assert(receiver.Type is { }); 871receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref);

48var operandType = rewrittenOperand.Type;

119Debug.Assert(node.Type is { SpecialType: SpecialType.System_Boolean }); 120LocalSymbol resultTemp = _factory.SynthesizedLocal(node.Type, node.Syntax, kind: SynthesizedLocalKind.LoweringTemp); 175if (test.Type?.IsErrorType() != false) 178Debug.Assert(test.Type.SpecialType == SpecialType.System_Boolean);

20return MakeLiteral(node.Syntax, node.ConstantValueOpt, node.Type, oldNodeOpt: node);

30TypeSymbol? argumentType = rewrittenArgument.Type;

16Debug.Assert(node.Type is { }); 20Debug.Assert(node.LeftOperand.Type is { }); 24Debug.Assert(transformedLHS.Type is { }); 41Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.LeftOperand.Type, TypeCompareKind.AllIgnoreOptions)); 49Debug.Assert(assignment.Type is { }); 50assignment = new BoundSequence(syntax, [rightResult.LocalSymbol], [assignmentToTemp], assignment, assignment.Type); 58var leftPlaceholder = new BoundValuePlaceholder(lhsRead.Syntax, lhsRead.Type); 59BoundExpression conditionalExpression = MakeNullCoalescingOperator(syntax, lhsRead, assignment, leftPlaceholder: leftPlaceholder, leftConversion: leftPlaceholder, BoundNullCoalescingOperatorResultKind.LeftType, node.LeftOperand.Type); 60Debug.Assert(conditionalExpression.Type is { }); 69conditionalExpression.Type); 76Debug.Assert(node.LeftOperand.Type.IsNullableType()); 85leftOperand.Type, 93leftOperand.Type, 125Debug.Assert(transformedLHS.Type.GetNullableUnderlyingType().Equals(tmp.Type.StrippedType(), TypeCompareKind.AllIgnoreOptions)); 128Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.LeftOperand.Type, TypeCompareKind.AllIgnoreOptions)); 133MakeConversionNode(tmp, transformedLHS.Type, @checked: false, markAsChecked: true),

35Debug.Assert(rewrittenRight.Type is { }); 36Debug.Assert(rewrittenRight.Type.Equals(rewrittenResultType, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 42Debug.Assert(rewrittenLeft.Type is { }); 59var isUnconstrainedTypeParameter = rewrittenLeft.Type is { IsReferenceType: false, IsValueType: false }; 90Debug.Assert(rewrittenLeft.Type is { }); 91if (rewrittenLeft.Type.IsReferenceType && 110if (whenNullOpt.Type.IsNullableType()) 115if (whenNullOpt.IsDefaultValue() && whenNullOpt.Type.SpecialType != SpecialType.System_Decimal) 133if (rewrittenLeft.Type.IsNullableType() && 134rewrittenRight.Type.Equals(rewrittenLeft.Type.GetNullableUnderlyingType(), TypeCompareKind.AllIgnoreOptions)) 140TryGetNullableMethod(rewrittenLeft.Syntax, rewrittenLeft.Type, SpecialMember.System_Nullable_T_GetValueOrDefault, out MethodSymbol? getValueOrDefault, isOptional: true)) 147TryGetNullableMethod(rewrittenLeft.Syntax, rewrittenLeft.Type, SpecialMember.System_Nullable_T_GetValueOrDefaultDefaultValue, out MethodSymbol? getValueOrDefaultDefaultValue, isOptional: true)) 167Debug.Assert(convertedLeft.HasErrors || convertedLeft.Type!.Equals(rewrittenResultType, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 180Debug.Assert(conditionalExpression.Type!.Equals(rewrittenResultType, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 238Debug.Assert(rewrittenLeft.Type is { }); 242TypeSymbol rewrittenLeftType = rewrittenLeft.Type; 250var conversionTakesNullableType = leftPlaceholder?.Type?.IsNullableType() == true;

81Debug.Assert(TypeSymbol.Equals(rewrittenObjectCreation.Type, ((NamedTypeSymbol)node.Type).ComImportCoClass, TypeCompareKind.ConsiderEverything2)); 99rewrittenObjectCreation = new BoundDefaultExpression(rewrittenObjectCreation.Syntax, rewrittenObjectCreation.Type!); 114Debug.Assert(TypeSymbol.Equals(rewrittenObjectCreation.Type, ((NamedTypeSymbol)node.Type).ComImportCoClass, TypeCompareKind.ConsiderEverything2)); 135Debug.Assert(receiver.Type!.Equals(type, TypeCompareKind.ConsiderEverything)); 325return MakeExpressionWithInitializer(node.Syntax, rewrittenNewT, node.InitializerExpressionOpt, rewrittenNewT.Type!);

400Debug.Assert(assignment.Type.IsDynamic() || TypeSymbol.Equals(rewrittenAccess.Type, assignment.Type, TypeCompareKind.AllIgnoreOptions)); 454Debug.Assert(TypeSymbol.Equals(rangeArgument.Type, _compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.ConsiderEverything)); 472Debug.Assert(TypeSymbol.Equals(rewrittenAccess.Type, assignment.Type, TypeCompareKind.AllIgnoreOptions)); 505Debug.Assert(TypeSymbol.Equals(rewrittenAccess.Type, assignment.Type, TypeCompareKind.AllIgnoreOptions)); 517if (TypeSymbol.Equals(implicitIndexer.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.ConsiderEverything)) 539Debug.Assert(TypeSymbol.Equals(rewrittenAccess.Type, assignment.Type, TypeCompareKind.AllIgnoreOptions)); 700Debug.Assert(_compilation.Conversions.ClassifyConversionFromType(rewrittenReceiver.Type, memberSymbol.ContainingType, isChecked: false, ref discardedUseSiteInfo).IsImplicit || 701(memberSymbol.IsExtensionBlockMember() && !memberSymbol.IsStatic && ConversionsBase.IsValidExtensionMethodThisArgConversion(_compilation.Conversions.ClassifyConversionFromType(rewrittenReceiver.Type, memberSymbol.ContainingType.ExtensionParameter!.Type, isChecked: false, ref discardedUseSiteInfo))) || 702_compilation.Conversions.HasImplicitConversionToOrImplementsVarianceCompatibleInterface(rewrittenReceiver.Type, memberSymbol.ContainingType, ref discardedUseSiteInfo, out _));

46Debug.Assert(rewrittenExpression.Type is { }); 47Debug.Assert(rewrittenIndex.Type is { }); 48switch (rewrittenIndex.Type.SpecialType) 63throw ExceptionUtilities.UnexpectedValue(rewrittenIndex.Type.SpecialType); 78rewrittenExpression.Type,

37if (rewrittenReceiverOpt is { Type: { TypeKind: TypeKind.Array } } && !isLeftOfAssignment) 39var asArrayType = (ArrayTypeSymbol)rewrittenReceiverOpt.Type;

56Debug.Assert(operand.Type is { }); 60operand = new BoundDefaultExpression(operand.Syntax, operand.Type.GetNullableUnderlyingType()); 65Debug.Assert(operand.Type is { }); 67if (operand.Type.IsNullableType()) 80Debug.Assert(left?.Type?.IsNullableType() == true || right?.Type?.IsNullableType() == true); 131Debug.Assert(tempOperand.Type is { }); 133if (tempOperand.Type.IsNullableType())

28var type = stackAllocNode.Type;

75Debug.Assert(visitedArguments.All(arg => arg.Type!.SpecialType is SpecialType.System_String or SpecialType.System_Char or SpecialType.System_Object)); 107var argumentType = arg.Type; 153bool needsImplicitConversionFromStringToSpan = visitedArguments.Any(arg => arg.Type is { SpecialType: SpecialType.System_String }); 289if (argument is BoundConversion { ConversionKind: ConversionKind.Boxing, Type.SpecialType: SpecialType.System_Object, Operand: { Type.SpecialType: SpecialType.System_Char } operand }) 305else if (argument is BoundNullCoalescingOperator { LeftOperand: { Type.SpecialType: SpecialType.System_String } left, RightOperand: BoundLiteral { ConstantValueOpt: { IsString: true, RopeValue.IsEmpty: true } } }) 444if (call is { Arguments: [], ReceiverOpt.Type: NamedTypeSymbol { SpecialType: SpecialType.System_Char } charType, Method: { Name: "ToString" } method } 521Debug.Assert(arg.Type is not null); 523if (arg.Type.SpecialType == SpecialType.System_Char) 552Debug.Assert(arg.HasAnyErrors || arg.Type.SpecialType == SpecialType.System_String); 652Debug.Assert(expr.Type is not null); 655if (expr.Type.IsStringType()) 667if (expr.Type.IsValueType && !expr.Type.IsTypeParameter()) 669var type = (NamedTypeSymbol)expr.Type; 690expr.Type.SpecialType.CanOptimizeBehavior() && 706bool callWithoutCopy = expr.Type.IsReferenceType || 708(structToStringMethod == null && !expr.Type.IsTypeParameter()) || 712if (expr.Type.IsValueType) 716expr = new BoundPassByCopy(syntax, expr, expr.Type); 748new BoundConditionalReceiver(syntax, currentConditionalAccessID, expr.Type),

107if (actualCall.Type!.IsDynamic()) 145Debug.Assert(node.Type is { SpecialType: SpecialType.System_String }); // if target-converted, we should not get here. 149return LowerPartsToString(data, node.Parts, node.Syntax, node.Type); 183_factory.Binary(BinaryOperatorKind.StringConcatenation, node.Type, result, part); 194Debug.Assert(result.Type is not null); 195Debug.Assert(result.Type.SpecialType == SpecialType.System_String || result.Type.IsErrorType()); 196var placeholder = new BoundValuePlaceholder(result.Syntax, result.Type); 197result = new BoundNullCoalescingOperator(result.Syntax, result, _factory.StringLiteral(""), leftPlaceholder: placeholder, leftConversion: placeholder, BoundNullCoalescingOperatorResultKind.LeftType, @checked: false, result.Type) { WasCompilerGenerated = true };

54Debug.Assert(expr.Type == (object?)o.Type || expr.Type is { } && expr.Type.Equals(o.Type, TypeCompareKind.AllIgnoreOptions)); 91expr.Type is { } exprType && exprType.IsNullableType() && exprType.StrippedType().Equals(o.Type, TypeCompareKind.AllIgnoreOptions): 108Debug.Assert(expr.Type is { }); 109var destElementTypes = expr.Type.TupleElementTypesWithAnnotations; 111Debug.Assert(boundConversion.Operand.Type is { }); 112var srcElementFields = boundConversion.Operand.Type.TupleElements; 130ImmutableArray<bool>.Empty, expr.Type, expr.HasErrors); 166ImmutableArray<bool>.Empty, tuple.Type, tuple.HasErrors); 209return new BoundLiteral(expr.Syntax, ConstantValue.Null, expr.Type); 361isNullable = !(expr is BoundTupleExpression) && expr.Type is { } && expr.Type.IsNullableType(); 373Debug.Assert(expr.Type is { }); 376value = new BoundDefaultExpression(expr.Syntax, expr.Type.StrippedType()); 403Debug.Assert(expr.Type is { }); 409when expr.Type.IsNullableType() && o.Type is { } && o.Type.IsNullableType() && !underlying[0].IsUserDefined: // https://github.com/dotnet/roslyn/issues/82636: Confirm union conversions don't need special handling here 443expr.Type is { } exprType && exprType.IsNullableType() && o.Type is { } && o.Type.IsNullableType() && nested[0] is { IsTupleConversion: true } tupleConversion: 445Debug.Assert(expr.Type is { }); 448Debug.Assert(operand.Type is { }); 449var types = expr.Type.GetNullableUnderlyingType().TupleElementTypesWithAnnotations; 450int tupleCardinality = operand.Type.TupleElementTypesWithAnnotations.Length; 466type: expr.Type, 529Debug.Assert(tuple.Type is { IsTupleType: true }); 535return MakeTupleFieldAccessAndReportUseSiteDiagnostics(tuple, tuple.Syntax, tuple.Type.TupleElements[i]);

39Debug.Assert(node.Type is { }); 40return MakeTupleCreationExpression(node.Syntax, (NamedTypeSymbol)node.Type, rewrittenArguments);

133var underlyingType = loweredOperand.Type.GetEnumUnderlyingType(); 277Debug.Assert(result.Type is { }); 286type: result.Type 329Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2)); 330Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2)); 408Debug.Assert(node.OperandConversion is null || (node.Operand.Type!.IsReferenceType && node.MethodOpt.IsExtensionBlockMember())); 421TypeSymbol? operandType = node.Operand.Type; //type of the variable being incremented 458TypeSymbol? operandType = left.Type; //type of the variable being incremented 467Debug.Assert(TypeSymbol.Equals(operandType, transformedLHS.Type, TypeCompareKind.AllIgnoreOptions)); 586TypeSymbol? operandType = transformedLHS.Type; //type of the variable being incremented 660Debug.Assert(boundTemp.Type is not null); 686type: boundTemp.Type); 699Debug.Assert(boundTemp.Type is not null); 702Debug.Assert(tempValue.Type is { }); 711tempValue.Type); 725type: boundTemp.Type); 931Debug.Assert(binaryOperand.Type is { TypeKind: TypeKind.Pointer }); 932Debug.Assert(boundOne.Type is { SpecialType: SpecialType.System_Int32 }); 933return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null, constrainedToTypeOpt: null); 985Debug.Assert(operand.Type is { SpecialType: SpecialType.System_Decimal }); 992Debug.Assert(operand.Type is { } && operand.Type.IsNullableType() && operand.Type.GetNullableUnderlyingType().SpecialType == SpecialType.System_Decimal); 996MethodSymbol getValueOrDefault = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T_GetValueOrDefault); 997MethodSymbol ctor = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T__ctor); 1008BoundExpression alternative = new BoundDefaultExpression(syntax, operand.Type); 1011return RewriteConditionalOperator(syntax, condition, consequence, alternative, ConstantValue.NotAvailable, operand.Type, isRef: false);

149Debug.Assert(rewrittenExpression.Type is { }); 150TypeSymbol expressionType = rewrittenExpression.Type;

545Debug.Assert(loweredReceiver.Type is { }); 546if (!loweredReceiver.Type.IsValueType) 830var argType = boundArgument.Type; 909result[j++] = receiver.Type ?? systemObjectType; 915result[j++] = arguments[i].Type ?? systemObjectType; 921result[j++] = right.Type ?? systemObjectType;

45: base(SpillSequenceBuilderKind, syntax, value?.Type) 174new TreeDumperNode("type", this.Type, null) 337if (refKind != RefKind.None || expression.Type?.IsRefLikeOrAllowsRefLikeType() == true) 380if (refKind != RefKind.None || expression.Type.IsReferenceType) 497if (expression.Type.IsVoidType() || sideEffectsOnly) 1047Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType); 1056var receiverType = receiver.Type; 1087if (!receiver.Type.IsReferenceType && LocalRewriter.CanBePassedByReference(receiver)) 1089result = receiver.Type.IsReadOnly ? RefKind.In : RefKind.Ref; 1160Debug.Assert(condition.Type.SpecialType == SpecialType.System_Boolean); 1163var tmp = _F.SynthesizedLocal(condition.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax); 1210type: node.Type)); 1267_F.ObjectEqual(_F.Local(tmp), _F.Null(left.Type)), 1299if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None) 1319var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill); 1323var isNotClass = _F.IsNotNullReference(_F.Default(receiver.Type)); 1491return UpdateExpression(builder, node.Update(operand, node.Type)); 1535return UpdateExpression(builder, node.Update(expression, node.Type));

42var field = this.HoistedField.AsMember((NamedTypeSymbol)frame.Type); 60var field = this.HoistedField.AsMember((NamedTypeSymbol)frame.Type);

152Debug.Assert(thisProxyReplacement.Type is not null); 153this.cachedThis = F.SynthesizedLocal(thisProxyReplacement.Type, syntax: F.Syntax, kind: SynthesizedLocalKind.FrameCache);

98Debug.Assert(TypeSymbol.Equals(type, replacement.Type, TypeCompareKind.ConsiderEverything2)); 284Debug.Assert(_reportedError || isFieldAccessOfStruct || expr.Type!.IsTypeParameter()); 303Debug.Assert(expr.Type is not null); 304var hoistedSymbol = createHoistedSymbol(expr.Type, arg, assignedLocal);

267Debug.Assert(receiverOpt is null || receiverOpt.Type is { } && 268receiverOpt.Type.GetMembers(propertySym.Name).OfType<PropertySymbol>().Single() == propertySym); 279Debug.Assert(!(receiverOpt is { Type: ArrayTypeSymbol { IsSZArray: true } } && 439Debug.Assert(left.Type is { } && right.Type is { } && 440(left.Type.Equals(right.Type, TypeCompareKind.AllIgnoreOptions) || 442right.Type.IsErrorType() || left.Type.IsErrorType())); 444var assignment = new BoundAssignmentOperator(syntax, left, right, isRef, left.Type, hasErrors) { WasCompilerGenerated = wasCompilerGenerated }; 569var conversion = Compilation.Conversions.ClassifyConversionFromType(expression.Type, CurrentFunction.ReturnType, isChecked: false, ref useSiteInfo); 658Conversion c = Compilation.Conversions.ClassifyBuiltInConversion(operand.Type, type, isChecked: false, ref discardedUseSiteInfo); 664Debug.Assert(left.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean); 665Debug.Assert(right.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean); 671Debug.Assert(left.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean); 672Debug.Assert(right.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean); 691if (value.Type is TypeParameterSymbol { AllowsRefLikeType: true }) 801switch (input.Type) 810throw ExceptionUtilities.UnexpectedValue(input.Type); 935Debug.Assert(valueTypeReceiver.Type is { }); 936Debug.Assert(TypeSymbol.Equals(valueTypeReceiver.Type, referenceTypeReceiver.Type, TypeCompareKind.ConsiderEverything2)); 937return new BoundComplexConditionalReceiver(Syntax, valueTypeReceiver, referenceTypeReceiver, valueTypeReceiver.Type) { WasCompilerGenerated = true }; 942Debug.Assert(left.Type!.Equals(right.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes) || left.Type.IsErrorType()); 943Debug.Assert(left.Type.IsReferenceType); 945return new BoundNullCoalescingOperator(Syntax, left, right, leftPlaceholder: null, leftConversion: null, BoundNullCoalescingOperatorResultKind.LeftType, @checked: false, left.Type) { WasCompilerGenerated = true }; 1053Debug.Assert(result.Type is { }); 1054var resultType = type ?? result.Type; 1060Debug.Assert(result.Type is { }); 1064: new BoundSequence(Syntax, locals, sideEffects, result, result.Type) { WasCompilerGenerated = true }; 1069Debug.Assert(result.Type is { }); 1070return new BoundSpillSequence(Syntax, locals, sideEffects, result, result.Type) { WasCompilerGenerated = true }; 1099Debug.Assert(ex.Type is { SpecialType: CodeAnalysis.SpecialType.System_Int32 }); 1194Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1200Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1201int rank = ((ArrayTypeSymbol)array.Type).Rank; 1213Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1214return new BoundArrayAccess(Syntax, array, indices, ((ArrayTypeSymbol)array.Type).ElementType); 1519if (TypeSymbol.Equals(type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1529Debug.Assert(arg.Type is { }); 1616return new BoundCatchBlock(Syntax, ImmutableArray<LocalSymbol>.Empty, source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false); 1636Debug.Assert(expression is { Type: { SpecialType: CodeAnalysis.SpecialType.System_Boolean } }); 1637return new BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.BoolLogicalNegation, expression, null, null, constrainedToTypeOpt: null, LookupResultKind.Viable, expression.Type); 1657Debug.Assert(argument.Type is { }); 1690var type = argument.Type; 1760TypeSymbol exprType = rewrittenExpr.Type; 1814LocalRewriter.UnsafeGetNullableMethod(syntax, expression.Type, CodeAnalysis.SpecialMember.System_Nullable_T_get_HasValue, Compilation, Diagnostics)); 1878return conditionalAccess.Update(conditionalAccess.Receiver, conditionalAccess.HasValueMethodOpt, whenNotNull, whenNull, conditionalAccess.Id, conditionalAccess.ForceCopyOfNullableValueType, whenNotNull.Type);

1122if (boundOperand.Kind == BoundKind.ConvertedTupleLiteral && TypeSymbol.Equals(boundOperand.Type, boundConversion.Type, TypeCompareKind.ConsiderEverything2)) 1143!TypeSymbol.Equals(nestedConversion.Type, nestedOperand.Type, TypeCompareKind.ConsiderEverything2)) 1662boundNullCoalescingOperator.Type.Equals(boundNullCoalescingOperator.LeftOperand.Type?.StrippedType(), TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes))

348argumentKind = argument.Type?.IsSZArray() == true ? ArgumentKind.ParamArray : ArgumentKind.ParamCollection;

165if (!(expression.Type is null) && expression.Type.IsStringType())

1001conversion.IsIdentity && parameterType.SpecialType == SpecialType.System_Object && defaultExpression.Type.IsDynamic()) 1015(object)defaultExpression.Type != null && 1016defaultExpression.Type.SpecialType == SpecialType.System_String || 1026else if (((conversion.IsNullable && !defaultExpression.Type.IsNullableType()) || 1027(conversion.IsObjectCreation && convertedExpression.Type.IsNullableType())) && 1044(defaultExpression.IsImplicitObjectCreation() ? convertedExpression.Type.StrippedType() : defaultExpression.Type), parameterSyntax.Identifier.ValueText);

662return TypeWithAnnotations.Create(initializerOpt?.Type);

554if ((object)initializerOpt.Type != null && !initializerOpt.Type.IsErrorType()) 556type = TypeWithAnnotations.Create(initializerOpt.Type);

208Debug.Assert(value.Type is not null); 209if (value.Type.IsValueType) 216else if (!value.Type.IsRestrictedType())

432public override TypeWithAnnotations ReturnTypeWithAnnotations => TypeWithAnnotations.Create(_userEntryPointInvocation.Type);

1736Assert.Equal(SpecialType.System_Collections_IEnumerable, boundNode.Expression.Type.SpecialType); 1737Assert.Equal(SymbolKind.ArrayType, ((BoundConversion)boundNode.Expression).Operand.Type.Kind); 1774Assert.Equal(SpecialType.System_String, boundNode.Expression.Type.SpecialType); 1775Assert.Equal(SpecialType.System_String, ((BoundConversion)boundNode.Expression).Operand.Type.SpecialType); 1818Assert.Equal("Enumerable", boundNode.Expression.Type.ToTestDisplayString()); 1819Assert.Equal("Enumerable", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 1862Assert.Equal("Enumerable", boundNode.Expression.Type.ToTestDisplayString()); 1863Assert.Equal("Enumerable", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 1895Assert.Equal("System.Collections.IEnumerable", boundNode.Expression.Type.ToTestDisplayString()); 1896Assert.Equal("System.Collections.IEnumerable", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 1935Assert.Equal("System.Collections.Generic.IEnumerable<System.Int32>", boundNode.Expression.Type.ToTestDisplayString()); 1936Assert.Equal("Enumerable", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 1977Assert.Equal(SpecialType.System_Collections_IEnumerable, boundNode.Expression.Type.SpecialType); 1978Assert.Equal("Enumerable", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 2016Assert.Equal(SpecialType.System_Collections_IEnumerable, boundNode.Expression.Type.SpecialType); 2017Assert.Equal("Enumerable", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 2197Assert.Equal(SpecialType.System_Collections_IEnumerable, boundNode.Expression.Type.SpecialType); 2198Assert.Equal(TypeKind.Dynamic, ((BoundConversion)boundNode.Expression).Operand.Type.TypeKind); 2230Assert.Equal(SpecialType.System_Collections_IEnumerable, boundNode.Expression.Type.SpecialType); 2231Assert.Equal(SymbolKind.DynamicType, ((BoundConversion)boundNode.Expression).Operand.Type.Kind); 2271Assert.Equal("Enumerable<T>", boundNode.Expression.Type.ToTestDisplayString()); 2272Assert.Equal("Enumerable<T>", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 2355Assert.Equal("Enumerable<T>", boundNode.Expression.Type.ToTestDisplayString()); 2356Assert.Equal("Enumerable<T>", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 2402Assert.Equal("Enumerable", boundNode.Expression.Type.ToTestDisplayString()); 2403Assert.Equal("Enumerable", ((BoundConversion)boundNode.Expression).Operand.Type.ToTestDisplayString()); 3754Assert.Equal("C", info.GetEnumeratorInfo.Arguments.Single().Type.ToTestDisplayString()); 3764Assert.Equal("C", boundNode.Expression.Type.ToDisplayString());