Binder\Binder.ValueChecks.cs (32)
923Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter());
950if ((expr.ConstantValueOpt != null) || (expr.Type.GetSpecialTypeSafe() == SpecialType.System_Void))
1140getItemOrSliceHelper = getItemOrSliceHelper.AsMember(getItemOrSliceHelper.ContainingType.Construct(ImmutableArray.Create(elementAccess.Expression.Type.TryGetInlineArrayElementField().TypeWithAnnotations)));
1211indices[0].Type,
1244Error(diagnostics, ErrorCode.ERR_BadSKunknown, expr.Syntax, expr.Type, MessageID.IDS_SK_TYPE.Localize());
1883&& receiver?.Type?.IsValueType == true;
2115if (receiver is BoundObjectOrCollectionValuePlaceholder && receiver.Type.IsAnonymousType)
2279if (methodInvocationInfo.MethodInfo.Method?.RequiresInstanceReceiver == true && methodInvocationInfo.Receiver?.Type?.IsRefLikeOrAllowsRefLikeType() == true)
2505if (receiver?.Type?.IsRefLikeOrAllowsRefLikeType() == true)
2618Debug.Assert(receiver.Type is { });
2623Debug.Assert(receiver is not BoundValuePlaceholderBase && method is not null && receiver.Type?.IsReferenceType == false);
2628receiver = new BoundCapturedReceiverPlaceholder(receiver.Syntax, receiver, _localScopeDepth, receiver.Type).MakeCompilerGenerated();
2747if (receiver.Type is TypeParameterSymbol typeParameter)
2986if (argument.Type?.IsRefLikeOrAllowsRefLikeType() == true)
3046if (argument.Type?.IsRefLikeOrAllowsRefLikeType() == true)
3178&& argument.Type?.IsRefLikeOrAllowsRefLikeType() == true)
3640Debug.Assert(expr.Type is not null);
3672if (expr.Type?.GetSpecialTypeSafe() == SpecialType.System_Void)
3938Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter());
3953if (expr.Type?.GetSpecialTypeSafe() == SpecialType.System_Void)
4311if (expr.Type?.IsRefLikeOrAllowsRefLikeType() != true)
4724RoslynDebug.Assert(false, $"{expr.Kind} expression of {expr.Type} type");
4949Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter());
4970if (expr.Type?.IsRefLikeOrAllowsRefLikeType() != true)
5035Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeStackAlloc : ErrorCode.ERR_EscapeStackAlloc, node, expr.Type);
5290Error(diagnostics, ErrorCode.ERR_CollectionExpressionEscape, node, expr.Type);
5480RoslynDebug.Assert(false, $"{expr.Kind} expression of {expr.Type} type");
5653TypeWithAnnotations.Create(elementAccess.Expression.Type),
5693TypeWithAnnotations.Create(inlineArray.Type),
Binder\Binder_Await.cs (15)
32var placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type);
87var type = expression.Type;
268Debug.Assert(TypeSymbol.Equals(expression.Type, getAwaiterArgument.Type, TypeCompareKind.ConsiderEverything));
304TypeSymbol awaiterType = getAwaiter.Type!;
305return GetIsCompletedProperty(awaiterType, node, expression.Type!, diagnostics, out isCompleted)
307&& GetGetResultMethod(getAwaiter, node, expression.Type!, diagnostics, out getResult, out getAwaiterGetResultCall)
332if (expression.Type is not NamedTypeSymbol { Arity: 0 or 1 } exprType)
359placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type);
549if (expression.Type is null)
571RoslynDebug.Assert(expression.Type is object);
572if (expression.Type.IsVoidType())
588Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
599Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
683var awaiterType = awaiterExpression.Type;
Binder\Binder_Conversions.cs (39)
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);
1492TypeSymbol? receiverType = methodGroup.ReceiverOpt.Type;
1969Debug.Assert(targetTyped || destination.IsErrorType() || destination.Equals(source.Type, TypeCompareKind.ConsiderEverything));
1988source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.ReachabilityDecisionDag,
2074conversion: Conversions.ClassifyStandardConversion(convertedOperand.Type, conversionParameterType, ref useSiteInfo),
2679RoslynDebug.Assert(receiverOpt.Type is object);
2681diagnostics.Add(ErrorCode.ERR_QueryNoProvider, node.Location, receiverOpt.Type, memberSymbol.Name);
2699RoslynDebug.Assert(receiverOpt.Type is object);
2700diagnostics.Add(ErrorCode.ERR_BadAwaitArg, node.Location, receiverOpt.Type);
2835(Conversions.ConvertExtensionMethodThisArg(GetReceiverParameter(method)!.Type, receiverOpt!.Type, ref useSiteInfo, isMethodGroupConversion: true).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty()));
Binder\Binder_Deconstruct.cs (20)
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)
321Debug.Assert(single.Type is not null);
323nestedConversion = this.Conversions.ClassifyConversionFromType(tupleOrDeconstructedTypes[i], single.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
329GenerateImplicitConversionError(diagnostics, Compilation, single.Syntax, nestedConversion, tupleOrDeconstructedTypes[i], single.Type);
336nestedConversion, isCast: false, conversionGroupOpt: null, single.Type, diagnostics)));
357if ((object?)pending.Type != null)
421Debug.Assert((object?)variables[i].Single!.Type != null);
481TypeSymbol? mergedType = element.Type;
502if ((object?)variable.Single.Type != null)
505mergedType = variable.Single.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);
Binder\Binder_Expressions.cs (98)
204TypeSymbol resultType = expr.Type;
297var commonType = expr.Type;
369case BoundStackAllocArrayCreation { Type: null } boundStackAlloc:
570TypeSymbol exprType = expr.Type;
987subExpressions.SelectAsArray(e => TypeWithAnnotations.Create(e.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);
1684type: expression.Type,
2592(object)operand.Type != null &&
2593!operand.Type.IsNullableType() &&
2594!TypeSymbol.Equals(targetType.GetNullableUnderlyingType(), operand.Type, TypeCompareKind.ConsiderEverything2))
2615if ((object)boundOperand.Type != null && boundOperand.Type.IsNullableType())
2694if (left?.Type.IsNullableType() == true || right?.Type.IsNullableType() == true)
2722if (boundOperand.Type?.IsNullableType() == true)
2814SymbolDistinguisher distinguisher1 = new SymbolDistinguisher(this.Compilation, operand.Type, targetType);
2863case BoundKind.UnconvertedConditionalOperator when operand.Type is null:
2864case BoundKind.UnconvertedSwitchExpression when operand.Type is null:
2888Debug.Assert((object)operand.Type != null);
2889SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, operand.Type, targetType);
2930Debug.Assert((object)operand.Type != null && !operand.Type.IsNullableType());
2936var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo);
3789Debug.Assert(receiver!.Type is not null);
3791placeholderType = receiver.Type;
4236if ((object)boundExpression.Type == null || !boundExpression.Type.IsErrorType())
4320Debug.Assert(init.Type.IsErrorType());
4730if (constantValue == null || constantValue.IsBad || expression.Type.SpecialType != SpecialType.System_Int32)
4753var type = expression.Type.SpecialType;
5303Debug.Assert(expression.Type is { });
5305var expressionPlaceholder = new BoundCollectionExpressionSpreadExpressionPlaceholder(syntax.Expression, expression.Type);
5318_ = expression.Type.HasInlineArrayAttribute(out int length);
5448else if ((object)argument.Type == null)
5460else if (argument.Type.TypeKind == TypeKind.Delegate)
5462var sourceDelegate = (NamedTypeSymbol)argument.Type;
5466if (ReportDelegateInvokeUseSiteDiagnostic(diagnostics, argument.Type, node: node))
5747Debug.Assert((object)boundLeft.Type != null);
5756type: boundLeft.Type,
6044type: boundMember.Type,
6458({ Type: null } or BoundLiteral or BoundUnconvertedInterpolatedString or BoundBinaryOperator { IsUnconvertedInterpolatedStringAddition: true }) &&
7529var leftType = boundValue.Type;
7537if (TypeSymbol.Equals(boundType.Type, leftType, TypeCompareKind.AllIgnoreOptions))
7569TypeSymbol.Equals(BindNamespaceOrType(id, BindingDiagnosticBag.Discarded).Type, type, TypeCompareKind.AllIgnoreOptions);
7673TypeSymbol leftType = boundLeft.Type;
7711leftType = boundLeft.Type;
7954Error(diagnostics, ErrorCode.WRN_DotOnDefault, node, boundLeft.Type);
8081var leftType = boundLeft.Type;
8216if ((object)boundLeft.Type == null)
8225Error(diagnostics, ErrorCode.ERR_NoSuchMember, name, boundLeft.Type, plainName);
8227else if (WouldUsingSystemFindExtension(boundLeft.Type, plainName))
8229Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtensionNeedUsing, name, boundLeft.Type, plainName, "System");
8233Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtension, name, boundLeft.Type, plainName);
8533Debug.Assert(left.Type is not null);
8534Debug.Assert(!left.Type.IsDynamic());
8626Debug.Assert(left.Type is not null);
8662firstResult = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics);
8688result = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics);
8707result = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics);
8735TypeSymbol? receiverType = left.Type;
8888TypeSymbol receiverType = receiver.Type;
9059if (receiverOpt is { Type: TypeParameterSymbol { AllowsRefLikeType: true } } &&
9101bool isUsableAsField = eventSymbol.HasAssociatedField && this.IsAccessible(eventSymbol.AssociatedField, ref useSiteInfo, (receiver != null) ? receiver.Type : null);
9341if ((object)expr.Type == null)
9362expr.Type.HasInlineArrayAttribute(out int length) && expr.Type.TryGetPossiblyUnsupportedByLanguageInlineArrayElementField() is FieldSymbol elementField)
9374Debug.Assert(expr.Type.TryGetInlineArrayElementField() is not null);
9394{ Code: (int)ErrorCode.ERR_BadIndexLHS, Arguments: [TypeSymbol type] } && type.Equals(expr.Type, TypeCompareKind.ConsiderEverything))
9521CheckInlineArrayTypeIsSupported(node, expr.Type, elementField.Type, diagnostics);
9572if (TypeSymbol.Equals(convertedIndex.Type, compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.AllIgnoreOptions))
9620Debug.Assert((object)expr.Type != null);
9623var exprType = expr.Type;
9666var arrayType = (ArrayTypeSymbol)expr.Type;
9713var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(expr.Syntax, isEquivalentToThisReference: expr.IsEquivalentToThisReference, expr.Type) { WasCompilerGenerated = true };
9877Debug.Assert(expr.Type.IsPointerType());
9878PointerTypeSymbol pointerType = (PointerTypeSymbol)expr.Type;
9924Debug.Assert((object)expr.Type != null);
9930this.LookupMembersWithFallback(lookupResult, expr.Type, WellKnownMemberNames.Indexer, arity: 0, useSiteInfo: ref useSiteInfo, options: lookupOptions);
10245var argType = argument.Type;
10251Debug.Assert(receiver.Type is not null);
10258var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(receiver.Syntax, isEquivalentToThisReference: receiver.IsEquivalentToThisReference, receiver.Type) { WasCompilerGenerated = true };
10267Debug.Assert(indexerOrSliceAccess.Type is not null);
10277indexerOrSliceAccess.Type);
10491Debug.Assert(receiverPlaceholder.Type is not null);
10492if (TryLookupLengthOrCount(syntax, receiverPlaceholder.Type, lookupResult, out var lengthOrCountProperty, diagnostics))
10851Debug.Assert(node.ReceiverOpt!.Type is not null); // extensions are only considered on member access
10881var substituted = (MethodSymbol?)extensionMember.GetReducedAndFilteredSymbol(typeArguments, receiver.Type, Compilation, checkFullyInferred: true);
10887else if (m.ReduceExtensionMethod(receiver.Type, Compilation) is { } reduced)
11066Debug.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;
Binder\Binder_InterpolatedString.cs (17)
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));
Binder\Binder_Invocation.cs (28)
284else if ((object)argument.Type == null && !argument.HasAnyErrors)
295else if (argument.Type.IsVoidType())
349if ((object)boundExpression.Type != null && boundExpression.Type.IsDynamic())
377else if (boundExpression.Type?.Kind == SymbolKind.FunctionPointerType)
564Debug.Assert(receiver.Type is not null);
565Error(diagnostics, ErrorCode.ERR_CannotDynamicInvokeOnExpression, receiver.Syntax, receiver.Type);
616Debug.Assert((object?)arg.Type != null);
619Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, arg.Type);
839Debug.Assert(methodGroup.ReceiverOpt != null && (object)methodGroup.ReceiverOpt.Type != null);
841Error(diagnostics, ErrorCode.ERR_BadArgTypeDynamicExtension, syntax, methodGroup.ReceiverOpt.Type, methodGroup.Name);
1068if (!call.HasAnyErrors && call.ReceiverOpt != null && (object)call.ReceiverOpt.Type != null && !call.Method.GetIsNewExtensionMember())
1073if (call.ReceiverOpt.Type.IsRestrictedType() && !call.Method.ContainingType.IsInterface && !TypeSymbol.Equals(call.Method.ContainingType, call.ReceiverOpt.Type, TypeCompareKind.ConsiderEverything2))
1075SymbolDistinguisher distinguisher = new SymbolDistinguisher(compilation, call.ReceiverOpt.Type, call.Method.ContainingType);
1091(object)dynInvoke.Expression.Type != null &&
1092dynInvoke.Expression.Type.IsRestrictedType())
1096Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, dynInvoke.Expression.Syntax, dynInvoke.Expression.Type);
1181case BoundUnconvertedSwitchExpression { Type: { } naturalType } switchExpr:
1400if (receiver is BoundValuePlaceholderBase || receiver?.Type is null or { IsReferenceType: true })
1848receiver.Type.IsValueType &&
1911!(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.
1966var type = expr.Type as NamedTypeSymbol;
2020var methodContainer = (object)receiver != null && (object)receiver.Type != null
2021? receiver.Type
2261var methodContainer = expr.Type ?? this.ContainingType;
2455RoslynDebug.Assert(boundExpression.Type is FunctionPointerTypeSymbol);
2457var funcPtr = (FunctionPointerTypeSymbol)boundExpression.Type;
Binder\Binder_Operators.cs (92)
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,
262var leftType = left.Type;
333var leftType = left.Type;
375var leftType = left.Type;
425var leftType = left.Type;
746TypeSymbol type = operand.Type;
774Debug.Assert((object)left.Type != null && left.Type.IsDynamic() || (object)right.Type != null && right.Type.IsDynamic());
798Error(diagnostics, ErrorCode.ERR_InvalidDynamicCondition, node.Left, left.Type, kind == BinaryOperatorKind.LogicalAnd ? "false" : "true");
804Debug.Assert(left.Type is not TypeParameterSymbol);
920TypeSymbol leftType = left.Type;
921TypeSymbol rightType = right.Type;
956Debug.Assert(right.Type.SpecialType == SpecialType.System_String);
957var stringConstant = FoldBinaryOperator(node, BinaryOperatorKind.StringConcatenation, left, right, right.Type, diagnostics);
958return new BoundBinaryOperator(node, BinaryOperatorKind.StringConcatenation, BoundBinaryOperator.UncommonData.UnconvertedInterpolatedStringAddition(stringConstant), LookupResultKind.Empty, left, right, right.Type);
1158TypeSymbol leftType = left.Type;
1159TypeSymbol rightType = right.Type;
1269(object)left.Type != null && left.Type.TypeKind == TypeKind.Delegate)
1273var conversion = this.Conversions.ClassifyConversionFromExpression(right, left.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo);
1275GenerateImplicitConversionError(diagnostics, right.Syntax, conversion, right, left.Type);
1297case (BoundKind.DefaultLiteral, _) when right.Type is TypeParameterSymbol:
1298Debug.Assert(!right.Type.IsReferenceType);
1299Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnUnconstrainedDefault, node, operatorToken.Text, right.Type);
1301case (_, BoundKind.DefaultLiteral) when left.Type is TypeParameterSymbol:
1302Debug.Assert(!left.Type.IsReferenceType);
1303Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnUnconstrainedDefault, node, operatorToken.Text, left.Type);
1322case LookupResultKind.OverloadResolutionFailure when operatorToken.Kind() is SyntaxKind.PlusToken && isReadOnlySpanOfByte(left.Type) && isReadOnlySpanOfByte(right.Type):
1389if ((object)left.Type != null && left.Type.SpecialType == SpecialType.System_Boolean &&
1390(object)right.Type != null && right.Type.SpecialType == SpecialType.System_Boolean)
1392var constantValue = FoldBinaryOperator(node, kind | BinaryOperatorKind.Bool, left, right, left.Type, diagnostics);
1396resultKind: LookupResultKind.Viable, left, right, type: left.Type, hasErrors: constantValue != null && constantValue.IsBad);
1484var operandPlaceholder = new BoundValuePlaceholder(resultLeft.Syntax, resultLeft.Type).MakeCompilerGenerated();
1487var conversion = this.Conversions.ClassifyConversionFromType(resultLeft.Type, trueFalseParameterType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
1544var type = left.Type;
1561if (left.Type is not null)
1563var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated();
1601var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated();
1604implicitConversion = this.Conversions.ClassifyConversionFromType(operandPlaceholder.Type, parameterType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
2016if (left.Type is null && right.Type is null)
2251(object)operand.Type != null &&
2252(operand.Type.SpecialType == SpecialType.System_UInt64 || isNuint(operand.Type)))
2304operand.Type is null) // GetUserDefinedOperators performs this check too, let's optimize early
2524return left.Type;
2527return right.Type;
2591BinaryOperatorKind newKind = kind.Operator().WithType(newLeftOperand.Type!.SpecialType);
3144var operandType = operand.Type;
3294var operandType = operand.Type;
3340Debug.Assert(operand.Type is not null);
3346operand.Type,
3382var operandType = operand.Type;
3528Debug.Assert(operand.Type is not null);
3903var operandType = operand.Type as PointerTypeSymbol;
3958TypeSymbol operandType = operand.Type;
4037if (receiver.Type.IsReferenceType)
4163if (isOperandNullOrNew || operand.Type?.IsErrorType() == true)
4191type: operand.Type!);
4240var underlyingType = operand.Type.GetEnumUnderlyingType()!;
4599if ((object)operand.Type == null && !operand.IsLiteralNull())
4658if ((object)operand.Type == null)
4669var convertedExpression = BindExpressionForPattern(operand.Type, node.Right, ref hasErrors, isPatternDiagnostics, out var constantValueOpt, out var wasExpression, out _);
4676node.Right, convertedExpression, constantValueOpt ?? ConstantValue.Bad, operand.Type, convertedExpression.Type ?? operand.Type, hasErrors)
4696if (operandHasErrors || IsOperatorErrors(node, operand.Type, typeExpression, diagnostics))
4717operand.Type.IsVoidType())
4747var operandType = operand.Type;
5147if ((object)operand.Type == null)
5209Debug.Assert(operand.Type is null);
5210operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated();
5224var operandType = operand.Type;
5257operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated();
5436TypeSymbol optLeftType = leftOperand.Type; // "A"
5437TypeSymbol optRightType = rightOperand.Type; // "B"
5612TypeSymbol leftType = leftOperand.Type;
5630if (underlyingRightConversion.Exists && rightOperand.Type?.IsDynamic() != true)
5771TypeSymbol trueType = trueExpr.Type;
5772TypeSymbol falseType = falseExpr.Type;
Binder\Binder_Patterns.cs (20)
25TypeSymbol? expressionType = expression.Type;
38Debug.Assert(expression.Type is { });
39BoundPattern pattern = BindPattern(node.Pattern, expression.Type, permitDesignations: true, hasErrors, diagnostics, underIsPattern: true);
66Debug.Assert(expression.Type is object);
67diagnostics.Add(ErrorCode.ERR_IsPatternImpossible, node.Location, expression.Type);
83Debug.Assert(expression.Type is object);
84diagnostics.Add(ErrorCode.WRN_IsPatternAlways, node.Location, expression.Type);
249Debug.Assert(indexerAccess.Type is not null);
250sliceType = indexerAccess.Type;
323Debug.Assert(indexerAccess!.Type is not null);
324elementType = indexerAccess.Type;
428var convertedType = convertedExpression.Type ?? inputType;
516Debug.Assert(expression is { Kind: BoundKind.TypeExpression, Type: { } });
517hasErrors |= CheckValidPatternType(patternExpression, inputType, expression.Type, diagnostics: diagnostics);
579if (convertedExpression.Type is null && constantValueOpt != ConstantValue.Null)
620RoslynDebug.Assert(expression.Type is { });
621ConstantValue match = ExpressionOfTypeMatchesPatternType(Conversions, inputType, expression.Type, ref useSiteInfo, out _, operandConstantValue: null);
653if (expression.Type?.SpecialType == SpecialType.System_String && inputType.IsSpanOrReadOnlySpanChar())
708(conversion.ConversionKind == ConversionKind.NoConversion && convertedExpression.Type?.IsErrorType() == true))
1634var type = value.Type ?? inputType;
Binder\Binder_Query.cs (14)
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())
Binder\Binder_QueryErrors.cs (7)
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;
Binder\Binder_Statements.cs (26)
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());
1622if (!hasErrors && op1.Type.IsRefLikeOrAllowsRefLikeType())
1853Debug.Assert((object)receiver.Type != null);
1854return receiver.Type;
1980this.Conversions.ClassifyConversionFromType(expression.Type, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
2012expression.Type,
2472var sourceType = operand.Type;
3078hasErrors |= arg.HasErrors || ((object)arg.Type != null && arg.Type.IsErrorType());
3153if ((object)arg?.Type != null && arg.Type.IsVoidType())
3217&& TypeSymbol.Equals(argument.Type, this.GetCurrentReturnType(out unusedRefKind), TypeCompareKind.ConsiderEverything2))
3220Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType, argument.Type);
3554else if (expression.Type?.SpecialType == SpecialType.System_Void)
Binder\Binder_Symbols.cs (3)
1507receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Ambiguous, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(receiver), receiver.Type, hasErrors: true).MakeCompilerGenerated();
1516Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtension, right, receiver.Type, plainName);
1517receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, childBoundNodes: [receiver], receiver.Type, hasErrors: true).MakeCompilerGenerated();
Binder\ForEachLoopBinder.cs (21)
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(),
Binder\Semantics\Conversions\ConversionsBase.cs (13)
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))
Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (35)
78TypeSymbol leftOperatorSourceOpt = left.Type?.StrippedType();
79TypeSymbol rightOperatorSourceOpt = right.Type?.StrippedType();
373var leftType = left.Type;
375var rightType = right.Type;
517bool isExactSubtraction = TypeSymbol.Equals(right.Type?.StrippedType(), underlying, TypeCompareKind.ConsiderEverything2);
621var leftType = left.Type;
627var rightType = right.Type;
696var leftType = left.Type as PointerTypeSymbol;
697var rightType = right.Type as PointerTypeSymbol;
712if ((object)leftType != null || (object)rightType != null || left.Type is FunctionPointerTypeSymbol || right.Type is FunctionPointerTypeSymbol)
734if ((left.Type is TypeParameterSymbol { AllowsRefLikeType: true } && right.IsLiteralNull()) ||
735(right.Type is TypeParameterSymbol { AllowsRefLikeType: true } && left.IsLiteralNull()))
754this.Compilation.BuiltInOperators.GetSimpleBuiltInOperators(kind, operators, skipNativeIntegerOperators: !left.Type.IsNativeIntegerOrNullableThereof() && !right.Type.IsNativeIntegerOrNullableThereof());
769this.Compilation.BuiltInOperators.GetUtf8ConcatenationBuiltInOperator(left.Type, operators);
780BuiltInOperators.IsValidObjectEquality(conversions, left.Type, left.IsLiteralNull(), leftIsDefault: false, right.Type, right.IsLiteralNull(), rightIsDefault: false, ref useSiteInfo) &&
781((object)left.Type == null || (!left.Type.IsDelegateType() && left.Type.SpecialType != SpecialType.System_String && left.Type.SpecialType != SpecialType.System_Delegate)) &&
782((object)right.Type == null || (!right.Type.IsDelegateType() && right.Type.SpecialType != SpecialType.System_String && right.Type.SpecialType != SpecialType.System_Delegate));
792return (operand.Type is TypeParameterSymbol { AllowsRefLikeType: true }) ? Conversion.Boxing : Conversions.ClassifyConversionFromExpression(operand, objectType, isChecked: isChecked, ref useSiteInfo);
1440if (left.Type?.IsNullableType() == true || right.Type?.IsNullableType() == true) // Wouldn't be applicable to the receiver type otherwise
1588if (left.Type is not null && parameterMatchesReceiver(in candidate, 0) && isOperandApplicableToReceiver(in candidate, left, ref useSiteInfo))
1593if (!kind.IsShift() && right.Type is not null && parameterMatchesReceiver(in candidate, 1) && isOperandApplicableToReceiver(in candidate, right, ref useSiteInfo))
1612Debug.Assert(operand.Type is not null);
1615if (candidate.Kind.IsLifted() && operand.Type.IsNullableType())
1618!Conversions.ConvertExtensionMethodThisArg(MakeNullable(candidate.Method.ContainingType.ExtensionParameter.Type), operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists)
1623else if (!Conversions.ConvertExtensionMethodThisArg(candidate.Method.ContainingType.ExtensionParameter.Type, operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists)
Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (7)
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);
779new object[] { instanceArgument.Type, inferenceFailed.Member.Name },
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);
CodeGen\EmitExpression.cs (50)
52if ((object)expression.Type == null ||
53(expression.Type.SpecialType != SpecialType.System_Decimal &&
54!expression.Type.IsNullableType()))
56EmitConstantExpression(expression.Type, constantValue, used, expression.Syntax);
374EmitDefaultValue(node.Type, used, node.Syntax);
409var receiverType = receiver.Type;
522Debug.Assert(receiver.Type.IsNullableType());
680EmitSymbolToken(expression.Operand.Type, expression.Operand.Syntax);
730Debug.Assert(refKind is RefKind.In || argument.Type.IsDynamic() || argument is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None }, "passing args byref should not clone them into temps");
803EmitLoadIndirect(expression.Type, expression.Syntax);
812var meth = expression.MethodOpt ?? receiver.Type.DelegateInvokeMethod();
1025if (((ArrayTypeSymbol)arrayAccess.Expression.Type).IsSZArray)
1112_builder.EmitArrayElementLoad(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Expression.Syntax);
1143if (!field.IsVolatile && !field.IsStatic && fieldAccess.ReceiverOpt.Type.IsVerifierValue() && field.RefKind == RefKind.None)
1182if (fieldType.IsValueType && (object)fieldType == (object)receiver.Type)
1238if (receiver == null || !receiver.Type.IsValueType)
1249EmitSymbolToken(receiver.Type, receiver.Syntax);
1278if (!receiver.Type.IsVerifierValue())
1330var type = expr.Type;
1521if (receiver.Type.IsTypeParameter())
1526Debug.Assert(receiver.Type.IsVerifierReference(), "this is not a reference");
1656Debug.Assert(TypeSymbol.Equals(method.ContainingType, receiver.Type, TypeCompareKind.ConsiderEverything2));
1691EmitSymbolToken(receiver.Type, receiver.Syntax);
1858var receiverType = receiver.Type;
1944var receiverType = receiver.Type;
2004Debug.Assert(receiver.Type.IsVerifierReference());
2015Debug.Assert(receiver.Type.IsVerifierReference());
2035EmitSymbolToken(receiver.Type, receiver.Syntax);
2050var receiverType = receiver.Type;
2113var receiverType = receiver.Type;
2630var rightType = right.Type;
2686if (left.Kind == BoundKind.ArrayAccess && left.Type.TypeKind == TypeKind.TypeParameter && !left.Type.IsValueType)
2710EmitSymbolToken(target.Type, target.Syntax);
3089assignmentOperator.Left.Type,
3136var arrayType = (ArrayTypeSymbol)array.Type;
3150EmitIndirectStore(expression.Type, expression.Syntax);
3155EmitIndirectStore(expression.Type, expression.Syntax);
3161EmitIndirectStore(expression.Type, expression.Syntax);
3173EmitIndirectStore(expression.Type, expression.Syntax);
3178EmitIndirectStore(expression.Type, expression.Syntax);
3424Debug.Assert((object)operand.Type != null);
3425if (!operand.Type.IsVerifierReference())
3428EmitBox(operand.Type, operand.Syntax);
3451var operandType = operand.Type;
3945if (!(expr.Type.IsInterfaceType() || expr.Type.IsDelegateType()))
3947return expr.Type;
3992return expr.Type;
4063temp = AllocateTemp(ptrInvocation.InvokedExpression.Type, ptrInvocation.Syntax);
CodeGen\EmitStatement.cs (28)
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);
Compilation\CSharpSemanticModel.cs (18)
2062type = boundExpr.Type;
2181convertedType = highestBoundExpr.Type;
2187convertedType = highestBoundExpr.Type;
2276static (TypeSymbol, NullabilityInfo) getTypeAndNullability(BoundExpression expr) => (expr.Type, expr.TopLevelNullability);
3388else if (expr.Type.IsDelegateType())
3697var thisParam = GetThisParameter(boundNode.Type, containingType, containingMember, out resultKind);
3821symbols = OneOrMany.Create<Symbol>(new SynthesizedIntrinsicOperatorSymbol(unaryOperator.Operand.Type.StrippedType(),
3844TypeSymbol opType = increment.Operand.Type.StrippedType();
3871((binaryOperator.Left.IsLiteralNull() && binaryOperator.Right.Type.IsNullableType()) ||
3872(binaryOperator.Right.IsLiteralNull() && binaryOperator.Left.Type.IsNullableType())) &&
3886binaryOperator.Left.Type,
3887binaryOperator.Right.Type,
4097TypeSymbol type = boundNode.Type;
4621if (node.SearchExtensions && receiver.Type is { } receiverType)
4763receiverType = call.ReceiverOpt.Type;
4767receiverType = call.Arguments[0].Type;
4797MethodSymbol reduced = method.ReduceExtensionMethod(receiver.Type, Compilation);
4812MethodSymbol reduced = method.ReduceExtensionMethod(receiverOpt.Type, Compilation);
FlowAnalysis\NullableWalker.cs (62)
417expr.Type?.Equals(result.RValueType.Type, TypeCompareKind.AllIgnoreOptions) == true ? result.RValueType.Type : expr.Type);
553Debug.Assert(AreCloseEnough(placeholder.Type, result.RValueType.Type));
2098receiver.Type is object;
2109TypeSymbol? nodeType = node.Type;
2145var operandType = operand.Type;
2163TypeSymbol.Equals(conv.Type, conv.Operand.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes):
3711Debug.Assert(AreCloseEnough(resultType.Type, node.Type));
4575SetAnalyzedNullability(node.ImplicitReceiverOpt, new VisitResult(node.ImplicitReceiverOpt.Type, NullableAnnotation.NotAnnotated, NullableFlowState.NotNull));
4633SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull));
4638var resultType = TypeWithState.Create(node.Type, NullableFlowState.NotNull);
4685Debug.Assert(node.Type is object);
4686if (IsEmptyStructType(node.Type))
4691return GetOrCreatePlaceholderSlot(node, TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated));
5009Debug.Assert(!node.Expression.Type!.IsValueType);
5023TypeSymbol.Equals(node.Indices[0].Type, compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.ConsiderEverything2))
5342if (expr.Type is null)
5352TypeWithAnnotations.Create(expr.Type),
5366Debug.Assert(binary.Type!.SpecialType == SpecialType.System_Boolean);
5629var receiverType = conditional.Receiver.Type!;
5658if (slot > 0 && PossiblyNullableType(operand.Type))
5728LearnFromNullTest(slot, expressionWithoutConversion.Type, ref state, markDependentSlotsNotNull: false);
5842node.Type?.ContainsErrorType() == true ||
5843TypeSymbol.Equals(targetType.Type.GetNullableUnderlyingType(), node.Type, TypeCompareKind.AllIgnoreOptions));
5849targetType = TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated);
6139if (slot > 0 && receiver.Type?.IsNullableType() == true)
6140slot = GetNullableOfTValueSlot(receiver.Type, slot, out _);
6184TypeSymbol? refResultType = node.Type?.SetUnknownNullabilityForReferenceTypes();
6250resultType ??= node.Type?.SetUnknownNullabilityForReferenceTypes();
7406TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState.Create(argument.Type, result.RValueType.State), argument as BoundConversion, argumentNoConversion);
7524completion(TypeWithAnnotations.Create(argument.Type));
8622if (value.Type is null || value.Type.IsDynamic() || value.ConstantValueOpt != null)
8632value.Type.HasInlineArrayAttribute(out _) == true &&
8633value.Type.TryGetInlineArrayElementField() is not null)
8773if (TypeAllowsConditionalState(targetType.Type) && TypeAllowsConditionalState(operand.Type))
8921var tupleOpt = (NamedTypeSymbol?)node.Type;
10121case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate }:
10235Debug.Assert(arg.Type is not null);
10236TypeSymbol argType = arg.Type;
10254Debug.Assert(arg.Type is not null);
10255TypeSymbol argType = arg.Type;
10435var rvalueResult = TypeWithState.Create(node.Type, NullableFlowState.NotNull);
10436var lvalueResult = TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated);
10936if (expr.Type is NamedTypeSymbol { IsTupleType: true } tupleType)
11269SetResultType(node.Expression, TypeWithState.Create(node.Expression.Type, ResultType.State));
11639if (collectionExpression.Type!.SpecialType == SpecialType.System_Collections_IEnumerable)
11642targetTypeWithAnnotations = TypeWithAnnotations.Create(collectionExpression.Type);
11644else if (ForEachLoopBinder.IsIEnumerableT(collectionExpression.Type.OriginalDefinition, isAsync, compilation))
11911var type = TypeWithAnnotations.Create(node.Type);
12411SetResultType(node, TypeWithState.Create(node.Type, node.Type?.CanContainNull() != false && node.ConstantValueOpt?.IsNull == true ? NullableFlowState.MaybeDefault : NullableFlowState.NotNull));
12588SetResultType(expression, TypeWithState.Create(expression.Type, default));
12622Debug.Assert(receiverOpt.Type is null || AreCloseEnough(receiverOpt.Type, resultTypeSymbol));
12710SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull));
12743Debug.Assert(node.Type is null || node.Type.IsErrorType() || node.Type.IsRefLikeType);
12759SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull));
12763Debug.Assert(node.Type is not null);
12764var type = VisitArrayInitialization(node.Type, initialization, node.HasErrors);
Generated\BoundNodes.xml.Generated.cs (187)
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!;
1786public new TypeSymbol Type => base.Type!;
1826public new TypeSymbol Type => base.Type!;
1861public new TypeSymbol Type => base.Type!;
1899public new TypeSymbol Type => base.Type!;
1943if (leftOperand != this.LeftOperand || rightOperand != this.RightOperand || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
1970public new TypeSymbol? Type => base.Type;
2012public new TypeSymbol Type => base.Type!;
2050public new TypeSymbol Type => base.Type!;
2080public new TypeSymbol? Type => base.Type;
2110public new TypeSymbol Type => base.Type!;
2184public new TypeSymbol Type => base.Type!;
2224public new TypeSymbol Type => base.Type!;
2315public new TypeSymbol Type => base.Type!;
2357public new TypeSymbol Type => base.Type!;
2400public new TypeSymbol Type => base.Type!;
2437public new TypeSymbol Type => base.Type!;
2472public new TypeSymbol Type => base.Type!;
2510public new TypeSymbol Type => base.Type!;
2545public new TypeSymbol Type => base.Type!;
2580public new TypeSymbol Type => base.Type!;
2615public new TypeSymbol Type => base.Type!;
2650public new TypeSymbol Type => base.Type!;
2689public new TypeSymbol Type => base.Type!;
2731public new TypeSymbol Type => base.Type!;
2774public new TypeSymbol Type => base.Type!;
2805public new TypeSymbol? Type => base.Type;
2828public new TypeSymbol Type => base.Type!;
2862public new TypeSymbol Type => base.Type!;
2898public new TypeSymbol Type => base.Type!;
2932public new TypeSymbol Type => base.Type!;
2969public new TypeSymbol Type => base.Type!;
3007public new TypeSymbol Type => base.Type!;
3044public new TypeSymbol Type => base.Type!;
3073public new TypeSymbol? Type => base.Type;
3109public new TypeSymbol Type => base.Type!;
4319if (constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
4351public new TypeSymbol Type => base.Type!;
4387public new TypeSymbol Type => base.Type!;
4422public new TypeSymbol Type => base.Type!;
4457public new TypeSymbol Type => base.Type!;
4486public new TypeSymbol? Type => base.Type;
4531public new TypeSymbol Type => base.Type!;
4578public new TypeSymbol Type => base.Type!;
4611public new TypeSymbol Type => base.Type!;
4652public new TypeSymbol Type => base.Type!;
4797if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(label, this.Label) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
4958if (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))
4983public new TypeSymbol Type => base.Type!;
5730public new TypeSymbol? Type => base.Type;
5753if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
5779public new TypeSymbol Type => base.Type!;
5815public new TypeSymbol Type => base.Type!;
5852public new TypeSymbol Type => base.Type!;
5907public new TypeSymbol Type => base.Type!;
5941public new TypeSymbol Type => base.Type!;
5978public new TypeSymbol Type => base.Type!;
6021public new TypeSymbol Type => base.Type!;
6053public new TypeSymbol Type => base.Type!;
6166public new TypeSymbol Type => base.Type!;
6213public new TypeSymbol Type => base.Type!;
6255public new TypeSymbol Type => base.Type!;
6296public new TypeSymbol? Type => base.Type;
6336public new TypeSymbol Type => base.Type!;
6414public new TypeSymbol? Type => base.Type;
6451public new TypeSymbol Type => base.Type!;
6494if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
6572public new TypeSymbol? Type => base.Type;
6609if (sourceTuple != this.SourceTuple || wasTargetTyped != this.WasTargetTyped || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || inferredNamesOpt != this.InferredNamesOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
6708public new TypeSymbol Type => base.Type!;
6763public new TypeSymbol Type => base.Type!;
6816public new TypeSymbol Type => base.Type!;
6883public new TypeSymbol Type => base.Type!;
6922public new TypeSymbol Type => base.Type!;
6958public new TypeSymbol Type => base.Type!;
6991public new TypeSymbol Type => base.Type!;
7033public new TypeSymbol Type => base.Type!;
7096public new TypeSymbol Type => base.Type!;
7130public new TypeSymbol Type => base.Type!;
7161public new TypeSymbol? Type => base.Type;
7216if (!TypeSymbol.Equals(elementType, this.ElementType, TypeCompareKind.ConsiderEverything) || count != this.Count || initializerOpt != this.InitializerOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
7238public new TypeSymbol Type => base.Type!;
7272public new TypeSymbol Type => base.Type!;
7317public new TypeSymbol Type => base.Type!;
7351public new TypeSymbol Type => base.Type!;
7388public new TypeSymbol Type => base.Type!;
7432public new TypeSymbol Type => base.Type!;
7486public new TypeSymbol Type => base.Type!;
7529public new TypeSymbol Type => base.Type!;
7568public new TypeSymbol Type => base.Type!;
7610public new TypeSymbol? Type => base.Type;
7654public new TypeSymbol? Type => base.Type;
7692public new TypeSymbol Type => base.Type!;
7755public new TypeSymbol Type => base.Type!;
7806if (parts != this.Parts || constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
7834if (!interpolationData.Equals(this.InterpolationData) || parts != this.Parts || constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
7862if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
7892public new TypeSymbol Type => base.Type!;
7924public new TypeSymbol? Type => base.Type;
7977if (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))
8577public new TypeSymbol? Type => base.Type;
8614if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
8636public new TypeSymbol? Type => base.Type;
8709public new TypeSymbol? Type => base.Type;
8807public new TypeSymbol? Type => base.Type;
8840public new TypeSymbol Type => base.Type!;
10865TypeSymbol? type = this.VisitType(node.Type);
10871TypeSymbol? type = this.VisitType(node.Type);
10932TypeSymbol? type = this.VisitType(node.Type);
10938TypeSymbol? type = this.VisitType(node.Type);
10945TypeSymbol? type = this.VisitType(node.Type);
11140TypeSymbol? type = this.VisitType(node.Type);
11559TypeSymbol? type = this.VisitType(node.Type);
11633TypeSymbol? type = this.VisitType(node.Type);
11662TypeSymbol? type = this.VisitType(node.Type);
11810TypeSymbol? type = this.VisitType(node.Type);
11947TypeSymbol? type = this.VisitType(node.Type);
11970TypeSymbol? type = this.VisitType(node.Type);
12081TypeSymbol? type = this.VisitType(node.Type);
12192TypeSymbol? type = this.VisitType(node.Type);
12198TypeSymbol? type = this.VisitType(node.Type);
12203TypeSymbol? type = this.VisitType(node.Type);
12226TypeSymbol? type = this.VisitType(node.Type);
12351TypeSymbol? type = this.VisitType(node.Type);
12465updatedNode = node.Update(receiver, node.LocalScopeDepth, node.Type);
12631updatedNode = node.Update(expression, node.Type);
12649updatedNode = node.Update(node.ResultKind, node.Symbols, childBoundNodes, node.Type);
13021updatedNode = node.Update(leftOperand, rightOperand, node.Type);
13823updatedNode = node.Update(expression, switchArms, reachabilityDecisionDag, node.DefaultLabel, node.ReportedNotExhaustive, node.Type);
13918updatedNode = node.Update(expression, node.Type);
14280updatedNode = node.Update(sourceTuple, node.WasTargetTyped, arguments, node.ArgumentNamesOpt, node.InferredNamesOpt, node.Type);
14563updatedNode = node.Update(elementType, count, initializerOpt, node.Type);
14801updatedNode = node.Update(parts, node.ConstantValueOpt, node.Type);
14818updatedNode = node.Update(node.InterpolationData, parts, node.ConstantValueOpt, node.Type);
14880updatedNode = node.Update(expression, pattern, node.IsNegated, reachabilityDecisionDag, node.WhenTrueLabel, node.WhenFalseLabel, node.Type);
15029updatedNode = node.Update(expression, node.Type);
15171new TreeDumperNode("type", node.Type, null),
15180new TreeDumperNode("type", node.Type, null),
15269new TreeDumperNode("type", node.Type, null),
15277new TreeDumperNode("type", node.Type, null),
15287new TreeDumperNode("type", node.Type, null),
15559new TreeDumperNode("type", node.Type, null),
16123new TreeDumperNode("type", node.Type, null),
16225new TreeDumperNode("type", node.Type, null),
16261new TreeDumperNode("type", node.Type, null),
16447new TreeDumperNode("type", node.Type, null),
16664new TreeDumperNode("type", node.Type, null),
16698new TreeDumperNode("type", node.Type, null),
16864new TreeDumperNode("type", node.Type, null),
17031new TreeDumperNode("type", node.Type, null),
17041new TreeDumperNode("type", node.Type, null),
17048new TreeDumperNode("type", node.Type, null),
17080new TreeDumperNode("type", node.Type, null),
17234new TreeDumperNode("type", node.Type, null),
Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (28)
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)));
Lowering\DiagnosticsPass_Warnings.cs (18)
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;
Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (24)
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);
Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (55)
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;
Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (26)
175Debug.Assert(singleSpread.Expression.Type is not null);
177if (!ShouldUseIEnumerableBulkAddMethod(singleSpread.Expression.Type, toListOfElementType.Parameters[0].Type, singleSpread.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))
223Elements: [BoundCollectionExpressionSpreadElement { Expression: { Type: NamedTypeSymbol spreadType } expr }],
315Debug.Assert(list.Type is { });
316Debug.Assert(list.Type.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_Collections_Generic_List_T), TypeCompareKind.AllIgnoreOptions));
318var listToArray = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_Collections_Generic_List_T__ToArray)).AsMember((NamedTypeSymbol)list.Type);
327Debug.Assert(TypeSymbol.Equals(array.Type, spanConstructor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions));
664var spreadTypeOriginalDefinition = spreadExpression.Type!.OriginalDefinition;
670return _factory.Call(rewrittenSpreadExpression, listToArrayMethod.AsMember((NamedTypeSymbol)spreadExpression.Type!));
680&& ShouldUseIEnumerableBulkAddMethod(spreadExpression.Type!, linqToArrayMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))
687&& TryGetSpanConversion(spreadExpression.Type, writableOnly: false, out var asSpanMethod))
689var spanType = CallAsSpanMethod(spreadExpression, asSpanMethod).Type!.OriginalDefinition;
694return _factory.Call(rewrittenSpreadExpression, toArrayMethod.AsMember((NamedTypeSymbol)rewrittenSpreadExpression.Type!));
788Debug.Assert(arrayTemp.Type is ArrayTypeSymbol);
792var elementType = ((ArrayTypeSymbol)arrayTemp.Type).ElementType;
902var type = expression.Type;
969if (spreadOperandAsSpan.Type!.OriginalDefinition.Equals(this._compilation.GetWellKnownType(wellKnownSpanType))
1008var spreadLength = _factory.Call(spreadOperandAsSpan, getLengthMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!));
1009var targetSlice = _factory.Call(spanTemp, spanSliceMethod.AsMember((NamedTypeSymbol)spanTemp.Type!), indexTemp, spreadLength);
1010sideEffects.Add(_factory.Call(spreadOperandAsSpan, copyToMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!), targetSlice));
1124Debug.Assert(spanTemp.Type is NamedTypeSymbol);
1128var elementType = ((NamedTypeSymbol)spanTemp.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type;
1177Debug.Assert(rewrittenSpreadOperand.Type is not null);
1182if (!ShouldUseIEnumerableBulkAddMethod(rewrittenSpreadOperand.Type, addRangeMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))
1317_factory.Binary(BinaryOperatorKind.Addition, sum.Type!, sum, value);
1352if (convertedExpression.Operand.Type is ArrayTypeSymbol arrayType)
Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (32)
24Debug.Assert(TypeSymbol.Equals(node.Right.Type, node.Operator.RightType, TypeCompareKind.ConsiderEverything2));
39Debug.Assert(node.LeftConversion is null || (node.Left.Type!.IsReferenceType && node.Operator.Method.GetIsNewExtensionMember()));
53TypeSymbol? leftType = node.Left.Type; // type of the target
153Debug.Assert(rewrittenAssignment.Type is { });
156var condition = _factory.Conditional(isEvent, invokeEventAccessor.ToExpression(), rewrittenAssignment, rewrittenAssignment.Type);
158rewrittenAssignment = new BoundSequence(node.Syntax, eventTemps.ToImmutableAndFree(), sequence.ToImmutableAndFree(), condition, condition.Type!);
165Debug.Assert(rewrittenAssignment.Type is { });
173rewrittenAssignment.Type);
216Debug.Assert(node.Left.Type is { });
228Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.Left.Type, TypeCompareKind.AllIgnoreOptions));
235Debug.Assert(assignment.Type is { });
236return new BoundSequence(syntax, [binaryResult.LocalSymbol], [assignmentToTemp], assignment, assignment.Type);
292Debug.Assert(rewrittenReceiver.Type is { });
312var variableRepresentsLocation = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter;
315isKnownToReferToTempIfReferenceType = !variableRepresentsLocation || rewrittenReceiver.Type.IsValueType ||
544indexerAccess.Argument.Type,
551throw ExceptionUtilities.UnexpectedValue(indexerAccess.Argument.Type);
572if (isDynamicAssignment || !IsInvariantArray(arrayAccess.Expression.Type))
600Debug.Assert(receiver is { Type: { } });
605else if (!receiver.Type.IsReferenceType)
610Debug.Assert(receiver.Type.IsReferenceType);
614Debug.Assert(rewrittenReceiver.Type is { });
615if (rewrittenReceiver.Type.IsTypeParameter())
753Debug.Assert(implicitIndexerAccess.Argument.Type!.Equals(_compilation.GetWellKnownType(WellKnownType.System_Index))
754|| implicitIndexerAccess.Argument.Type!.Equals(_compilation.GetWellKnownType(WellKnownType.System_Range)));
783if (isDynamicAssignment || !IsInvariantArray(arrayAccess.Expression.Type))
964var type = expression.Type;
980var type = expression.Type;
1036Debug.Assert(expression.Type is { });
1037if (expression.Type.IsNullableType())
Lowering\LocalRewriter\LocalRewriter_Conversion.cs (65)
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);
Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (37)
121Debug.Assert(oldNode.Type is not null);
122Debug.Assert(oldNode.Type.Equals(type, TypeCompareKind.ConsiderEverything));
218Debug.Assert(call.Type is not null);
233call.Type);
242Debug.Assert(node.Expression.Type is object);
243Debug.Assert(node.Argument.Type is object);
258_ = node.Expression.Type.HasInlineArrayAttribute(out int length);
260if (node.Argument.Type.SpecialType == SpecialType.System_Int32)
268if (TypeSymbol.Equals(node.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.AllIgnoreOptions))
280Debug.Assert(TypeSymbol.Equals(node.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.AllIgnoreOptions));
362Debug.Assert(node.Expression.Type is object);
374return createSpan.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type);
379Debug.Assert(node.Expression.Type is object);
380Debug.Assert(index.Type?.SpecialType == SpecialType.System_Int32);
382var intType = (NamedTypeSymbol)index.Type;
401elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type);
420elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type);
475node.Argument.Type,
484node.Argument.Type,
522node.Argument.Type,
538Debug.Assert(receiver.Type is { });
544receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref);
602Debug.Assert(integerArgument.Type!.SpecialType == SpecialType.System_Int32);
699Debug.Assert(loweredExpr.Type!.SpecialType == SpecialType.System_Int32);
710Debug.Assert(loweredExpr.Type!.SpecialType == SpecialType.System_Int32);
717loweredExpr.Type,
750unloweredExpr.Type,
758Debug.Assert(hatExpression.Operand is { Type: { SpecialType: SpecialType.System_Int32 } });
762else if (unloweredExpr is BoundConversion { Operand: { Type: { SpecialType: SpecialType.System_Int32 } } operand })
771arguments[0] is { Type.SpecialType: SpecialType.System_Int32, ConstantValueOpt.Value: int _ and >= 0 } index &&
772arguments[1] is { Type.SpecialType: SpecialType.System_Boolean, ConstantValueOpt.Value: bool fromEnd })
815node.Argument.Type,
841Debug.Assert(receiver.Type is { });
847receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref);
Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (18)
16Debug.Assert(node.Type is { });
20Debug.Assert(node.LeftOperand.Type is { });
24Debug.Assert(transformedLHS.Type is { });
41Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.LeftOperand.Type, TypeCompareKind.AllIgnoreOptions));
49Debug.Assert(assignment.Type is { });
50assignment = new BoundSequence(syntax, [rightResult.LocalSymbol], [assignmentToTemp], assignment, assignment.Type);
58var leftPlaceholder = new BoundValuePlaceholder(lhsRead.Syntax, lhsRead.Type);
59BoundExpression conditionalExpression = MakeNullCoalescingOperator(syntax, lhsRead, assignment, leftPlaceholder: leftPlaceholder, leftConversion: leftPlaceholder, BoundNullCoalescingOperatorResultKind.LeftType, node.LeftOperand.Type);
60Debug.Assert(conditionalExpression.Type is { });
69conditionalExpression.Type);
76Debug.Assert(node.LeftOperand.Type.IsNullableType());
85leftOperand.Type,
93leftOperand.Type,
125Debug.Assert(transformedLHS.Type.GetNullableUnderlyingType().Equals(tmp.Type.StrippedType(), TypeCompareKind.AllIgnoreOptions));
128Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.LeftOperand.Type, TypeCompareKind.AllIgnoreOptions));
133MakeConversionNode(tmp, transformedLHS.Type, @checked: false, markAsChecked: true),
Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (18)
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;
Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (9)
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 _));
Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (21)
75Debug.Assert(visitedArguments.All(arg => arg.Type!.SpecialType is SpecialType.System_String or SpecialType.System_Char or SpecialType.System_Object));
107var argumentType = arg.Type;
153bool needsImplicitConversionFromStringToSpan = visitedArguments.Any(arg => arg.Type is { SpecialType: SpecialType.System_String });
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),
Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (9)
107if (actualCall.Type!.IsDynamic())
145Debug.Assert(node.Type is { SpecialType: SpecialType.System_String }); // if target-converted, we should not get here.
149return LowerPartsToString(data, node.Parts, node.Syntax, node.Type);
183_factory.Binary(BinaryOperatorKind.StringConcatenation, node.Type, result, part);
194Debug.Assert(result.Type is not null);
195Debug.Assert(result.Type.SpecialType == SpecialType.System_String || result.Type.IsErrorType());
196var placeholder = new BoundValuePlaceholder(result.Syntax, result.Type);
197result = new BoundNullCoalescingOperator(result.Syntax, result, _factory.StringLiteral(""), leftPlaceholder: placeholder, leftConversion: placeholder, BoundNullCoalescingOperatorResultKind.LeftType, @checked: false, result.Type) { WasCompilerGenerated = true };
Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (32)
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]);
Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (27)
133var underlyingType = loweredOperand.Type.GetEnumUnderlyingType();
277Debug.Assert(result.Type is { });
286type: result.Type
329Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2));
330Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2));
408Debug.Assert(node.OperandConversion is null || (node.Operand.Type!.IsReferenceType && node.MethodOpt.GetIsNewExtensionMember()));
421TypeSymbol? operandType = node.Operand.Type; //type of the variable being incremented
458TypeSymbol? operandType = left.Type; //type of the variable being incremented
467Debug.Assert(TypeSymbol.Equals(operandType, transformedLHS.Type, TypeCompareKind.AllIgnoreOptions));
586TypeSymbol? operandType = transformedLHS.Type; //type of the variable being incremented
660Debug.Assert(boundTemp.Type is not null);
686type: boundTemp.Type);
699Debug.Assert(boundTemp.Type is not null);
702Debug.Assert(tempValue.Type is { });
711tempValue.Type);
725type: boundTemp.Type);
931Debug.Assert(binaryOperand.Type is { TypeKind: TypeKind.Pointer });
932Debug.Assert(boundOne.Type is { SpecialType: SpecialType.System_Int32 });
933return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null, constrainedToTypeOpt: null);
985Debug.Assert(operand.Type is { SpecialType: SpecialType.System_Decimal });
992Debug.Assert(operand.Type is { } && operand.Type.IsNullableType() && operand.Type.GetNullableUnderlyingType().SpecialType == SpecialType.System_Decimal);
996MethodSymbol getValueOrDefault = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T_GetValueOrDefault);
997MethodSymbol ctor = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T__ctor);
1008BoundExpression alternative = new BoundDefaultExpression(syntax, operand.Type);
1011return RewriteConditionalOperator(syntax, condition, consequence, alternative, ConstantValue.NotAvailable, operand.Type, isRef: false);
Lowering\SpillSequenceSpiller.cs (19)
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)
1045Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType);
1054var receiverType = receiver.Type;
1085if (!receiver.Type.IsReferenceType && LocalRewriter.CanBePassedByReference(receiver))
1087result = receiver.Type.IsReadOnly ? RefKind.In : RefKind.Ref;
1158Debug.Assert(condition.Type.SpecialType == SpecialType.System_Boolean);
1161var tmp = _F.SynthesizedLocal(condition.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax);
1208type: node.Type));
1265_F.ObjectEqual(_F.Local(tmp), _F.Null(left.Type)),
1297if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None)
1317var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill);
1321var isNotClass = _F.IsNotNullReference(_F.Default(receiver.Type));
1489return UpdateExpression(builder, node.Update(operand, node.Type));
1533return UpdateExpression(builder, node.Update(expression, node.Type));
Lowering\SyntheticBoundNodeFactory.cs (54)
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);