411this.Type = type; 417this.Type = type;

879RoslynDebug.Assert(expression.Type is object); 880return expression.Type;

701Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter()); 728if ((expr.ConstantValueOpt != null) || (expr.Type.GetSpecialTypeSafe() == SpecialType.System_Void)) 918getItemOrSliceHelper = getItemOrSliceHelper.AsMember(getItemOrSliceHelper.ContainingType.Construct(ImmutableArray.Create(elementAccess.Expression.Type.TryGetInlineArrayElementField().TypeWithAnnotations))); 989indices[0].Type, 1022Error(diagnostics, ErrorCode.ERR_BadSKunknown, expr.Syntax, expr.Type, MessageID.IDS_SK_TYPE.Localize()); 1661&& receiver?.Type?.IsValueType == true; 1893if (receiver is BoundObjectOrCollectionValuePlaceholder && receiver.Type.IsAnonymousType) 2077if (methodInfo.Method?.RequiresInstanceReceiver == true && receiver?.Type?.IsRefLikeOrAllowsRefLikeType() == true) 2289if (receiver?.Type?.IsRefLikeOrAllowsRefLikeType() == true) 2386Debug.Assert(receiver.Type is { }); 2391Debug.Assert(receiver is not BoundValuePlaceholderBase && method is not null && receiver.Type?.IsReferenceType == false); 2396receiver = new BoundCapturedReceiverPlaceholder(receiver.Syntax, receiver, _localScopeDepth, receiver.Type).MakeCompilerGenerated(); 2511if (receiver.Type is TypeParameterSymbol typeParameter) 3404Debug.Assert(expr.Type is not null); 3436if (expr.Type?.GetSpecialTypeSafe() == SpecialType.System_Void) 3737Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter()); 3752if (expr.Type?.GetSpecialTypeSafe() == SpecialType.System_Void) 4145if (expr.Type?.IsRefLikeOrAllowsRefLikeType() != true) 4623RoslynDebug.Assert(false, $"{expr.Kind} expression of {expr.Type} type"); 4830Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter()); 4851if (expr.Type?.IsRefLikeOrAllowsRefLikeType() != true) 4916Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeStackAlloc : ErrorCode.ERR_EscapeStackAlloc, node, expr.Type); 5225Error(diagnostics, ErrorCode.ERR_CollectionExpressionEscape, node, expr.Type); 5431RoslynDebug.Assert(false, $"{expr.Kind} expression of {expr.Type} type"); 5604TypeWithAnnotations.Create(elementAccess.Expression.Type), 5644TypeWithAnnotations.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;

839RoslynDebug.Assert(node.Type is object); 840var typedConstantKind = node.Type.GetAttributeParameterTypedConstantKind(_binder.Compilation); 893return new TypedConstant(spread.Expression.Type, TypedConstantKind.Error, value: null); 912var operandType = operand.Type; 1015var type = node.Type;

31var placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type); 84var type = expression.Type; 262Debug.Assert(TypeSymbol.Equals(expression.Type, getAwaiterArgument.Type, TypeCompareKind.ConsiderEverything)); 286TypeSymbol awaiterType = getAwaiter.Type!; 287return GetIsCompletedProperty(awaiterType, node, expression.Type!, diagnostics, out isCompleted) 289&& GetGetResultMethod(getAwaiter, node, expression.Type!, diagnostics, out getResult, out getAwaiterGetResultCall); 303if (expression.Type is null) 325RoslynDebug.Assert(expression.Type is object); 326if (expression.Type.IsVoidType()) 342Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type); 353Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type); 437var awaiterType = awaiterExpression.Type;

75else if (source.Type is not null && filterConversion(conversion)) 77var placeholder2 = new BoundValuePlaceholder(source.Syntax, source.Type); 120RoslynDebug.Assert(source.Type is object); 124if (!isCast && source.Type.Equals(destination, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)) 211TypeSymbol? type = source.Type; 255Debug.Assert(source.Type is null); 281source.Type is { } sourceType && 322switch (source.Type?.IsNullableType()) 327new BoundValuePlaceholder(source.Syntax, source.Type.GetNullableUnderlyingType()), 352else if (source.Type?.IsNullableType() == true) 356new BoundValuePlaceholder(source.Syntax, source.Type.GetNullableUnderlyingType()), 373if (source.Type?.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) == true && 446Debug.Assert(source.Type is { }); 448FieldSymbol? elementField = source.Type.TryGetInlineArrayElementField(); 481CheckInlineArrayTypeIsSupported(syntax, source.Type, elementField.Type, diagnostics); 485Debug.Assert(source.Type is not null); 494if (source.Type is ArrayTypeSymbol) 505if (source.Type.IsSpan()) 509TryFindImplicitOperatorFromSpan(source.Type.OriginalDefinition, destination.OriginalDefinition), 510source.Type.OriginalDefinition, 517if (source.Type.IsSpan() || source.Type.IsReadOnlySpan()) 520if (NeedsSpanCastUp(source.Type, destination)) 525TypeSymbol sourceForCastUp = source.Type.IsSpan() 527: source.Type.OriginalDefinition; 538.Construct([((NamedTypeSymbol)source.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0]]) 544if (source.Type.IsStringType()) 722unconvertedSource.Type, 1358Debug.Assert(methodGroup.ReceiverOpt.Type is not null); 1428diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, syntax, methodGroup.ReceiverOpt.Type); 1478TypeSymbol? receiverType = methodGroup.ReceiverOpt.Type; 1987Debug.Assert(targetTyped || destination.IsErrorType() || destination.Equals(source.Type, TypeCompareKind.ConsiderEverything)); 2006source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.ReachabilityDecisionDag, 2092conversion: Conversions.ClassifyStandardConversion(convertedOperand.Type, conversionParameterType, ref useSiteInfo), 2697RoslynDebug.Assert(receiverOpt.Type is object); 2699diagnostics.Add(ErrorCode.ERR_QueryNoProvider, node.Location, receiverOpt.Type, memberSymbol.Name); 2717RoslynDebug.Assert(receiverOpt.Type is object); 2718diagnostics.Add(ErrorCode.ERR_BadAwaitArg, node.Location, receiverOpt.Type); 2853(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!; 226else if ((object?)boundRHS.Type == null) 481TypeSymbol? mergedType = element.Type; 569typesWithAnnotationsBuilder.Add(TypeWithAnnotations.Create(value.Type)); 622if (receiver.Type?.IsDynamic() ?? false) 718if (receiver.Type?.IsErrorType() == false) 720Error(diagnostics, ErrorCode.ERR_MissingDeconstruct, rightSyntax, receiver.Type!, numParameters);

204TypeSymbol resultType = expr.Type; 297var commonType = expr.Type; 369case BoundStackAllocArrayCreation { Type: null } boundStackAlloc: 570TypeSymbol exprType = expr.Type; 1044if (boundArgument.Type?.SpecialType == SpecialType.System_Void) 1054var elementTypeWithAnnotations = TypeWithAnnotations.Create(boundArgument.Type); 1253if ((object)argument.Type != null && argument.Type.IsRestrictedType()) 1256Error(diagnostics, ErrorCode.ERR_MethodArgCantBeRefAny, node, argument.Type); 1682type: expression.Type, 2590(object)operand.Type != null && 2591!operand.Type.IsNullableType() && 2592!TypeSymbol.Equals(targetType.GetNullableUnderlyingType(), operand.Type, TypeCompareKind.ConsiderEverything2)) 2613if ((object)boundOperand.Type != null && boundOperand.Type.IsNullableType()) 2692if (left?.Type.IsNullableType() == true || right?.Type.IsNullableType() == true) 2720if (boundOperand.Type?.IsNullableType() == true) 2812SymbolDistinguisher distinguisher1 = new SymbolDistinguisher(this.Compilation, operand.Type, targetType); 2861case BoundKind.UnconvertedConditionalOperator when operand.Type is null: 2862case BoundKind.UnconvertedSwitchExpression when operand.Type is null: 2886Debug.Assert((object)operand.Type != null); 2887SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, operand.Type, targetType); 2928Debug.Assert((object)operand.Type != null && !operand.Type.IsNullableType()); 2934var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3786Debug.Assert(receiver!.Type is not null); 3788placeholderType = receiver.Type; 4225if ((object)boundExpression.Type == null || !boundExpression.Type.IsErrorType()) 4309Debug.Assert(init.Type.IsErrorType()); 4719if (constantValue == null || constantValue.IsBad || expression.Type.SpecialType != SpecialType.System_Int32) 4742var type = expression.Type.SpecialType; 5294Debug.Assert(expression.Type is { }); 5296var expressionPlaceholder = new BoundCollectionExpressionSpreadExpressionPlaceholder(syntax.Expression, expression.Type); 5309_ = expression.Type.HasInlineArrayAttribute(out int length); 5439else if ((object)argument.Type == null) 5451else if (argument.Type.TypeKind == TypeKind.Delegate) 5453var sourceDelegate = (NamedTypeSymbol)argument.Type; 5457if (ReportDelegateInvokeUseSiteDiagnostic(diagnostics, argument.Type, node: node)) 5738Debug.Assert((object)boundLeft.Type != null); 5747type: boundLeft.Type, 6035type: boundMember.Type, 6449({ Type: null } or BoundLiteral or BoundUnconvertedInterpolatedString or BoundBinaryOperator { IsUnconvertedInterpolatedStringAddition: true }) && 7520var leftType = boundValue.Type; 7528if (TypeSymbol.Equals(boundType.Type, leftType, TypeCompareKind.AllIgnoreOptions)) 7560TypeSymbol.Equals(BindNamespaceOrType(id, BindingDiagnosticBag.Discarded).Type, type, TypeCompareKind.AllIgnoreOptions); 7664TypeSymbol leftType = boundLeft.Type; 7702leftType = boundLeft.Type; 7945Error(diagnostics, ErrorCode.WRN_DotOnDefault, node, boundLeft.Type); 8072var leftType = boundLeft.Type; 8210if ((object)boundLeft.Type == null) 8219Error(diagnostics, ErrorCode.ERR_NoSuchMember, name, boundLeft.Type, plainName); 8221else if (WouldUsingSystemFindExtension(boundLeft.Type, plainName)) 8223Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtensionNeedUsing, name, boundLeft.Type, plainName, "System"); 8227Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtension, name, boundLeft.Type, plainName); 8517Debug.Assert(left.Type is not null); 8518Debug.Assert(!left.Type.IsDynamic()); 8610Debug.Assert(left.Type is not null); 8646firstResult = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics); 8672result = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics); 8691result = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics); 8719TypeSymbol? receiverType = left.Type; 8926TypeSymbol receiverType = receiver.Type; 9097if (receiverOpt is { Type: TypeParameterSymbol { AllowsRefLikeType: true } } && 9139bool isUsableAsField = eventSymbol.HasAssociatedField && this.IsAccessible(eventSymbol.AssociatedField, ref useSiteInfo, (receiver != null) ? receiver.Type : null); 9379if ((object)expr.Type == null) 9400expr.Type.HasInlineArrayAttribute(out int length) && expr.Type.TryGetPossiblyUnsupportedByLanguageInlineArrayElementField() is FieldSymbol elementField) 9412Debug.Assert(expr.Type.TryGetInlineArrayElementField() is not null); 9432{ Code: (int)ErrorCode.ERR_BadIndexLHS, Arguments: [TypeSymbol type] } && type.Equals(expr.Type, TypeCompareKind.ConsiderEverything)) 9559CheckInlineArrayTypeIsSupported(node, expr.Type, elementField.Type, diagnostics); 9610if (TypeSymbol.Equals(convertedIndex.Type, compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.AllIgnoreOptions)) 9658Debug.Assert((object)expr.Type != null); 9661var exprType = expr.Type; 9704var arrayType = (ArrayTypeSymbol)expr.Type; 9751var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(expr.Syntax, isEquivalentToThisReference: expr.IsEquivalentToThisReference, expr.Type) { WasCompilerGenerated = true }; 9915Debug.Assert(expr.Type.IsPointerType()); 9916PointerTypeSymbol pointerType = (PointerTypeSymbol)expr.Type; 9962Debug.Assert((object)expr.Type != null); 9968this.LookupMembersWithFallback(lookupResult, expr.Type, WellKnownMemberNames.Indexer, arity: 0, useSiteInfo: ref useSiteInfo, options: lookupOptions); 10289Debug.Assert(receiver.Type is not null); 10296var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(receiver.Syntax, isEquivalentToThisReference: receiver.IsEquivalentToThisReference, receiver.Type) { WasCompilerGenerated = true }; 10305Debug.Assert(indexerOrSliceAccess.Type is not null); 10315indexerOrSliceAccess.Type); 10528Debug.Assert(receiverPlaceholder.Type is not null); 10529if (TryLookupLengthOrCount(syntax, receiverPlaceholder.Type, lookupResult, out var lengthOrCountProperty, diagnostics)) 10895if (m.ReduceExtensionMethod(receiver.Type, Compilation) is { } reduced) 11058Debug.Assert(node.ReceiverOpt!.Type is not null); // extensions are only considered on member access 11091var substituted = (MethodSymbol?)extensionMember.GetReducedAndFilteredSymbol(typeArguments, receiver.Type, Compilation, checkFullyInferred: true); 11340var receiverType = receiver.Type; 11349var accessType = access.Type; 11485var receiverType = receiver.Type; 11516var 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));

278else if ((object)argument.Type == null && !argument.HasAnyErrors) 289else if (argument.Type.IsVoidType()) 343if ((object)boundExpression.Type != null && boundExpression.Type.IsDynamic()) 371else if (boundExpression.Type?.Kind == SymbolKind.FunctionPointerType) 558Debug.Assert(receiver.Type is not null); 559Error(diagnostics, ErrorCode.ERR_CannotDynamicInvokeOnExpression, receiver.Syntax, receiver.Type); 610Debug.Assert((object?)arg.Type != null); 613Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, arg.Type); 833Debug.Assert(methodGroup.ReceiverOpt != null && (object)methodGroup.ReceiverOpt.Type != null); 835Error(diagnostics, ErrorCode.ERR_BadArgTypeDynamicExtension, syntax, methodGroup.ReceiverOpt.Type, methodGroup.Name); 1062if (!call.HasAnyErrors && call.ReceiverOpt != null && (object)call.ReceiverOpt.Type != null && !call.Method.GetIsNewExtensionMember()) 1067if (call.ReceiverOpt.Type.IsRestrictedType() && !call.Method.ContainingType.IsInterface && !TypeSymbol.Equals(call.Method.ContainingType, call.ReceiverOpt.Type, TypeCompareKind.ConsiderEverything2)) 1069SymbolDistinguisher distinguisher = new SymbolDistinguisher(compilation, call.ReceiverOpt.Type, call.Method.ContainingType); 1085(object)dynInvoke.Expression.Type != null && 1086dynInvoke.Expression.Type.IsRestrictedType()) 1090Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, dynInvoke.Expression.Syntax, dynInvoke.Expression.Type); 1175case BoundUnconvertedSwitchExpression { Type: { } naturalType } switchExpr: 1394if (receiver is BoundValuePlaceholderBase || receiver?.Type is null or { IsReferenceType: true }) 1842receiver.Type.IsValueType && 1905!(d.Arguments is [ParameterSymbol shadowedParameter] && shadowedParameter.Type.Equals(typeOrValue.Data.ValueExpression.Type, TypeCompareKind.AllIgnoreOptions))) // If the type and the name match, we would resolve to the same type rather than a value at the end. 1960var type = expr.Type as NamedTypeSymbol; 2014var methodContainer = (object)receiver != null && (object)receiver.Type != null 2015? receiver.Type 2255var methodContainer = expr.Type ?? this.ContainingType; 2449RoslynDebug.Assert(boundExpression.Type is FunctionPointerTypeSymbol); 2451var funcPtr = (FunctionPointerTypeSymbol)boundExpression.Type;

65Debug.Assert(left.Type is { }); 68var placeholder = new BoundValuePlaceholder(right.Syntax, left.HasDynamicType() ? left.Type : right.Type).MakeCompilerGenerated(); 69var finalDynamicConversion = this.Compilation.Conversions.ClassifyConversionFromExpression(placeholder, left.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 71var conversion = (BoundConversion)CreateConversion(node, placeholder, finalDynamicConversion, isCast: true, conversionGroupOpt: null, left.Type, diagnostics); 80left.Type, 81right.Type, 89left.Type, 209var leftType = left.Type; 264var leftType = left.Type; 492TypeSymbol type = operand.Type; 520Debug.Assert((object)left.Type != null && left.Type.IsDynamic() || (object)right.Type != null && right.Type.IsDynamic()); 544Error(diagnostics, ErrorCode.ERR_InvalidDynamicCondition, node.Left, left.Type, kind == BinaryOperatorKind.LogicalAnd ? "false" : "true"); 550Debug.Assert(left.Type is not TypeParameterSymbol); 666TypeSymbol leftType = left.Type; 667TypeSymbol rightType = right.Type; 702Debug.Assert(right.Type.SpecialType == SpecialType.System_String); 703var stringConstant = FoldBinaryOperator(node, BinaryOperatorKind.StringConcatenation, left, right, right.Type, diagnostics); 704return new BoundBinaryOperator(node, BinaryOperatorKind.StringConcatenation, BoundBinaryOperator.UncommonData.UnconvertedInterpolatedStringAddition(stringConstant), LookupResultKind.Empty, left, right, right.Type); 871TypeSymbol leftType = left.Type; 872TypeSymbol rightType = right.Type; 961(object)left.Type != null && left.Type.TypeKind == TypeKind.Delegate) 965var conversion = this.Conversions.ClassifyConversionFromExpression(right, left.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 967GenerateImplicitConversionError(diagnostics, right.Syntax, conversion, right, left.Type); 989case (BoundKind.DefaultLiteral, _) when right.Type is TypeParameterSymbol: 990Debug.Assert(!right.Type.IsReferenceType); 991Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnUnconstrainedDefault, node, operatorToken.Text, right.Type); 993case (_, BoundKind.DefaultLiteral) when left.Type is TypeParameterSymbol: 994Debug.Assert(!left.Type.IsReferenceType); 995Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnUnconstrainedDefault, node, operatorToken.Text, left.Type); 1014case LookupResultKind.OverloadResolutionFailure when operatorToken.Kind() is SyntaxKind.PlusToken && isReadOnlySpanOfByte(left.Type) && isReadOnlySpanOfByte(right.Type): 1081if ((object)left.Type != null && left.Type.SpecialType == SpecialType.System_Boolean && 1082(object)right.Type != null && right.Type.SpecialType == SpecialType.System_Boolean) 1084var constantValue = FoldBinaryOperator(node, kind | BinaryOperatorKind.Bool, left, right, left.Type, diagnostics); 1088resultKind: LookupResultKind.Viable, left, right, type: left.Type, hasErrors: constantValue != null && constantValue.IsBad); 1159var operandPlaceholder = new BoundValuePlaceholder(resultLeft.Syntax, resultLeft.Type).MakeCompilerGenerated(); 1162var conversion = this.Conversions.ClassifyConversionFromType(resultLeft.Type, trueFalseParameterType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1219var type = left.Type; 1236if (left.Type is not null) 1238var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated(); 1276var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated(); 1279implicitConversion = this.Conversions.ClassifyConversionFromType(operandPlaceholder.Type, parameterType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1646(object)operand.Type != null && 1647(operand.Type.SpecialType == SpecialType.System_UInt64 || isNuint(operand.Type))) 1872return left.Type; 1875return right.Type; 1939BinaryOperatorKind newKind = kind.Operator().WithType(newLeftOperand.Type!.SpecialType); 2485var operandType = operand.Type; 2562var operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 2582var operandType = operand.Type; 2917var operandType = operand.Type as PointerTypeSymbol; 2972TypeSymbol operandType = operand.Type; 3051if (receiver.Type.IsReferenceType) 3177if (isOperandNullOrNew || operand.Type?.IsErrorType() == true) 3205type: operand.Type!); 3254var underlyingType = operand.Type.GetEnumUnderlyingType()!; 3613if ((object)operand.Type == null && !operand.IsLiteralNull()) 3672if ((object)operand.Type == null) 3683var convertedExpression = BindExpressionForPattern(operand.Type, node.Right, ref hasErrors, isPatternDiagnostics, out var constantValueOpt, out var wasExpression, out _); 3690node.Right, convertedExpression, constantValueOpt ?? ConstantValue.Bad, operand.Type, convertedExpression.Type ?? operand.Type, hasErrors) 3710if (operandHasErrors || IsOperatorErrors(node, operand.Type, typeExpression, diagnostics)) 3731operand.Type.IsVoidType()) 3761var operandType = operand.Type; 4161if ((object)operand.Type == null) 4223Debug.Assert(operand.Type is null); 4224operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 4238var operandType = operand.Type; 4271operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 4450TypeSymbol optLeftType = leftOperand.Type; // "A" 4451TypeSymbol optRightType = rightOperand.Type; // "B" 4626TypeSymbol leftType = leftOperand.Type; 4644if (underlyingRightConversion.Exists && rightOperand.Type?.IsDynamic() != true) 4785TypeSymbol trueType = trueExpr.Type; 4786TypeSymbol falseType = falseExpr.Type;

24TypeSymbol? expressionType = expression.Type; 37Debug.Assert(expression.Type is { }); 38BoundPattern pattern = BindPattern(node.Pattern, expression.Type, permitDesignations: true, hasErrors, diagnostics, underIsPattern: true); 65Debug.Assert(expression.Type is object); 66diagnostics.Add(ErrorCode.ERR_IsPatternImpossible, node.Location, expression.Type); 82Debug.Assert(expression.Type is object); 83diagnostics.Add(ErrorCode.WRN_IsPatternAlways, node.Location, expression.Type); 248Debug.Assert(indexerAccess.Type is not null); 249sliceType = indexerAccess.Type; 322Debug.Assert(indexerAccess!.Type is not null); 323elementType = indexerAccess.Type; 427var convertedType = convertedExpression.Type ?? inputType; 515Debug.Assert(expression is { Kind: BoundKind.TypeExpression, Type: { } }); 516hasErrors |= CheckValidPatternType(patternExpression, inputType, expression.Type, diagnostics: diagnostics); 578if (convertedExpression.Type is null && constantValueOpt != ConstantValue.Null) 619RoslynDebug.Assert(expression.Type is { }); 620ConstantValue match = ExpressionOfTypeMatchesPatternType(Conversions, inputType, expression.Type, ref useSiteInfo, out _, operandConstantValue: null); 652if (expression.Type?.SpecialType == SpecialType.System_String && inputType.IsSpanOrReadOnlySpanChar()) 707(conversion.ConversionKind == ConversionKind.NoConversion && convertedExpression.Type?.IsErrorType() == true)) 1633var type = value.Type ?? inputType;

300Debug.Assert(state.fromExpression.Type is { }); 303ImmutableArray.Create(state.fromExpression), state.fromExpression.Type); 738else if (!yExpression.HasAnyErrors && yExpression.Type!.IsVoidType()) 740Error(d, ErrorCode.ERR_QueryRangeVariableAssignedBadValue, errorLocation, yExpression.Type!); 741Debug.Assert(yExpression.Type is { }); 742yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), yExpression.Type); 803field2Value = new BoundBadExpression(field2Value.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(field2Value), field2Value.Type, true); 823return e.Type ?? CreateErrorType(); 928Debug.Assert(receiver.Type is object || ultimateReceiver.Type is null); 929if ((object?)ultimateReceiver.Type == null) 963if (ultimateReceiver.Type.TypeKind == TypeKind.TypeParameter) 966Error(diagnostics, ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax, ultimateReceiver.Type, MessageID.IDS_SK_TYVAR.Localize()); 974else 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; 759Debug.Assert(expr.Type is object); 760Debug.Assert(expr.Type.IsRefLikeType || hasAwait); // pattern dispose lookup is only valid on ref structs or asynchronous usings 1022TypeSymbol initializerType = initializerOpt?.Type; 1232TypeSymbol initializerType = initializerOpt.Type; 1248elementType = ((BoundAddressOfOperator)initializerOpt).Operand.Type; 1322if (initializer.Type.IsVoidType()) 1342additionalDiagnostics.Add(ErrorCode.WRN_PatternBadSignature, initializer.Syntax.Location, initializer.Type, "fixed", patternMethodSymbol); 1459var inferredType = op2.Type; 1485if (op1.Type is { } lhsType && !lhsType.IsErrorType()) 1533type = op1.Type; 1554Debug.Assert(op1.Type is { }); 1587Debug.Assert(leftEscape.Equals(rightEscape) || op1.Type.IsRefLikeOrAllowsRefLikeType()); 1607if (!hasErrors && op1.Type.IsRefLikeOrAllowsRefLikeType()) 1830Debug.Assert((object)receiver.Type != null); 1831return receiver.Type; 1957this.Conversions.ClassifyConversionFromType(expression.Type, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1989expression.Type, 2449var sourceType = operand.Type; 3057hasErrors |= arg.HasErrors || ((object)arg.Type != null && arg.Type.IsErrorType()); 3132if ((object)arg?.Type != null && arg.Type.IsVoidType()) 3196&& TypeSymbol.Equals(argument.Type, this.GetCurrentReturnType(out unusedRefKind), TypeCompareKind.ConsiderEverything2)) 3199Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType, argument.Type); 3533else if (expression.Type?.SpecialType == SpecialType.System_Void)

1477receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Ambiguous, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(receiver), receiver.Type, hasErrors: true).MakeCompilerGenerated();

85TypeSymbol leftType = left.Type; 86TypeSymbol rightType = right.Type; 111return new TupleBinaryOperatorInfo.Single(binary.Left.Type, binary.Right.Type, binary.OperatorKind, binary.Method, binary.ConstrainedToType, 183Debug.Assert((object)left.Type != null && left.Type.IsDynamic() || (object)right.Type != null && right.Type.IsDynamic()); 205left = GiveTupleTypeToDefaultLiteralIfNeeded(left, right.Type); 206right = GiveTupleTypeToDefaultLiteralIfNeeded(right, left.Type); 217Debug.Assert((object)left.Type != null || left.Kind == BoundKind.TupleLiteral); 218Debug.Assert((object)right.Type != null || right.Kind == BoundKind.TupleLiteral); 247bool leftNullable = left.Type?.IsNullableType() == true; 248bool rightNullable = right.Type?.IsNullableType() == true; 356TypeSymbol type = expr.Type; 383TypeSymbol tupleType = expr.Type.StrippedType();

20var receiverType = receiver.Type;

407Debug.Assert(variableAccess.Type!.Equals(input.Type, TypeCompareKind.AllIgnoreOptions) || variableAccess.Type.IsErrorType()); 500Debug.Assert(constant.Value.Type is not null || constant.HasErrors); 501output = input = constant.Value.Type is { } type ? MakeConvertToType(input, constant.Syntax, type, isExplicitTest: false, tests) : input; 708var type = rel.Value.Type ?? input.Type;

557(builder.ElementType.IsPointerOrFunctionPointer() && collectionExpr.Type.IsArray()) || 558(builder.ElementType.IsNullableType() && builder.ElementType.GetMemberTypeArgumentsNoUseSiteDiagnostics().Single().IsErrorType() && collectionExpr.Type.IsArray())); 589(collectionConversionClassification.Kind == ConversionKind.ExplicitReference && collectionExpr.Type.SpecialType == SpecialType.System_String)); 658Debug.Assert(collectionType.Equals(collectionExpr.Type, TypeCompareKind.AllIgnoreOptions)); // Should not create an Identity conversion that changes type. 697else if (collectionExpr.Type.SpecialType == SpecialType.System_String && builder.CollectionType.SpecialType == SpecialType.System_Collections_IEnumerable) 715TypeSymbol collectionExprType = collectionExpr.Type; 792TypeSymbol collectionExprType = collectionExpr.Type; 831if (!isAsync && collectionExpr.Type?.HasInlineArrayAttribute(out _) == true && collectionExpr.Type.TryGetPossiblyUnsupportedByLanguageInlineArrayElementField() is FieldSymbol elementField) 862diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type); 885builder.CollectionType = collectionExpr.Type; 902CheckInlineArrayTypeIsSupported(collectionExpr.Syntax, collectionExpr.Type, elementField.Type, diagnostics); 910diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type); 923(originalCollectionExpr.Type?.IsNullableType() == true && originalCollectionExpr.Type.StrippedType().Equals(collectionExpr.Type, TypeCompareKind.AllIgnoreOptions))); 934TypeSymbol collectionExprType = collectionExpr.Type; 974var unwrappedCollectionExprType = unwrappedCollectionExpr.Type; 1053builder.CollectionType = collectionExpr.Type; 1363getEnumeratorInfo = FindForEachPatternMethod(syntax, collectionSyntax, collectionExpr.Type, methodName, lookupResult, warningsOnly: true, diagnostics, isAsync); 1607diagnostics.Add(ErrorCode.WRN_PatternIsAmbiguous, collectionSyntax.Location, collectionExpr.Type, MessageID.IDS_Collection.Localize(),

40TypeSymbol? exprType = expr.Type;

240return placeholder.Type?.SpecialType == SpecialType.System_Int32; 521if (node.ExpressionOpt is { Type: { } } expr) 531if (node.Expression is { Type: { } } expr)

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

480if (method.RequiresInstanceReceiver && methodGroup.Receiver?.Type?.IsRestrictedType() == true) 511Debug.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); 1033Debug.Assert(sourceExpression == null || (object)sourceExpression.Type == (object)source); 1075var innerConversion = ClassifyImplicitBuiltInConversionFromExpression(innerExpression, innerExpression.Type, destination, ref useSiteInfo); 1353if (constantValue == null || (object)source.Type == null) 1363var specialSource = source.Type.GetSpecialTypeSafe(); 1419var sourceType = sourceExpression.Type; 1462source.Type is object && 1463IsNumericType(source.Type) && 1923Debug.Assert(sourceExpressionOpt == null || (object)sourceExpressionOpt.Type == sourceType); 1960conversions.ClassifyImplicitExtensionMethodThisArgConversion(s, s.Type, d.Type, ref u, isMethodGroupConversion: false), 3043if (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)

67TypeSymbol leftOperatorSourceOpt = left.Type?.StrippedType(); 68TypeSymbol rightOperatorSourceOpt = right.Type?.StrippedType(); 360var leftType = left.Type; 362var rightType = right.Type; 504bool isExactSubtraction = TypeSymbol.Equals(right.Type?.StrippedType(), underlying, TypeCompareKind.ConsiderEverything2); 608var leftType = left.Type; 614var rightType = right.Type; 683var leftType = left.Type as PointerTypeSymbol; 684var rightType = right.Type as PointerTypeSymbol; 699if ((object)leftType != null || (object)rightType != null || left.Type is FunctionPointerTypeSymbol || right.Type is FunctionPointerTypeSymbol) 721if ((left.Type is TypeParameterSymbol { AllowsRefLikeType: true } && right.IsLiteralNull()) || 722(right.Type is TypeParameterSymbol { AllowsRefLikeType: true } && left.IsLiteralNull())) 741this.Compilation.BuiltInOperators.GetSimpleBuiltInOperators(kind, operators, skipNativeIntegerOperators: !left.Type.IsNativeIntegerOrNullableThereof() && !right.Type.IsNativeIntegerOrNullableThereof()); 756this.Compilation.BuiltInOperators.GetUtf8ConcatenationBuiltInOperator(left.Type, operators); 767BuiltInOperators.IsValidObjectEquality(conversions, left.Type, left.IsLiteralNull(), leftIsDefault: false, right.Type, right.IsLiteralNull(), rightIsDefault: false, ref useSiteInfo) && 768((object)left.Type == null || (!left.Type.IsDelegateType() && left.Type.SpecialType != SpecialType.System_String && left.Type.SpecialType != SpecialType.System_Delegate)) && 769((object)right.Type == null || (!right.Type.IsDelegateType() && right.Type.SpecialType != SpecialType.System_String && right.Type.SpecialType != SpecialType.System_Delegate)); 779return (operand.Type is TypeParameterSymbol { AllowsRefLikeType: true }) ? Conversion.Boxing : Conversions.ClassifyConversionFromExpression(operand, objectType, isChecked: isChecked, ref useSiteInfo);

99var operandType = operand.Type;

257this.Compilation.BuiltInOperators.GetSimpleBuiltInOperators(kind, operators, skipNativeIntegerOperators: !operand.Type.IsNativeIntegerOrNullableThereof()); 296var enumType = operand.Type; 327var pointerType = operand.Type as PointerTypeSymbol; 351if ((object)operand.Type == null) 379TypeSymbol type0 = operand.Type.StrippedType();

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

3253if ((object)node.Type != null && Conversions.HasIdentityConversion(node.Type, t)) 4708var argType = argument.Type; 4722Conversions.ClassifyImplicitExtensionMethodThisArgConversion(argument, argument.Type, parameterType, ref useSiteInfo, isMethodGroupConversion: isMethodGroupConversion) : 4723((!dynamicConvertsToAnything || !argument.Type.IsDynamic()) ?

522diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, location, receiver.Type); 662diagnostics.Add(ErrorCode.ERR_QueryNoProvider, location, receiverOpt.Type, symbol.Name); 670diagnostics.Add(ErrorCode.ERR_BadAwaitArg, location, receiverOpt.Type); 1132diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, location, receiver.Type); 1371=> argument is BoundLiteral { Type.SpecialType: SpecialType.System_String } && 1410diagnostics.Add(ErrorCode.ERR_QueryMultipleProviders, location, receiver.Type, name);

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

145var type = @case.Value.Type; 182Debug.Assert(inputExpression.Type is not null); 193Debug.Assert(inputExpression.Type is not null); 194return inputExpression.Type; 200if (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; 290(fromExpression ? expressionOpt!.Type : declarationTypeOpt)!.ContainingModule != originalBinder.Compilation.SourceModule)

14NarrowedType.Equals(Value.Type, TypeCompareKind.AllIgnoreOptions));

57return arrayAccess.Expression.Type; 61return arrayAccess.Expression.Type;

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

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

126return node.Type is { }; 131var type = node.Type; 146if (expr.Type is { } type) 264TypeSymbol? 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);

14NarrowedType.Equals(Value.Type, TypeCompareKind.AllIgnoreOptions));

637public 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;

379expression.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()) && 139var fromType = conversion.Operand.Type; 214var fromType = conversion.Operand.Type; 230if (!conversion.Operand.Type.IsVerifierReference()) 232EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 262if (!conversion.Operand.Type.IsVerifierReference()) 264EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 290var fromType = conversion.Operand.Type; 337EmitSymbolToken(receiver.Type, receiver.Syntax); 343if (!receiver.Type.IsVerifierReference()) 345EmitBox(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); 737Debug.Assert(argument.Type.IsDynamic() || argument is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None }, "passing args byref should not clone them into temps"); 792EmitLoadIndirect(expression.Type, expression.Syntax); 801var meth = expression.MethodOpt ?? receiver.Type.DelegateInvokeMethod(); 1014if (((ArrayTypeSymbol)arrayAccess.Expression.Type).IsSZArray) 1101_builder.EmitArrayElementLoad(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Expression.Syntax); 1132if (!field.IsVolatile && !field.IsStatic && fieldAccess.ReceiverOpt.Type.IsVerifierValue() && field.RefKind == RefKind.None) 1171if (fieldType.IsValueType && (object)fieldType == (object)receiver.Type) 1227if (receiver == null || !receiver.Type.IsValueType) 1238EmitSymbolToken(receiver.Type, receiver.Syntax); 1267if (!receiver.Type.IsVerifierValue()) 1319var type = expr.Type; 1510if (receiver.Type.IsTypeParameter()) 1515Debug.Assert(receiver.Type.IsVerifierReference(), "this is not a reference"); 1645Debug.Assert(TypeSymbol.Equals(method.ContainingType, receiver.Type, TypeCompareKind.ConsiderEverything2)); 1674EmitSymbolToken(receiver.Type, receiver.Syntax); 1831var receiverType = receiver.Type; 1917var receiverType = receiver.Type; 1977Debug.Assert(receiver.Type.IsVerifierReference()); 1988Debug.Assert(receiver.Type.IsVerifierReference()); 2008EmitSymbolToken(receiver.Type, receiver.Syntax); 2023var receiverType = receiver.Type; 2086var receiverType = receiver.Type; 2598var rightType = right.Type; 2654if (left.Kind == BoundKind.ArrayAccess && left.Type.TypeKind == TypeKind.TypeParameter && !left.Type.IsValueType) 2678EmitSymbolToken(target.Type, target.Syntax); 3050assignmentOperator.Left.Type, 3097var arrayType = (ArrayTypeSymbol)array.Type; 3111EmitIndirectStore(expression.Type, expression.Syntax); 3116EmitIndirectStore(expression.Type, expression.Syntax); 3122EmitIndirectStore(expression.Type, expression.Syntax); 3134EmitIndirectStore(expression.Type, expression.Syntax); 3139EmitIndirectStore(expression.Type, expression.Syntax); 3385Debug.Assert((object)operand.Type != null); 3386if (!operand.Type.IsVerifierReference()) 3389EmitBox(operand.Type, operand.Syntax); 3412var operandType = operand.Type; 3906if (!(expr.Type.IsInterfaceType() || expr.Type.IsDelegateType())) 3908return expr.Type; 3953return expr.Type; 4024temp = 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; 915_module.Translate(expressionOpt.Type, boundReturnStatement.Syntax, _diagnostics.DiagnosticBag); 1127if (!exceptionSourceOpt.Type.IsVerifierReference()) 1129Debug.Assert(exceptionSourceOpt.Type.IsTypeParameter()); // only expecting type parameters 1131EmitSymbolToken(exceptionSourceOpt.Type, exceptionSourceOpt.Syntax); 1158Debug.Assert(!left.ReceiverOpt.Type.IsTypeParameter()); 1169var temp = AllocateTemp(exceptionSource.Type, exceptionSource.Syntax); 1232Debug.Assert((object)dispatch.Expression.Type != null); 1233Debug.Assert(dispatch.Expression.Type.IsValidV6SwitchGoverningType() || dispatch.Expression.Type.IsSpanOrReadOnlySpanChar()); 1236Debug.Assert(!dispatch.Expression.Type.IsNullableType()); 1255Debug.Assert((object)expression.Type != null && 1256(expression.Type.IsValidV6SwitchGoverningType() || expression.Type.IsSpanOrReadOnlySpanChar())); 1301temp = AllocateTemp(expression.Type, expression.Syntax); 1308expression.Type.SpecialType == SpecialType.System_String || expression.Type.IsSpanOrReadOnlySpanChar()); 1311if (expression.Type.SpecialType == SpecialType.System_String || expression.Type.IsSpanOrReadOnlySpanChar()) 1315this.EmitStringSwitchJumpTable(switchCaseLabels, fallThroughLabel, key, expression.Syntax, expression.Type); 1319this.EmitLengthBasedStringSwitchJumpTable(lengthBasedSwitchStringJumpTableOpt, fallThroughLabel, key, expression.Syntax, expression.Type); 1324_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) || 1019left.Type.Equals(((PointerTypeSymbol)right.Type).PointedAtType, TypeCompareKind.AllIgnoreOptions); 1036Debug.Assert(lhs.Type.IsValueType, "'this' is assignable only in structs"); 1194var receiverType = receiver.Type; 1229var receiverType = receiver.Type; 1347if (receiver.Type.IsTypeParameter()) 1356if (receiver.Type.IsValueType && ( 1657PushEvalStack(new BoundDefaultExpression(node.Syntax, node.Operand.Type), ExprContext.Value);

2221(result!.Type!.IsVoidType() || result.Type!.SpecialType == SpecialType.System_Int32);

2061type = boundExpr.Type; 2180convertedType = highestBoundExpr.Type; 2186convertedType = highestBoundExpr.Type; 2275static (TypeSymbol, NullabilityInfo) getTypeAndNullability(BoundExpression expr) => (expr.Type, expr.TopLevelNullability); 3387else if (expr.Type.IsDelegateType()) 3696var thisParam = GetThisParameter(boundNode.Type, containingType, containingMember, out resultKind); 3820symbols = OneOrMany.Create<Symbol>(new SynthesizedIntrinsicOperatorSymbol(unaryOperator.Operand.Type.StrippedType(), 3843TypeSymbol opType = increment.Operand.Type.StrippedType(); 3870((binaryOperator.Left.IsLiteralNull() && binaryOperator.Right.Type.IsNullableType()) || 3871(binaryOperator.Right.IsLiteralNull() && binaryOperator.Left.Type.IsNullableType())) && 3885binaryOperator.Left.Type, 3886binaryOperator.Right.Type, 4096TypeSymbol type = boundNode.Type; 4620if (node.SearchExtensions && receiver.Type is { } receiverType) 4762receiverType = call.ReceiverOpt.Type; 4766receiverType = call.Arguments[0].Type; 4796MethodSymbol reduced = method.ReduceExtensionMethod(receiver.Type, Compilation); 4811MethodSymbol reduced = method.ReduceExtensionMethod(receiverOpt.Type, Compilation);

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

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

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

643else if ((object)node.Type == null || node.Type.SpecialType != SpecialType.System_Boolean) 1675&& node.Type.SpecialType == SpecialType.System_Boolean) 2245(object)receiverOpt.Type != null && 2246!receiverOpt.Type.IsPrimitiveRecursiveStruct()); 2642&& conv.Operand.Type!.IsNonNullableValueType());

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

1125MayRequireTrackingReceiverType(receiver.Type); 1142MayRequireTrackingReceiverType(receiverOpt.Type) && 1143!receiverOpt.Type.IsPrimitiveRecursiveStruct(); 1381if (_emptyStructTypeCache.IsEmptyStructType(node.Type)) return true; 1594if (elementAccess.Expression.Type.HasInlineArrayAttribute(out int length) && 1598int slot = MakeMemberSlot(elementAccess.Expression, elementAccess.Expression.Type.TryGetInlineArrayElementField()); 2595if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type)

411expr.Type?.Equals(result.RValueType.Type, TypeCompareKind.AllIgnoreOptions) == true ? result.RValueType.Type : expr.Type); 547Debug.Assert(AreCloseEnough(placeholder.Type, result.RValueType.Type)); 2092receiver.Type is object; 2103TypeSymbol? nodeType = node.Type; 2139var operandType = operand.Type; 2157TypeSymbol.Equals(conv.Type, conv.Operand.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes): 3705Debug.Assert(AreCloseEnough(resultType.Type, node.Type)); 4568SetAnalyzedNullability(node.ImplicitReceiverOpt, new VisitResult(node.ImplicitReceiverOpt.Type, NullableAnnotation.NotAnnotated, NullableFlowState.NotNull)); 4626SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull)); 4631var resultType = TypeWithState.Create(node.Type, NullableFlowState.NotNull); 4678Debug.Assert(node.Type is object); 4679if (IsEmptyStructType(node.Type)) 4684return GetOrCreatePlaceholderSlot(node, TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated)); 5002Debug.Assert(!node.Expression.Type!.IsValueType); 5016TypeSymbol.Equals(node.Indices[0].Type, compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.ConsiderEverything2)) 5336if (expr.Type is null) 5346TypeWithAnnotations.Create(expr.Type), 5360Debug.Assert(binary.Type!.SpecialType == SpecialType.System_Boolean); 5560var receiverType = conditional.Receiver.Type!; 5589if (slot > 0 && PossiblyNullableType(operand.Type)) 5659LearnFromNullTest(slot, expressionWithoutConversion.Type, ref state, markDependentSlotsNotNull: false); 5773node.Type?.ContainsErrorType() == true || 5774TypeSymbol.Equals(targetType.Type.GetNullableUnderlyingType(), node.Type, TypeCompareKind.AllIgnoreOptions)); 5780targetType = TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated); 6070if (slot > 0 && receiver.Type?.IsNullableType() == true) 6071slot = GetNullableOfTValueSlot(receiver.Type, slot, out _); 6115TypeSymbol? refResultType = node.Type?.SetUnknownNullabilityForReferenceTypes(); 6181resultType ??= node.Type?.SetUnknownNullabilityForReferenceTypes(); 7308TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState.Create(argument.Type, result.RValueType.State), argument as BoundConversion, argumentNoConversion); 7426completion(TypeWithAnnotations.Create(argument.Type)); 8524if (value.Type is null || value.Type.IsDynamic() || value.ConstantValueOpt != null) 8534value.Type.HasInlineArrayAttribute(out _) == true && 8535value.Type.TryGetInlineArrayElementField() is not null) 8674if (TypeAllowsConditionalState(targetType.Type) && TypeAllowsConditionalState(operand.Type)) 8822var tupleOpt = (NamedTypeSymbol?)node.Type; 10014case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate }: 10128Debug.Assert(arg.Type is not null); 10129TypeSymbol argType = arg.Type; 10147Debug.Assert(arg.Type is not null); 10148TypeSymbol argType = arg.Type; 10328var rvalueResult = TypeWithState.Create(node.Type, NullableFlowState.NotNull); 10329var lvalueResult = TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated); 10829if (expr.Type is NamedTypeSymbol { IsTupleType: true } tupleType) 11046SetResultType(node.Expression, TypeWithState.Create(node.Expression.Type, ResultType.State)); 11418if (collectionExpression.Type!.SpecialType == SpecialType.System_Collections_IEnumerable) 11421targetTypeWithAnnotations = TypeWithAnnotations.Create(collectionExpression.Type); 11423else if (ForEachLoopBinder.IsIEnumerableT(collectionExpression.Type.OriginalDefinition, isAsync, compilation)) 11687var type = TypeWithAnnotations.Create(node.Type); 12083SetResultType(node, TypeWithState.Create(node.Type, node.Type?.CanContainNull() != false && node.ConstantValueOpt?.IsNull == true ? NullableFlowState.MaybeDefault : NullableFlowState.NotNull)); 12260SetResultType(expression, TypeWithState.Create(expression.Type, default)); 12294Debug.Assert(receiverOpt.Type is null || AreCloseEnough(receiverOpt.Type, resultTypeSymbol)); 12382SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull)); 12415Debug.Assert(node.Type is null || node.Type.IsErrorType() || node.Type.IsRefLikeType); 12431SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull)); 12435Debug.Assert(node.Type is not null); 12436var type = VisitArrayInitialization(node.Type, initialization, node.HasErrors);

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

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

469if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 499if (receiver != this.Receiver || localScopeDepth != this.LocalScopeDepth || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 531public new TypeSymbol Type => base.Type!; 568public new TypeSymbol Type => base.Type!; 597public new TypeSymbol? Type => base.Type; 632public new TypeSymbol Type => base.Type!; 669public new TypeSymbol Type => base.Type!; 705public new TypeSymbol Type => base.Type!; 742public new TypeSymbol Type => base.Type!; 778public new TypeSymbol Type => base.Type!; 813public new TypeSymbol Type => base.Type!; 848public new TypeSymbol Type => base.Type!; 883public new TypeSymbol Type => base.Type!; 921if (refKind != this.RefKind || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 949if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 982if (resultKind != this.ResultKind || symbols != this.Symbols || childBoundNodes != this.ChildBoundNodes || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 1065public new TypeSymbol Type => base.Type!; 1103public new TypeSymbol Type => base.Type!; 1143public new TypeSymbol? Type => base.Type; 1180public new TypeSymbol Type => base.Type!; 1225public new TypeSymbol Type => base.Type!; 1265public new TypeSymbol Type => base.Type!; 1296public new TypeSymbol? Type => base.Type; 1339public new TypeSymbol Type => base.Type!; 1369public new TypeSymbol Type => base.Type!; 1404public new TypeSymbol Type => base.Type!; 1441public new TypeSymbol Type => base.Type!; 1475public new TypeSymbol Type => base.Type!; 1506public new TypeSymbol Type => base.Type!; 1537public new TypeSymbol Type => base.Type!; 1569public new TypeSymbol Type => base.Type!; 1601public new TypeSymbol Type => base.Type!; 1635public new TypeSymbol Type => base.Type!; 1691public new TypeSymbol Type => base.Type!; 1782public new TypeSymbol Type => base.Type!; 1822public new TypeSymbol Type => base.Type!; 1857public new TypeSymbol Type => base.Type!; 1895public new TypeSymbol Type => base.Type!; 1939if (leftOperand != this.LeftOperand || rightOperand != this.RightOperand || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 1966public new TypeSymbol? Type => base.Type; 2008public new TypeSymbol Type => base.Type!; 2046public new TypeSymbol Type => base.Type!; 2076public new TypeSymbol? Type => base.Type; 2106public new TypeSymbol Type => base.Type!; 2172public new TypeSymbol Type => base.Type!; 2212public new TypeSymbol Type => base.Type!; 2299public new TypeSymbol Type => base.Type!; 2341public new TypeSymbol Type => base.Type!; 2384public new TypeSymbol Type => base.Type!; 2421public new TypeSymbol Type => base.Type!; 2456public new TypeSymbol Type => base.Type!; 2494public new TypeSymbol Type => base.Type!; 2529public new TypeSymbol Type => base.Type!; 2564public new TypeSymbol Type => base.Type!; 2599public new TypeSymbol Type => base.Type!; 2634public new TypeSymbol Type => base.Type!; 2673public new TypeSymbol Type => base.Type!; 2715public new TypeSymbol Type => base.Type!; 2758public new TypeSymbol Type => base.Type!; 2789public new TypeSymbol? Type => base.Type; 2812public new TypeSymbol Type => base.Type!; 2846public new TypeSymbol Type => base.Type!; 2882public new TypeSymbol Type => base.Type!; 2916public new TypeSymbol Type => base.Type!; 2953public new TypeSymbol Type => base.Type!; 2991public new TypeSymbol Type => base.Type!; 3028public new TypeSymbol Type => base.Type!; 3057public new TypeSymbol? Type => base.Type; 3093public new TypeSymbol Type => base.Type!; 4303if (constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 4335public new TypeSymbol Type => base.Type!; 4371public new TypeSymbol Type => base.Type!; 4406public new TypeSymbol Type => base.Type!; 4441public new TypeSymbol Type => base.Type!; 4470public new TypeSymbol? Type => base.Type; 4515public new TypeSymbol Type => base.Type!; 4562public new TypeSymbol Type => base.Type!; 4595public new TypeSymbol Type => base.Type!; 4636public new TypeSymbol Type => base.Type!; 4781if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(label, this.Label) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 4942if (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)) 4967public new TypeSymbol Type => base.Type!; 5714public new TypeSymbol? Type => base.Type; 5737if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 5763public new TypeSymbol Type => base.Type!; 5799public new TypeSymbol Type => base.Type!; 5836public new TypeSymbol Type => base.Type!; 5891public new TypeSymbol Type => base.Type!; 5925public new TypeSymbol Type => base.Type!; 5962public new TypeSymbol Type => base.Type!; 6005public new TypeSymbol Type => base.Type!; 6037public new TypeSymbol Type => base.Type!; 6150public new TypeSymbol Type => base.Type!; 6197public new TypeSymbol Type => base.Type!; 6239public new TypeSymbol Type => base.Type!; 6280public new TypeSymbol? Type => base.Type; 6320public new TypeSymbol Type => base.Type!; 6398public new TypeSymbol? Type => base.Type; 6435public new TypeSymbol Type => base.Type!; 6478if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 6556public new TypeSymbol? Type => base.Type; 6593if (sourceTuple != this.SourceTuple || wasTargetTyped != this.WasTargetTyped || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || inferredNamesOpt != this.InferredNamesOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 6692public new TypeSymbol Type => base.Type!; 6747public new TypeSymbol Type => base.Type!; 6800public new TypeSymbol Type => base.Type!; 6867public new TypeSymbol Type => base.Type!; 6906public new TypeSymbol Type => base.Type!; 6942public new TypeSymbol Type => base.Type!; 6975public new TypeSymbol Type => base.Type!; 7017public new TypeSymbol Type => base.Type!; 7080public new TypeSymbol Type => base.Type!; 7114public new TypeSymbol Type => base.Type!; 7145public new TypeSymbol? Type => base.Type; 7200if (!TypeSymbol.Equals(elementType, this.ElementType, TypeCompareKind.ConsiderEverything) || count != this.Count || initializerOpt != this.InitializerOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 7222public new TypeSymbol Type => base.Type!; 7256public new TypeSymbol Type => base.Type!; 7301public new TypeSymbol Type => base.Type!; 7335public new TypeSymbol Type => base.Type!; 7372public new TypeSymbol Type => base.Type!; 7416public new TypeSymbol Type => base.Type!; 7470public new TypeSymbol Type => base.Type!; 7513public new TypeSymbol Type => base.Type!; 7552public new TypeSymbol Type => base.Type!; 7594public new TypeSymbol? Type => base.Type; 7638public new TypeSymbol? Type => base.Type; 7676public new TypeSymbol Type => base.Type!; 7739public new TypeSymbol Type => base.Type!; 7790if (parts != this.Parts || constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 7818if (!interpolationData.Equals(this.InterpolationData) || parts != this.Parts || constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 7846if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 7876public new TypeSymbol Type => base.Type!; 7908public new TypeSymbol? Type => base.Type; 7961if (expression != this.Expression || pattern != this.Pattern || 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)) 8561public new TypeSymbol? Type => base.Type; 8598if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 8620public new TypeSymbol? Type => base.Type; 8693public new TypeSymbol? Type => base.Type; 8791public new TypeSymbol? Type => base.Type; 8824public new TypeSymbol Type => base.Type!; 10847TypeSymbol? type = this.VisitType(node.Type); 10853TypeSymbol? type = this.VisitType(node.Type); 10914TypeSymbol? type = this.VisitType(node.Type); 10920TypeSymbol? type = this.VisitType(node.Type); 10927TypeSymbol? type = this.VisitType(node.Type); 11122TypeSymbol? type = this.VisitType(node.Type); 11538TypeSymbol? type = this.VisitType(node.Type); 11612TypeSymbol? type = this.VisitType(node.Type); 11641TypeSymbol? type = this.VisitType(node.Type); 11789TypeSymbol? type = this.VisitType(node.Type); 11926TypeSymbol? type = this.VisitType(node.Type); 11949TypeSymbol? type = this.VisitType(node.Type); 12060TypeSymbol? type = this.VisitType(node.Type); 12171TypeSymbol? type = this.VisitType(node.Type); 12177TypeSymbol? type = this.VisitType(node.Type); 12182TypeSymbol? type = this.VisitType(node.Type); 12205TypeSymbol? type = this.VisitType(node.Type); 12330TypeSymbol? type = this.VisitType(node.Type); 12444updatedNode = node.Update(receiver, node.LocalScopeDepth, node.Type); 12610updatedNode = node.Update(expression, node.Type); 12628updatedNode = node.Update(node.ResultKind, node.Symbols, childBoundNodes, node.Type); 13023updatedNode = node.Update(leftOperand, rightOperand, node.Type); 13815updatedNode = node.Update(expression, switchArms, reachabilityDecisionDag, node.DefaultLabel, node.ReportedNotExhaustive, node.Type); 13910updatedNode = node.Update(expression, node.Type); 14272updatedNode = node.Update(sourceTuple, node.WasTargetTyped, arguments, node.ArgumentNamesOpt, node.InferredNamesOpt, node.Type); 14555updatedNode = node.Update(elementType, count, initializerOpt, node.Type); 14793updatedNode = node.Update(parts, node.ConstantValueOpt, node.Type); 14810updatedNode = node.Update(node.InterpolationData, parts, node.ConstantValueOpt, node.Type); 14872updatedNode = node.Update(expression, pattern, node.IsNegated, reachabilityDecisionDag, node.WhenTrueLabel, node.WhenFalseLabel, node.Type); 15021updatedNode = node.Update(expression, node.Type); 15163new TreeDumperNode("type", node.Type, null), 15172new TreeDumperNode("type", node.Type, null), 15261new TreeDumperNode("type", node.Type, null), 15269new TreeDumperNode("type", node.Type, null), 15279new TreeDumperNode("type", node.Type, null), 15551new TreeDumperNode("type", node.Type, null), 16113new TreeDumperNode("type", node.Type, null), 16215new TreeDumperNode("type", node.Type, null), 16251new TreeDumperNode("type", node.Type, null), 16437new TreeDumperNode("type", node.Type, null), 16654new TreeDumperNode("type", node.Type, null), 16688new TreeDumperNode("type", node.Type, null), 16854new TreeDumperNode("type", node.Type, null), 17021new TreeDumperNode("type", node.Type, null), 17031new TreeDumperNode("type", node.Type, null), 17038new TreeDumperNode("type", node.Type, null), 17070new TreeDumperNode("type", node.Type, null), 17224new TreeDumperNode("type", node.Type, null),

674rewrittenSource.Type, 1008this.returnValue = returnValue = new SynthesizedLocal(containingMethod, TypeWithAnnotations.Create(valueOpt.Type), SynthesizedLocalKind.AsyncMethodReturnValue, _syntaxOpt);

378var awaiterTemp = F.SynthesizedLocal(getAwaiter.Type, syntax: node.Syntax, kind: SynthesizedLocalKind.Awaiter);

237F.Call(parameterProxy, WellKnownMember.System_Threading_CancellationToken__Equals, F.Default(parameterProxy.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);

118if (!node.Type.Equals(result.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)) 298if (!TypeSymbol.Equals(index.Type, _int32Type, TypeCompareKind.ConsiderEverything2)) 300index = ConvertIndex(index, arg.Type, _int32Type); 316if (!TypeSymbol.Equals(index.Type, _int32Type, TypeCompareKind.ConsiderEverything2)) 318index = ConvertIndex(index, arg.Type, _int32Type); 367if (node.Operand.IsLiteralNull() && (object)node.Operand.Type == null) 493if ((object)left.Type == null && left.IsLiteralNull()) 495left = _bound.Default(right.Type); 497if ((object)right.Type == null && right.IsLiteralNull()) 499right = _bound.Default(left.Type); 510var promotedType = PromotedType(enumOperand.Type.StrippedType().GetEnumUnderlyingType()); 563return Convert(loweredOperand, operand.Type, promotedType, isChecked, false); 700var operandType = node.Operand.Type; 709? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 725if (node.Operand.Type.IsNullableType()) 727return Convert(Visit(node.Operand), node.Operand.Type, node.Type, node.Checked, node.ExplicitCastInCode); 734var e1 = Convert(Visit(node.Operand), node.Operand.Type, intermediate, node.Checked, false); 740return Convert(Visit(node.Operand), node.Operand.Type, node.Type, node.Checked, node.ExplicitCastInCode); 760receiver = requiresInstanceReceiver ? nullObject : receiver.Type.IsReferenceType ? receiver : _bound.Convert(_objectType, receiver); 798var d = node.Argument.Type as NamedTypeSymbol; 819if ((object)operand.Type == null && operand.ConstantValueOpt != null && operand.ConstantValueOpt.IsNull) 880TypeSymbol lambdaParamType = node.LeftPlaceholder.Type; 881return _bound.StaticCall(WellKnownMember.System_Linq_Expressions_Expression__Coalesce_Lambda, left, right, MakeConversionLambda(leftConversion, lambdaParamType, node.LeftConversion.Type)); 1117if (node.ReceiverOpt?.Type.IsTypeParameter() == true && 1118!node.ReceiverOpt.Type.IsReferenceType) 1188var promotedType = PromotedType(arg.Type.StrippedType().GetEnumUnderlyingType()); 1190loweredArg = Convert(loweredArg, arg.Type, promotedType, isChecked, false); 1207_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()) 402expr.Type is TypeSymbol type &&

228Debug.Assert(TypeSymbol.Equals(expr1.Type, expr2.Type, TypeCompareKind.ConsiderEverything2)); 330if (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)) 335else 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)) 356NamedTypeSymbol nt = conv.Operand.Type as NamedTypeSymbol; 447if (!conversion.Operand.Type.SpecialType.IsIntegralType() || !conversion.Type.SpecialType.IsIntegralType()) 452if (!Binder.CheckConstantBounds(conversion.Operand.Type.SpecialType, constantValue, out _)) 454Error(ErrorCode.WRN_VacuousIntegralComp, tree, conversion.Operand.Type); 612TypeSymbol from = conv.Operand.Type; 770Error(ErrorCode.WRN_NubExprIsConstBool, node, always, node.Left.Type.GetNullableUnderlyingType(), node.Left.Type); 774Error(ErrorCode.WRN_NubExprIsConstBool, node, always, node.Right.Type.GetNullableUnderlyingType(), node.Right.Type); 818Error(node.OperatorKind.IsUserDefined() ? ErrorCode.WRN_NubExprIsConstBool2 : ErrorCode.WRN_NubExprIsConstBool, node, always, node.Left.Type.GetNullableUnderlyingType(), GetTypeForLiftedComparisonWarning(node.Right)); 822Error(node.OperatorKind.IsUserDefined() ? ErrorCode.WRN_NubExprIsConstBool2 : ErrorCode.WRN_NubExprIsConstBool, node, always, node.Right.Type.GetNullableUnderlyingType(), GetTypeForLiftedComparisonWarning(node.Left)); 858if ((object)node.Type == null || !node.Type.IsNullableType()) 874return type ?? node.Type;

120Debug.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);

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

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

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

259TypeSymbol? type = node.Type; 280Debug.Assert(visited == null || visited.HasErrors || ReferenceEquals(visited.Type, node.Type) || 281visited.Type is { } && visited.Type.Equals(node.Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes) || 302type: visited.Type); 512Debug.Assert(value.Type is { } && (value.Type.Equals(placeholder.Type, TypeCompareKind.AllIgnoreOptions) || value.HasErrors)); 577Debug.Assert(node.Type is { }); 578return BadExpression(node.Syntax, node.Type, ImmutableArray.Create(node)); 831var indexType = VisitType(node.Indices[0].Type); 843Debug.Assert(node.Expression.Type is { TypeKind: TypeKind.Array }); 844var elementType = ((ArrayTypeSymbol)node.Expression.Type).ElementTypeWithAnnotations; 1060Debug.Assert(eventAccess.ReceiverOpt.Type is { }); 1061return !eventAccess.ReceiverOpt.Type.IsValueType || CanBePassedByReference(eventAccess.ReceiverOpt); 1071Debug.Assert(fieldAccess.ReceiverOpt.Type is { }); 1072return !fieldAccess.ReceiverOpt.Type.IsValueType || CanBePassedByReference(fieldAccess.ReceiverOpt); 1148Debug.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) 803throw ExceptionUtilities.UnexpectedValue(input.Type); 813var lessThanOrEqualOperator = input.Type.SpecialType switch 818_ => throw ExceptionUtilities.UnexpectedValue(input.Type.SpecialType) 821var cases = node.Cases.Sort(new CasesComparer(input.Type));

202TypeSymbol inputType = input.Type; 215Conversion conversion = _factory.Compilation.Conversions.ClassifyBuiltInConversion(inputType, output.Type, isChecked: false, ref useSiteInfo); 223inputType.GetNullableUnderlyingType().Equals(output.Type, TypeCompareKind.AllIgnoreOptions) && 344Debug.Assert(input.Type is { }); 348return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullNotEqual : BinaryOperatorKind.NotEqual); 355return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullEqual : BinaryOperatorKind.Equal); 358Debug.Assert(!input.Type.IsNullableType()); 362Debug.Assert(!input.Type.IsNullableType()); 363Debug.Assert(input.Type.IsValueType); 373Debug.Assert(!rewrittenExpr.Type.IsSpanOrReadOnlySpanChar()); 375if (rewrittenExpr.Type.IsPointerOrFunctionPointer()) 393if (value.IsString && input.Type.IsSpanOrReadOnlySpanChar()) 398TypeSymbol comparisonType = input.Type.EnumUnderlyingTypeOrSelf(); 407if (input.Type.SpecialType == SpecialType.System_Double && double.IsNaN(value.DoubleValue) || 408input.Type.SpecialType == SpecialType.System_Single && float.IsNaN(value.SingleValue)) 414BoundExpression literal = _localRewriter.MakeLiteral(syntax, value, input.Type); 415TypeSymbol comparisonType = input.Type.EnumUnderlyingTypeOrSelf(); 437var isReadOnlySpan = input.Type.IsReadOnlySpanChar(); 479Debug.Assert(output.Type is { }); 481testExpression = _factory.ObjectNotEqual(output, _factory.Null(output.Type)); 515Debug.Assert(loweredInput.Type is { }); 556if (loweredInput.Type.IsTupleType && 557!loweredInput.Type.OriginalDefinition.Equals(_factory.Compilation.GetWellKnownType(WellKnownType.System_ValueTuple_TRest)) && 631var temp = new BoundDagTemp(expr.Syntax, expr.Type, fieldFetchEvaluation);

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

322TypeSymbol? 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); 576Debug.Assert(loweredLeft.Type is { }); 577whenNullOpt = RewriteLiftedBinaryOperator(syntax, operatorKind, _factory.Default(loweredLeft.Type), loweredRight, type, method, constrainedToTypeOpt); 587type: result.Type! 770conversion = _compilation.Conversions.ClassifyConversionFromType(loweredLeft.Type, parameterType, isChecked: operatorKind.IsChecked(), ref useSiteInfo); 908Debug.Assert(expression.Type is { }); 912if (expression.Type.IsNullableType()) 918UnsafeGetNullableMethod(syntax, expression.Type, SpecialMember.System_Nullable_T_GetValueOrDefault)); 931Debug.Assert(expression.Type is { }); 935if (expression.Type.IsNullableType()) 945Debug.Assert(expression.Type is { }); 950UnsafeGetNullableMethod(syntax, expression.Type, SpecialMember.System_Nullable_T_get_HasValue)); 1633Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2)); 1634Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2)); 1707Debug.Assert(alwaysNull.Type is { }); 1708BoundExpression nullBool = new BoundDefaultExpression(syntax, alwaysNull.Type); 1720rewrittenType: alwaysNull.Type, 1747rewrittenType: alwaysNull.Type, 1749Debug.Assert(conditionalExpression.Type is { }); 1755type: conditionalExpression.Type); 1809rewrittenType: newNullBool.Type!, 1816type: conditionalExpression.Type!); 1896rewrittenType: alternative.Type!, 1904type: conditionalExpression.Type!); 2002return conditionalAccess.Update(conditionalAccess.Receiver, conditionalAccess.HasValueMethodOpt, whenNotNull, whenNull, conditionalAccess.Id, conditionalAccess.ForceCopyOfNullableValueType, whenNotNull.Type!); 2058Debug.Assert(loweredLeft.Type is { SpecialType: SpecialType.System_Decimal }); 2059Debug.Assert(loweredRight.Type is { SpecialType: SpecialType.System_Decimal }); 2092TypeSymbol? exprType = rewrittenExpr.Type; 2155Debug.Assert(loweredRight.Type is { }); 2156TypeSymbol rightType = loweredRight.Type; 2222Debug.Assert(loweredLeft.Type is { }); 2223TypeSymbol leftType = loweredLeft.Type; 2227Debug.Assert(loweredRight.Type is { }); 2228TypeSymbol rightType = loweredRight.Type; 2278Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2279loweredRight = MakeSizeOfMultiplication(loweredRight, (PointerTypeSymbol)loweredLeft.Type, kind.IsChecked()); 2283Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer }); 2284loweredLeft = MakeSizeOfMultiplication(loweredLeft, (PointerTypeSymbol)loweredRight.Type, kind.IsChecked()); 2323Debug.Assert(sizeOfExpression.Type is { SpecialType: SpecialType.System_Int32 }); 2333Debug.Assert(numericOperand.Type is { }); 2334var numericSpecialType = numericOperand.Type.SpecialType; 2470Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2471Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer }); 2474PointerTypeSymbol pointerType = (PointerTypeSymbol)loweredLeft.Type;

102if (module != null && receiver != null && receiver.Type is { }) 104var assembly = receiver.Type.ContainingAssembly; 121if (module != null && receiver is { Type: { } }) 123var assembly = receiver.Type.ContainingAssembly; 203var symbolForCompare = needToReduce ? ReducedExtensionMethodSymbol.Create(interceptor, receiverOpt!.Type, _compilation, out _) : interceptor; // Tracked by https://github.com/dotnet/roslyn/issues/76130 : test interceptors 274Debug.Assert(receiverOpt?.Type is not null); 280Debug.Assert(receiverOpt.Type.Equals(interceptor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions) 281|| (!receiverOpt.Type.IsReferenceType && interceptor.Parameters[0].Type.IsReferenceType)); 509Debug.Assert(rewrittenBoundCall.Type is not null); 518type: rewrittenBoundCall.Type); 679Debug.Assert(rewrittenReceiver.Type is { }); 693refKind = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter ? RefKind.Ref : RefKind.None; 697if (rewrittenReceiver.Type.IsReferenceType) 1136optimized = CreateArrayEmptyCallIfAvailable(possibleParamsArray.Syntax, ((ArrayTypeSymbol)possibleParamsArray.Type!).ElementType);

176Debug.Assert(singleSpread.Expression.Type is not null); 178if (!ShouldUseIEnumerableBulkAddMethod(singleSpread.Expression.Type, toListOfElementType.Parameters[0].Type, singleSpread.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 224Elements: [BoundCollectionExpressionSpreadElement { Expression: { Type: NamedTypeSymbol spreadType } expr }], 316Debug.Assert(list.Type is { }); 317Debug.Assert(list.Type.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_Collections_Generic_List_T), TypeCompareKind.AllIgnoreOptions)); 319var listToArray = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_Collections_Generic_List_T__ToArray)).AsMember((NamedTypeSymbol)list.Type); 328Debug.Assert(TypeSymbol.Equals(array.Type, spanConstructor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions)); 665var spreadTypeOriginalDefinition = spreadExpression.Type!.OriginalDefinition; 671return _factory.Call(rewrittenSpreadExpression, listToArrayMethod.AsMember((NamedTypeSymbol)spreadExpression.Type!)); 681&& ShouldUseIEnumerableBulkAddMethod(spreadExpression.Type!, linqToArrayMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 688&& TryGetSpanConversion(spreadExpression.Type, writableOnly: false, out var asSpanMethod)) 690var spanType = CallAsSpanMethod(spreadExpression, asSpanMethod).Type!.OriginalDefinition; 695return _factory.Call(rewrittenSpreadExpression, toArrayMethod.AsMember((NamedTypeSymbol)rewrittenSpreadExpression.Type!)); 789Debug.Assert(arrayTemp.Type is ArrayTypeSymbol); 793var elementType = ((ArrayTypeSymbol)arrayTemp.Type).ElementType; 903var type = expression.Type; 970if (spreadOperandAsSpan.Type!.OriginalDefinition.Equals(this._compilation.GetWellKnownType(wellKnownSpanType)) 1009var spreadLength = _factory.Call(spreadOperandAsSpan, getLengthMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!)); 1010var targetSlice = _factory.Call(spanTemp, spanSliceMethod.AsMember((NamedTypeSymbol)spanTemp.Type!), indexTemp, spreadLength); 1011sideEffects.Add(_factory.Call(spreadOperandAsSpan, copyToMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!), targetSlice)); 1125Debug.Assert(spanTemp.Type is NamedTypeSymbol); 1129var elementType = ((NamedTypeSymbol)spanTemp.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 1178Debug.Assert(rewrittenSpreadOperand.Type is not null); 1183if (!ShouldUseIEnumerableBulkAddMethod(rewrittenSpreadOperand.Type, addRangeMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 1318_factory.Binary(BinaryOperatorKind.Addition, sum.Type!, sum, value); 1353if (convertedExpression.Operand.Type is ArrayTypeSymbol arrayType)

24Debug.Assert(TypeSymbol.Equals(node.Right.Type, node.Operator.RightType, TypeCompareKind.ConsiderEverything2)); 47TypeSymbol? leftType = node.Left.Type; // type of the target 139Debug.Assert(rewrittenAssignment.Type is { }); 142var condition = _factory.Conditional(isEvent, invokeEventAccessor.ToExpression(), rewrittenAssignment, rewrittenAssignment.Type); 144rewrittenAssignment = new BoundSequence(node.Syntax, eventTemps.ToImmutableAndFree(), sequence.ToImmutableAndFree(), condition, condition.Type!); 151Debug.Assert(rewrittenAssignment.Type is { }); 159rewrittenAssignment.Type); 202Debug.Assert(node.Left.Type is { }); 214Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.Left.Type, TypeCompareKind.AllIgnoreOptions)); 260Debug.Assert(rewrittenReceiver.Type is { }); 261var variableRepresentsLocation = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter; 471indexerAccess.Argument.Type, 478throw ExceptionUtilities.UnexpectedValue(indexerAccess.Argument.Type); 499if (isDynamicAssignment || !IsInvariantArray(arrayAccess.Expression.Type)) 527Debug.Assert(receiver is { Type: { } }); 532else if (!receiver.Type.IsReferenceType) 537Debug.Assert(receiver.Type.IsReferenceType); 541Debug.Assert(rewrittenReceiver.Type is { }); 542if (rewrittenReceiver.Type.IsTypeParameter()) 680Debug.Assert(implicitIndexerAccess.Argument.Type!.Equals(_compilation.GetWellKnownType(WellKnownType.System_Index)) 681|| implicitIndexerAccess.Argument.Type!.Equals(_compilation.GetWellKnownType(WellKnownType.System_Range))); 710if (isDynamicAssignment || !IsInvariantArray(arrayAccess.Expression.Type)) 891var type = expression.Type; 907var type = expression.Type; 963Debug.Assert(expression.Type is { }); 964if (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)); 289type: result.Type); 312@checked = @checked && NeedsCheckedConversionInExpressionTree(rewrittenOperand.Type, rewrittenType, explicitCastInCode); 318Debug.Assert(rewrittenOperand.Type is { }); 331if (_inExpressionLambda || !rewrittenOperand.Type.Equals(rewrittenType, TypeCompareKind.ConsiderEverything)) 426Debug.Assert(rewrittenOperand.Type is { }); 432if (rewrittenType.SpecialType == SpecialType.System_Decimal || rewrittenOperand.Type.SpecialType == SpecialType.System_Decimal) 434return RewriteDecimalConversion(syntax, rewrittenOperand, rewrittenOperand.Type, rewrittenType, @checked, conversion.Kind.IsImplicitConversion(), constantValueOpt); 441Debug.Assert(rewrittenOperand.Type is { }); 444Debug.Assert(rewrittenOperand.Type.Equals(rewrittenType, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 487Debug.Assert(rewrittenOperand.Type is { }); 497Debug.Assert(rewrittenOperand.Type.IsEnumType()); 498var underlyingTypeFrom = rewrittenOperand.Type.GetEnumUnderlyingType()!; 502else if (rewrittenOperand.Type.SpecialType == SpecialType.System_Decimal) 510var rewrittenNode = RewriteDecimalConversion(syntax, rewrittenOperand, rewrittenOperand.Type, underlyingTypeTo, @checked, isImplicit: false, constantValueOpt: constantValueOpt); 555(symbolOpt.IsAbstract || symbolOpt.IsVirtual) ? mg.ReceiverOpt?.Type : null, 594Debug.Assert(rewrittenOperand.Type is not null); 609createSpan = createSpan.Construct(rewrittenOperand.Type, spanType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type); 610_ = rewrittenOperand.Type.HasInlineArrayAttribute(out int length); 618var sourceType = rewrittenOperand.Type; 815Debug.Assert(rewrittenOperand.Type is { }); 817Conversion conversion = compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, isChecked: @checked, ref useSiteInfo); 823rewrittenOperand.Type.SpecialType != SpecialType.System_Decimal && 824rewrittenOperand.Type.SpecialType != SpecialType.System_DateTime) 830rewrittenOperand.Type, 876if (!TypeSymbol.Equals(rewrittenOperand.Type, conversion.BestUserDefinedConversionAnalysis.FromType, TypeCompareKind.ConsiderEverything2)) 886if (!TypeSymbol.Equals(rewrittenOperand.Type, conversion.Method.GetParameterType(0), TypeCompareKind.ConsiderEverything2)) 899Debug.Assert(rewrittenOperand.Type is { }); 900if (rewrittenOperand.Type.IsNullableType() && 901conversion.Method.GetParameterType(0).Equals(rewrittenOperand.Type.GetNullableUnderlyingType(), TypeCompareKind.AllIgnoreOptions) && 905userDefinedConversionRewrittenType = ((NamedTypeSymbol)rewrittenOperand.Type.OriginalDefinition).Construct(userDefinedConversionRewrittenType); 915if (!TypeSymbol.Equals(userDefined.Type, conversion.BestUserDefinedConversionAnalysis.ToType, TypeCompareKind.ConsiderEverything2)) 924if (!TypeSymbol.Equals(userDefined.Type, rewrittenType, TypeCompareKind.ConsiderEverything2)) 956Debug.Assert(rewrittenOperand.Type is { }); 960var tupleTypeSymbol = (NamedTypeSymbol)rewrittenOperand.Type; 997Debug.Assert(expression.Type is { }); 998if (!expression.Type.IsNullableType()) 1010when convertedArgument.Type!.Equals(expression.Type.StrippedType(), TypeCompareKind.AllIgnoreOptions): 1015when underlying.Length == 1 && underlying[0].Kind == ConversionKind.ImplicitTuple && !convertedArgument.Type!.IsNullableType(): 1050TypeSymbol? rewrittenOperandType = rewrittenOperand.Type; 1100Debug.Assert(rewrittenOperand.Type is { }); 1101TypeSymbol rewrittenOperandType = rewrittenOperand.Type; 1314Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2)); 1315Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2)); 1347Debug.Assert(rewrittenOperand.Type is { }); 1348if (rewrittenOperand.Type.IsNullableType()) 1351if (parameterType.Equals(rewrittenOperand.Type.GetNullableUnderlyingType(), TypeCompareKind.AllIgnoreOptions) && 1365if ((rewrittenOperand.Type.IsArray()) && _compilation.IsReadOnlySpanType(rewrittenType)) 1377Debug.Assert(TypeSymbol.Equals(result.Type, rewrittenType, TypeCompareKind.ConsiderEverything2)); 1400Debug.Assert(rewrittenOperand.Type is { }); 1403Conversion conv = TryMakeConversion(syntax, conversion, rewrittenOperand.Type, rewrittenType, @checked: @checked); 1415Debug.Assert(rewrittenOperand.Type.IsNullableType()); 1492Debug.Assert(rewrittenOperand.Type is { }); 1495TypeSymbol source = rewrittenOperand.Type; 1718Debug.Assert(operand.Type is { }); 1719return 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: { } }); 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; 445TypeSymbol? initializerType = initializerExpr.Type; 514TypeSymbol? initializerType = initializerExpr.Type;

42TypeSymbol? nodeExpressionType = collectionExpression.Type; 496Debug.Assert(receiver.Type is { }); 497if (!receiver.Type.IsReferenceType && method.ContainingType.IsInterface) 595NamedTypeSymbol? collectionType = (NamedTypeSymbol?)collectionExpression.Type; 734Debug.Assert(rewrittenExpression.Type is not null); 863Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 891Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 895ArrayTypeSymbol arrayType = (ArrayTypeSymbol)collectionExpression.Type; 1012Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 1040Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 1044ArrayTypeSymbol arrayType = (ArrayTypeSymbol)collectionExpression.Type;

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

119Debug.Assert(oldNode.Type is not null); 120Debug.Assert(oldNode.Type.Equals(type, TypeCompareKind.ConsiderEverything)); 180Debug.Assert(call.Type is not null); 194call.Type); 203Debug.Assert(node.Expression.Type is object); 204Debug.Assert(node.Argument.Type is object); 219_ = node.Expression.Type.HasInlineArrayAttribute(out int length); 221if (node.Argument.Type.SpecialType == SpecialType.System_Int32) 229if (TypeSymbol.Equals(node.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.AllIgnoreOptions)) 241Debug.Assert(TypeSymbol.Equals(node.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.AllIgnoreOptions)); 323Debug.Assert(node.Expression.Type is object); 335return createSpan.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type); 340Debug.Assert(node.Expression.Type is object); 341Debug.Assert(index.Type?.SpecialType == SpecialType.System_Int32); 343var intType = (NamedTypeSymbol)index.Type; 362elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type); 381elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type); 436node.Argument.Type, 445node.Argument.Type, 483node.Argument.Type, 499Debug.Assert(receiver.Type is { }); 505receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref); 563Debug.Assert(integerArgument.Type!.SpecialType == SpecialType.System_Int32); 659Debug.Assert(loweredExpr.Type!.SpecialType == SpecialType.System_Int32); 670Debug.Assert(loweredExpr.Type!.SpecialType == SpecialType.System_Int32); 677loweredExpr.Type, 710unloweredExpr.Type, 718Debug.Assert(hatExpression.Operand is { Type: { SpecialType: SpecialType.System_Int32 } }); 722else if (unloweredExpr is BoundConversion { Operand: { Type: { SpecialType: SpecialType.System_Int32 } } operand }) 731arguments[0] is { Type.SpecialType: SpecialType.System_Int32, ConstantValueOpt.Value: int _ and >= 0 } index && 732arguments[1] is { Type.SpecialType: SpecialType.System_Boolean, ConstantValueOpt.Value: bool fromEnd }) 775node.Argument.Type, 801Debug.Assert(receiver.Type is { }); 807receiver.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)); 45var leftPlaceholder = new BoundValuePlaceholder(lhsRead.Syntax, lhsRead.Type); 46BoundExpression conditionalExpression = MakeNullCoalescingOperator(syntax, lhsRead, assignment, leftPlaceholder: leftPlaceholder, leftConversion: leftPlaceholder, BoundNullCoalescingOperatorResultKind.LeftType, node.LeftOperand.Type); 47Debug.Assert(conditionalExpression.Type is { }); 56conditionalExpression.Type); 63Debug.Assert(node.LeftOperand.Type.IsNullableType()); 72leftOperand.Type, 80leftOperand.Type, 112Debug.Assert(transformedLHS.Type.GetNullableUnderlyingType().Equals(tmp.Type.StrippedType(), TypeCompareKind.AllIgnoreOptions)); 115Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.LeftOperand.Type, TypeCompareKind.AllIgnoreOptions)); 120MakeConversionNode(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)); 320return 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.GetIsNewExtensionMember() && !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;

222not (BoundCall or BoundConversion { ConversionKind: ConversionKind.Boxing, Type.SpecialType: SpecialType.System_Object, Operand.Type.SpecialType: SpecialType.System_Char }) 286if (argument is BoundConversion { ConversionKind: ConversionKind.Boxing, Type.SpecialType: SpecialType.System_Object, Operand: { Type.SpecialType: SpecialType.System_Char } operand }) 307else if (argument is BoundNullCoalescingOperator { LeftOperand: { Type.SpecialType: SpecialType.System_String } left, RightOperand: BoundLiteral { ConstantValueOpt: { IsString: true, RopeValue.IsEmpty: true } } }) 397if (call is { Arguments: [], ReceiverOpt.Type: NamedTypeSymbol { SpecialType: SpecialType.System_Char } charType, Method: { Name: "ToString" } method } 474Debug.Assert(arg.Type is not null); 476if (arg.Type.SpecialType == SpecialType.System_Char) 505Debug.Assert(arg.HasAnyErrors || arg.Type.SpecialType == SpecialType.System_String); 605Debug.Assert(expr.Type is not null); 608if (expr.Type.IsStringType()) 620if (expr.Type.IsValueType && !expr.Type.IsTypeParameter()) 622var type = (NamedTypeSymbol)expr.Type; 643expr.Type.SpecialType.CanOptimizeBehavior() && 659bool callWithoutCopy = expr.Type.IsReferenceType || 661(structToStringMethod == null && !expr.Type.IsTypeParameter()) || 665if (expr.Type.IsValueType) 669expr = new BoundPassByCopy(syntax, expr, expr.Type); 701new BoundConditionalReceiver(syntax, currentConditionalAccessID, expr.Type),

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)); 90expr.Type is { } exprType && exprType.IsNullableType() && exprType.StrippedType().Equals(o.Type, TypeCompareKind.AllIgnoreOptions): 107Debug.Assert(expr.Type is { }); 108var destElementTypes = expr.Type.TupleElementTypesWithAnnotations; 110Debug.Assert(boundConversion.Operand.Type is { }); 111var srcElementFields = boundConversion.Operand.Type.TupleElements; 127ImmutableArray<bool>.Empty, expr.Type, expr.HasErrors); 163ImmutableArray<bool>.Empty, tuple.Type, tuple.HasErrors); 206return new BoundLiteral(expr.Syntax, ConstantValue.Null, expr.Type); 356isNullable = !(expr is BoundTupleExpression) && expr.Type is { } && expr.Type.IsNullableType(); 368Debug.Assert(expr.Type is { }); 371value = new BoundDefaultExpression(expr.Syntax, expr.Type.StrippedType()); 398Debug.Assert(expr.Type is { }); 404when expr.Type.IsNullableType() && o.Type is { } && o.Type.IsNullableType() && !underlying[0].IsUserDefined: 438expr.Type is { } exprType && exprType.IsNullableType() && o.Type is { } && o.Type.IsNullableType() && nested[0] is { IsTupleConversion: true } tupleConversion: 440Debug.Assert(expr.Type is { }); 443Debug.Assert(operand.Type is { }); 444var types = expr.Type.GetNullableUnderlyingType().TupleElementTypesWithAnnotations; 445int tupleCardinality = operand.Type.TupleElementTypesWithAnnotations.Length; 461type: expr.Type, 524Debug.Assert(tuple.Type is { IsTupleType: true }); 530return MakeTupleFieldAccessAndReportUseSiteDiagnostics(tuple, tuple.Syntax, tuple.Type.TupleElements[i]);

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

132var underlyingType = loweredOperand.Type.GetEnumUnderlyingType(); 276Debug.Assert(result.Type is { }); 285type: result.Type 328Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2)); 329Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2)); 416TypeSymbol? operandType = node.Operand.Type; //type of the variable being incremented 444TypeSymbol? operandType = left.Type; //type of the variable being incremented 453Debug.Assert(TypeSymbol.Equals(operandType, transformedLHS.Type, TypeCompareKind.AllIgnoreOptions)); 572TypeSymbol? operandType = transformedLHS.Type; //type of the variable being incremented 645Debug.Assert(boundTemp.Type is not null); 660type: boundTemp.Type); 673Debug.Assert(boundTemp.Type is not null); 676Debug.Assert(tempValue.Type is { }); 685tempValue.Type); 699type: boundTemp.Type); 905Debug.Assert(binaryOperand.Type is { TypeKind: TypeKind.Pointer }); 906Debug.Assert(boundOne.Type is { SpecialType: SpecialType.System_Int32 }); 907return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null, constrainedToTypeOpt: null); 959Debug.Assert(operand.Type is { SpecialType: SpecialType.System_Decimal }); 966Debug.Assert(operand.Type is { } && operand.Type.IsNullableType() && operand.Type.GetNullableUnderlyingType().SpecialType == SpecialType.System_Decimal); 970MethodSymbol getValueOrDefault = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T_GetValueOrDefault); 971MethodSymbol ctor = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T__ctor); 982BoundExpression alternative = new BoundDefaultExpression(syntax, operand.Type); 985return RewriteConditionalOperator(syntax, condition, consequence, alternative, ConstantValue.NotAvailable, operand.Type, isRef: false);

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

544Debug.Assert(loweredReceiver.Type is { }); 545if (!loweredReceiver.Type.IsValueType) 829var argType = boundArgument.Type; 908result[j++] = receiver.Type ?? systemObjectType; 914result[j++] = arguments[i].Type ?? systemObjectType; 920result[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) 1034Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType); 1043var receiverType = receiver.Type; 1074if (!receiver.Type.IsReferenceType && LocalRewriter.CanBePassedByReference(receiver)) 1076result = receiver.Type.IsReadOnly ? RefKind.In : RefKind.Ref; 1147Debug.Assert(condition.Type.SpecialType == SpecialType.System_Boolean); 1150var tmp = _F.SynthesizedLocal(condition.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax); 1197type: node.Type)); 1254_F.ObjectEqual(_F.Local(tmp), _F.Null(left.Type)), 1286if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None) 1306var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill); 1310var isNotClass = _F.IsNotNullReference(_F.Default(receiver.Type)); 1478return UpdateExpression(builder, node.Update(operand, node.Type)); 1522return UpdateExpression(builder, node.Update(expression, node.Type));

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

150Debug.Assert(thisProxyReplacement.Type is not null); 151this.cachedThis = F.SynthesizedLocal(thisProxyReplacement.Type, syntax: F.Syntax, kind: SynthesizedLocalKind.FrameCache); 566Debug.Assert(TypeSymbol.Equals(type, replacement.Type, TypeCompareKind.ConsiderEverything2)); 685TypeSymbol fieldType = expr.Type; 712hoistedField = F.StateMachineField(expr.Type, fieldName, new LocalSlotDebugInfo(kind, id), slotIndex);

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); 657Conversion c = Compilation.Conversions.ClassifyBuiltInConversion(operand.Type, type, isChecked: false, ref discardedUseSiteInfo); 663Debug.Assert(left.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean); 664Debug.Assert(right.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean); 670Debug.Assert(left.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean); 671Debug.Assert(right.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean); 785switch (input.Type) 794throw ExceptionUtilities.UnexpectedValue(input.Type); 919Debug.Assert(valueTypeReceiver.Type is { }); 920Debug.Assert(TypeSymbol.Equals(valueTypeReceiver.Type, referenceTypeReceiver.Type, TypeCompareKind.ConsiderEverything2)); 921return new BoundComplexConditionalReceiver(Syntax, valueTypeReceiver, referenceTypeReceiver, valueTypeReceiver.Type) { WasCompilerGenerated = true }; 926Debug.Assert(left.Type!.Equals(right.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes) || left.Type.IsErrorType()); 927Debug.Assert(left.Type.IsReferenceType); 929return new BoundNullCoalescingOperator(Syntax, left, right, leftPlaceholder: null, leftConversion: null, BoundNullCoalescingOperatorResultKind.LeftType, @checked: false, left.Type) { WasCompilerGenerated = true }; 1037Debug.Assert(result.Type is { }); 1038var resultType = type ?? result.Type; 1044Debug.Assert(result.Type is { }); 1048: new BoundSequence(Syntax, locals, sideEffects, result, result.Type) { WasCompilerGenerated = true }; 1053Debug.Assert(result.Type is { }); 1054return new BoundSpillSequence(Syntax, locals, sideEffects, result, result.Type) { WasCompilerGenerated = true }; 1083Debug.Assert(ex.Type is { SpecialType: CodeAnalysis.SpecialType.System_Int32 }); 1178Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1184Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1185int rank = ((ArrayTypeSymbol)array.Type).Rank; 1197Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1198return new BoundArrayAccess(Syntax, array, indices, ((ArrayTypeSymbol)array.Type).ElementType); 1484if (TypeSymbol.Equals(type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1498arg.Type is TypeParameterSymbol { AllowsRefLikeType: true } && type.IsObjectType()) 1514if (conversion.Method is { } && !TypeSymbol.Equals(conversion.Method.Parameters[0].Type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1524Debug.Assert(arg.Type is { }); 1526arg.Type.IsNullableType() && 1527arg.Type.GetNullableUnderlyingType().Equals(type, TypeCompareKind.AllIgnoreOptions)) 1531return this.Call(arg, this.SpecialMethod(CodeAnalysis.SpecialMember.System_Nullable_T_get_Value).AsMember((NamedTypeSymbol)arg.Type)); 1620return new BoundCatchBlock(Syntax, ImmutableArray<LocalSymbol>.Empty, source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false); 1640Debug.Assert(expression is { Type: { SpecialType: CodeAnalysis.SpecialType.System_Boolean } }); 1641return new BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.BoolLogicalNegation, expression, null, null, constrainedToTypeOpt: null, LookupResultKind.Viable, expression.Type); 1661Debug.Assert(argument.Type is { }); 1694var type = argument.Type; 1764TypeSymbol exprType = rewrittenExpr.Type; 1818LocalRewriter.UnsafeGetNullableMethod(syntax, expression.Type, CodeAnalysis.SpecialMember.System_Nullable_T_get_HasValue, Compilation, Diagnostics)); 1882return conditionalAccess.Update(conditionalAccess.Receiver, conditionalAccess.HasValueMethodOpt, whenNotNull, whenNull, conditionalAccess.Id, conditionalAccess.ForceCopyOfNullableValueType, whenNotNull.Type);

1082if (boundOperand.Kind == BoundKind.ConvertedTupleLiteral && TypeSymbol.Equals(boundOperand.Type, boundConversion.Type, TypeCompareKind.ConsiderEverything2)) 1103!TypeSymbol.Equals(nestedConversion.Type, nestedOperand.Type, TypeCompareKind.ConsiderEverything2)) 1596boundNullCoalescingOperator.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())

974conversion.IsIdentity && parameterType.SpecialType == SpecialType.System_Object && defaultExpression.Type.IsDynamic()) 988(object)defaultExpression.Type != null && 989defaultExpression.Type.SpecialType == SpecialType.System_String || 999else if (((conversion.IsNullable && !defaultExpression.Type.IsNullableType()) || 1000(conversion.IsObjectCreation && convertedExpression.Type.IsNullableType())) && 1017(defaultExpression.IsImplicitObjectCreation() ? convertedExpression.Type.StrippedType() : defaultExpression.Type), parameterSyntax.Identifier.ValueText);

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

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

392public override TypeWithAnnotations ReturnTypeWithAnnotations => TypeWithAnnotations.Create(_getAwaiterGetResultCall.Type);