Binder\Binder.ValueChecks.cs (29)
701Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter());
728if ((expr.ConstantValueOpt != null) || (expr.Type.GetSpecialTypeSafe() == SpecialType.System_Void))
918getItemOrSliceHelper = getItemOrSliceHelper.AsMember(getItemOrSliceHelper.ContainingType.Construct(ImmutableArray.Create(elementAccess.Expression.Type.TryGetInlineArrayElementField().TypeWithAnnotations)));
989indices[0].Type,
1022Error(diagnostics, ErrorCode.ERR_BadSKunknown, expr.Syntax, expr.Type, MessageID.IDS_SK_TYPE.Localize());
1661&& receiver?.Type?.IsValueType == true;
1893if (receiver is BoundObjectOrCollectionValuePlaceholder && receiver.Type.IsAnonymousType)
2077if (methodInfo.Method?.RequiresInstanceReceiver == true && receiver?.Type?.IsRefLikeOrAllowsRefLikeType() == true)
2289if (receiver?.Type?.IsRefLikeOrAllowsRefLikeType() == true)
2386Debug.Assert(receiver.Type is { });
2391Debug.Assert(receiver is not BoundValuePlaceholderBase && method is not null && receiver.Type?.IsReferenceType == false);
2396receiver = new BoundCapturedReceiverPlaceholder(receiver.Syntax, receiver, _localScopeDepth, receiver.Type).MakeCompilerGenerated();
2511if (receiver.Type is TypeParameterSymbol typeParameter)
3404Debug.Assert(expr.Type is not null);
3436if (expr.Type?.GetSpecialTypeSafe() == SpecialType.System_Void)
3737Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter());
3752if (expr.Type?.GetSpecialTypeSafe() == SpecialType.System_Void)
4145if (expr.Type?.IsRefLikeOrAllowsRefLikeType() != true)
4623RoslynDebug.Assert(false, $"{expr.Kind} expression of {expr.Type} type");
4830Debug.Assert(!checkingReceiver || expr.Type.IsValueType || expr.Type.IsTypeParameter());
4851if (expr.Type?.IsRefLikeOrAllowsRefLikeType() != true)
4916Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeStackAlloc : ErrorCode.ERR_EscapeStackAlloc, node, expr.Type);
5225Error(diagnostics, ErrorCode.ERR_CollectionExpressionEscape, node, expr.Type);
5431RoslynDebug.Assert(false, $"{expr.Kind} expression of {expr.Type} type");
5604TypeWithAnnotations.Create(elementAccess.Expression.Type),
5644TypeWithAnnotations.Create(inlineArray.Type),
Binder\Binder_Await.cs (13)
31var placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type);
84var type = expression.Type;
262Debug.Assert(TypeSymbol.Equals(expression.Type, getAwaiterArgument.Type, TypeCompareKind.ConsiderEverything));
286TypeSymbol awaiterType = getAwaiter.Type!;
287return GetIsCompletedProperty(awaiterType, node, expression.Type!, diagnostics, out isCompleted)
289&& GetGetResultMethod(getAwaiter, node, expression.Type!, diagnostics, out getResult, out getAwaiterGetResultCall);
303if (expression.Type is null)
325RoslynDebug.Assert(expression.Type is object);
326if (expression.Type.IsVoidType())
342Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
353Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
437var awaiterType = awaiterExpression.Type;
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,
1357Debug.Assert(methodGroup.ReceiverOpt.Type is not null);
1427diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, syntax, methodGroup.ReceiverOpt.Type);
1474TypeSymbol? receiverType = methodGroup.ReceiverOpt.Type;
1982Debug.Assert(targetTyped || destination.IsErrorType() || destination.Equals(source.Type, TypeCompareKind.ConsiderEverything));
2001source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.ReachabilityDecisionDag,
2087conversion: Conversions.ClassifyStandardConversion(convertedOperand.Type, conversionParameterType, ref useSiteInfo),
2692RoslynDebug.Assert(receiverOpt.Type is object);
2694diagnostics.Add(ErrorCode.ERR_QueryNoProvider, node.Location, receiverOpt.Type, memberSymbol.Name);
2712RoslynDebug.Assert(receiverOpt.Type is object);
2713diagnostics.Add(ErrorCode.ERR_BadAwaitArg, node.Location, receiverOpt.Type);
2848(Conversions.ConvertExtensionMethodThisArg(GetReceiverParameter(method)!.Type, receiverOpt!.Type, ref useSiteInfo, isMethodGroupConversion: true).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty()));
Binder\Binder_Expressions.cs (94)
204TypeSymbol resultType = expr.Type;
297var commonType = expr.Type;
369case BoundStackAllocArrayCreation { Type: null } boundStackAlloc:
570TypeSymbol exprType = expr.Type;
1044if (boundArgument.Type?.SpecialType == SpecialType.System_Void)
1054var elementTypeWithAnnotations = TypeWithAnnotations.Create(boundArgument.Type);
1253if ((object)argument.Type != null && argument.Type.IsRestrictedType())
1256Error(diagnostics, ErrorCode.ERR_MethodArgCantBeRefAny, node, argument.Type);
1682type: expression.Type,
2590(object)operand.Type != null &&
2591!operand.Type.IsNullableType() &&
2592!TypeSymbol.Equals(targetType.GetNullableUnderlyingType(), operand.Type, TypeCompareKind.ConsiderEverything2))
2613if ((object)boundOperand.Type != null && boundOperand.Type.IsNullableType())
2692if (left?.Type.IsNullableType() == true || right?.Type.IsNullableType() == true)
2720if (boundOperand.Type?.IsNullableType() == true)
2812SymbolDistinguisher distinguisher1 = new SymbolDistinguisher(this.Compilation, operand.Type, targetType);
2861case BoundKind.UnconvertedConditionalOperator when operand.Type is null:
2862case BoundKind.UnconvertedSwitchExpression when operand.Type is null:
2886Debug.Assert((object)operand.Type != null);
2887SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, operand.Type, targetType);
2928Debug.Assert((object)operand.Type != null && !operand.Type.IsNullableType());
2934var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo);
3786Debug.Assert(receiver!.Type is not null);
3788placeholderType = receiver.Type;
4225if ((object)boundExpression.Type == null || !boundExpression.Type.IsErrorType())
4309Debug.Assert(init.Type.IsErrorType());
4719if (constantValue == null || constantValue.IsBad || expression.Type.SpecialType != SpecialType.System_Int32)
4742var type = expression.Type.SpecialType;
5294Debug.Assert(expression.Type is { });
5296var expressionPlaceholder = new BoundCollectionExpressionSpreadExpressionPlaceholder(syntax.Expression, expression.Type);
5309_ = expression.Type.HasInlineArrayAttribute(out int length);
5439else if ((object)argument.Type == null)
5451else if (argument.Type.TypeKind == TypeKind.Delegate)
5453var sourceDelegate = (NamedTypeSymbol)argument.Type;
5457if (ReportDelegateInvokeUseSiteDiagnostic(diagnostics, argument.Type, node: node))
5738Debug.Assert((object)boundLeft.Type != null);
5747type: boundLeft.Type,
6035type: boundMember.Type,
6449({ Type: null } or BoundLiteral or BoundUnconvertedInterpolatedString or BoundBinaryOperator { IsUnconvertedInterpolatedStringAddition: true }) &&
7520var leftType = boundValue.Type;
7528if (TypeSymbol.Equals(boundType.Type, leftType, TypeCompareKind.AllIgnoreOptions))
7560TypeSymbol.Equals(BindNamespaceOrType(id, BindingDiagnosticBag.Discarded).Type, type, TypeCompareKind.AllIgnoreOptions);
7664TypeSymbol leftType = boundLeft.Type;
7702leftType = boundLeft.Type;
7945Error(diagnostics, ErrorCode.WRN_DotOnDefault, node, boundLeft.Type);
8071var leftType = boundLeft.Type;
8209if ((object)boundLeft.Type == null)
8218Error(diagnostics, ErrorCode.ERR_NoSuchMember, name, boundLeft.Type, plainName);
8220else if (WouldUsingSystemFindExtension(boundLeft.Type, plainName))
8222Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtensionNeedUsing, name, boundLeft.Type, plainName, "System");
8226Error(diagnostics, ErrorCode.ERR_NoSuchMemberOrExtension, name, boundLeft.Type, plainName);
8516Debug.Assert(left.Type is not null);
8517Debug.Assert(!left.Type.IsDynamic());
8609Debug.Assert(left.Type is not null);
8645firstResult = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics);
8671result = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics);
8690result = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics);
8718TypeSymbol? receiverType = left.Type;
8925TypeSymbol receiverType = receiver.Type;
9096if (receiverOpt is { Type: TypeParameterSymbol { AllowsRefLikeType: true } } &&
9138bool isUsableAsField = eventSymbol.HasAssociatedField && this.IsAccessible(eventSymbol.AssociatedField, ref useSiteInfo, (receiver != null) ? receiver.Type : null);
9378if ((object)expr.Type == null)
9399expr.Type.HasInlineArrayAttribute(out int length) && expr.Type.TryGetPossiblyUnsupportedByLanguageInlineArrayElementField() is FieldSymbol elementField)
9411Debug.Assert(expr.Type.TryGetInlineArrayElementField() is not null);
9431{ Code: (int)ErrorCode.ERR_BadIndexLHS, Arguments: [TypeSymbol type] } && type.Equals(expr.Type, TypeCompareKind.ConsiderEverything))
9558CheckInlineArrayTypeIsSupported(node, expr.Type, elementField.Type, diagnostics);
9609if (TypeSymbol.Equals(convertedIndex.Type, compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.AllIgnoreOptions))
9657Debug.Assert((object)expr.Type != null);
9660var exprType = expr.Type;
9703var arrayType = (ArrayTypeSymbol)expr.Type;
9750var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(expr.Syntax, isEquivalentToThisReference: expr.IsEquivalentToThisReference, expr.Type) { WasCompilerGenerated = true };
9914Debug.Assert(expr.Type.IsPointerType());
9915PointerTypeSymbol pointerType = (PointerTypeSymbol)expr.Type;
9961Debug.Assert((object)expr.Type != null);
9967this.LookupMembersWithFallback(lookupResult, expr.Type, WellKnownMemberNames.Indexer, arity: 0, useSiteInfo: ref useSiteInfo, options: lookupOptions);
10288Debug.Assert(receiver.Type is not null);
10295var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(receiver.Syntax, isEquivalentToThisReference: receiver.IsEquivalentToThisReference, receiver.Type) { WasCompilerGenerated = true };
10304Debug.Assert(indexerOrSliceAccess.Type is not null);
10314indexerOrSliceAccess.Type);
10527Debug.Assert(receiverPlaceholder.Type is not null);
10528if (TryLookupLengthOrCount(syntax, receiverPlaceholder.Type, lookupResult, out var lengthOrCountProperty, diagnostics))
10894if (m.ReduceExtensionMethod(receiver.Type, Compilation) is { } reduced)
11057Debug.Assert(node.ReceiverOpt!.Type is not null); // extensions are only considered on member access
11090var substituted = (MethodSymbol?)extensionMember.GetReducedAndFilteredSymbol(typeArguments, receiver.Type, Compilation, checkFullyInferred: true);
11339var receiverType = receiver.Type;
11348var accessType = access.Type;
11484var receiverType = receiver.Type;
11515var 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)
278else if ((object)argument.Type == null && !argument.HasAnyErrors)
289else if (argument.Type.IsVoidType())
343if ((object)boundExpression.Type != null && boundExpression.Type.IsDynamic())
371else if (boundExpression.Type?.Kind == SymbolKind.FunctionPointerType)
558Debug.Assert(receiver.Type is not null);
559Error(diagnostics, ErrorCode.ERR_CannotDynamicInvokeOnExpression, receiver.Syntax, receiver.Type);
610Debug.Assert((object?)arg.Type != null);
613Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, arg.Type);
833Debug.Assert(methodGroup.ReceiverOpt != null && (object)methodGroup.ReceiverOpt.Type != null);
835Error(diagnostics, ErrorCode.ERR_BadArgTypeDynamicExtension, syntax, methodGroup.ReceiverOpt.Type, methodGroup.Name);
1062if (!call.HasAnyErrors && call.ReceiverOpt != null && (object)call.ReceiverOpt.Type != null && !call.Method.GetIsNewExtensionMember())
1067if (call.ReceiverOpt.Type.IsRestrictedType() && !call.Method.ContainingType.IsInterface && !TypeSymbol.Equals(call.Method.ContainingType, call.ReceiverOpt.Type, TypeCompareKind.ConsiderEverything2))
1069SymbolDistinguisher distinguisher = new SymbolDistinguisher(compilation, call.ReceiverOpt.Type, call.Method.ContainingType);
1085(object)dynInvoke.Expression.Type != null &&
1086dynInvoke.Expression.Type.IsRestrictedType())
1090Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, dynInvoke.Expression.Syntax, dynInvoke.Expression.Type);
1175case BoundUnconvertedSwitchExpression { Type: { } naturalType } switchExpr:
1393if (receiver is BoundValuePlaceholderBase || receiver?.Type is null or { IsReferenceType: true })
1841receiver.Type.IsValueType &&
1904!(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.
1959var type = expr.Type as NamedTypeSymbol;
2013var methodContainer = (object)receiver != null && (object)receiver.Type != null
2014? receiver.Type
2254var methodContainer = expr.Type ?? this.ContainingType;
2441RoslynDebug.Assert(boundExpression.Type is FunctionPointerTypeSymbol);
2443var funcPtr = (FunctionPointerTypeSymbol)boundExpression.Type;
Binder\Binder_Operators.cs (84)
65Debug.Assert(left.Type is { });
68var placeholder = new BoundValuePlaceholder(right.Syntax, left.HasDynamicType() ? left.Type : right.Type).MakeCompilerGenerated();
69var finalDynamicConversion = this.Compilation.Conversions.ClassifyConversionFromExpression(placeholder, left.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
71var conversion = (BoundConversion)CreateConversion(node, placeholder, finalDynamicConversion, isCast: true, conversionGroupOpt: null, left.Type, diagnostics);
80left.Type,
81right.Type,
89left.Type,
209var leftType = left.Type;
264var leftType = left.Type;
492TypeSymbol type = operand.Type;
520Debug.Assert((object)left.Type != null && left.Type.IsDynamic() || (object)right.Type != null && right.Type.IsDynamic());
544Error(diagnostics, ErrorCode.ERR_InvalidDynamicCondition, node.Left, left.Type, kind == BinaryOperatorKind.LogicalAnd ? "false" : "true");
550Debug.Assert(left.Type is not TypeParameterSymbol);
666TypeSymbol leftType = left.Type;
667TypeSymbol rightType = right.Type;
702Debug.Assert(right.Type.SpecialType == SpecialType.System_String);
703var stringConstant = FoldBinaryOperator(node, BinaryOperatorKind.StringConcatenation, left, right, right.Type, diagnostics);
704return new BoundBinaryOperator(node, BinaryOperatorKind.StringConcatenation, BoundBinaryOperator.UncommonData.UnconvertedInterpolatedStringAddition(stringConstant), LookupResultKind.Empty, left, right, right.Type);
871TypeSymbol leftType = left.Type;
872TypeSymbol rightType = right.Type;
961(object)left.Type != null && left.Type.TypeKind == TypeKind.Delegate)
965var conversion = this.Conversions.ClassifyConversionFromExpression(right, left.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo);
967GenerateImplicitConversionError(diagnostics, right.Syntax, conversion, right, left.Type);
989case (BoundKind.DefaultLiteral, _) when right.Type is TypeParameterSymbol:
990Debug.Assert(!right.Type.IsReferenceType);
991Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnUnconstrainedDefault, node, operatorToken.Text, right.Type);
993case (_, BoundKind.DefaultLiteral) when left.Type is TypeParameterSymbol:
994Debug.Assert(!left.Type.IsReferenceType);
995Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnUnconstrainedDefault, node, operatorToken.Text, left.Type);
1014case LookupResultKind.OverloadResolutionFailure when operatorToken.Kind() is SyntaxKind.PlusToken && isReadOnlySpanOfByte(left.Type) && isReadOnlySpanOfByte(right.Type):
1081if ((object)left.Type != null && left.Type.SpecialType == SpecialType.System_Boolean &&
1082(object)right.Type != null && right.Type.SpecialType == SpecialType.System_Boolean)
1084var constantValue = FoldBinaryOperator(node, kind | BinaryOperatorKind.Bool, left, right, left.Type, diagnostics);
1088resultKind: LookupResultKind.Viable, left, right, type: left.Type, hasErrors: constantValue != null && constantValue.IsBad);
1159var operandPlaceholder = new BoundValuePlaceholder(resultLeft.Syntax, resultLeft.Type).MakeCompilerGenerated();
1162var conversion = this.Conversions.ClassifyConversionFromType(resultLeft.Type, trueFalseParameterType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
1219var type = left.Type;
1236if (left.Type is not null)
1238var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated();
1276var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated();
1279implicitConversion = this.Conversions.ClassifyConversionFromType(operandPlaceholder.Type, parameterType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
1646(object)operand.Type != null &&
1647(operand.Type.SpecialType == SpecialType.System_UInt64 || isNuint(operand.Type)))
1872return left.Type;
1875return right.Type;
1939BinaryOperatorKind newKind = kind.Operator().WithType(newLeftOperand.Type!.SpecialType);
2485var operandType = operand.Type;
2562var operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated();
2582var operandType = operand.Type;
2917var operandType = operand.Type as PointerTypeSymbol;
2972TypeSymbol operandType = operand.Type;
3051if (receiver.Type.IsReferenceType)
3177if (isOperandNullOrNew || operand.Type?.IsErrorType() == true)
3205type: operand.Type!);
3254var underlyingType = operand.Type.GetEnumUnderlyingType()!;
3613if ((object)operand.Type == null && !operand.IsLiteralNull())
3672if ((object)operand.Type == null)
3683var convertedExpression = BindExpressionForPattern(operand.Type, node.Right, ref hasErrors, isPatternDiagnostics, out var constantValueOpt, out var wasExpression, out _);
3690node.Right, convertedExpression, constantValueOpt ?? ConstantValue.Bad, operand.Type, convertedExpression.Type ?? operand.Type, hasErrors)
3710if (operandHasErrors || IsOperatorErrors(node, operand.Type, typeExpression, diagnostics))
3731operand.Type.IsVoidType())
3761var operandType = operand.Type;
4161if ((object)operand.Type == null)
4223Debug.Assert(operand.Type is null);
4224operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated();
4238var operandType = operand.Type;
4271operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated();
4450TypeSymbol optLeftType = leftOperand.Type; // "A"
4451TypeSymbol optRightType = rightOperand.Type; // "B"
4626TypeSymbol leftType = leftOperand.Type;
4644if (underlyingRightConversion.Exists && rightOperand.Type?.IsDynamic() != true)
4785TypeSymbol trueType = trueExpr.Type;
4786TypeSymbol falseType = falseExpr.Type;
Binder\Binder_Patterns.cs (20)
24TypeSymbol? expressionType = expression.Type;
37Debug.Assert(expression.Type is { });
38BoundPattern pattern = BindPattern(node.Pattern, expression.Type, permitDesignations: true, hasErrors, diagnostics, underIsPattern: true);
65Debug.Assert(expression.Type is object);
66diagnostics.Add(ErrorCode.ERR_IsPatternImpossible, node.Location, expression.Type);
82Debug.Assert(expression.Type is object);
83diagnostics.Add(ErrorCode.WRN_IsPatternAlways, node.Location, expression.Type);
248Debug.Assert(indexerAccess.Type is not null);
249sliceType = indexerAccess.Type;
322Debug.Assert(indexerAccess!.Type is not null);
323elementType = indexerAccess.Type;
427var convertedType = convertedExpression.Type ?? inputType;
515Debug.Assert(expression is { Kind: BoundKind.TypeExpression, Type: { } });
516hasErrors |= CheckValidPatternType(patternExpression, inputType, expression.Type, diagnostics: diagnostics);
578if (convertedExpression.Type is null && constantValueOpt != ConstantValue.Null)
619RoslynDebug.Assert(expression.Type is { });
620ConstantValue match = ExpressionOfTypeMatchesPatternType(Conversions, inputType, expression.Type, ref useSiteInfo, out _, operandConstantValue: null);
652if (expression.Type?.SpecialType == SpecialType.System_String && inputType.IsSpanOrReadOnlySpanChar())
707(conversion.ConversionKind == ConversionKind.NoConversion && convertedExpression.Type?.IsErrorType() == true))
1633var type = value.Type ?? inputType;
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());
1607if (!hasErrors && op1.Type.IsRefLikeOrAllowsRefLikeType())
1830Debug.Assert((object)receiver.Type != null);
1831return receiver.Type;
1957this.Conversions.ClassifyConversionFromType(expression.Type, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
1989expression.Type,
2449var sourceType = operand.Type;
3057hasErrors |= arg.HasErrors || ((object)arg.Type != null && arg.Type.IsErrorType());
3132if ((object)arg?.Type != null && arg.Type.IsVoidType())
3196&& TypeSymbol.Equals(argument.Type, this.GetCurrentReturnType(out unusedRefKind), TypeCompareKind.ConsiderEverything2))
3199Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType, argument.Type);
3533else if (expression.Type?.SpecialType == SpecialType.System_Void)
Binder\ForEachLoopBinder.cs (21)
553(builder.ElementType.IsPointerOrFunctionPointer() && collectionExpr.Type.IsArray()) ||
554(builder.ElementType.IsNullableType() && builder.ElementType.GetMemberTypeArgumentsNoUseSiteDiagnostics().Single().IsErrorType() && collectionExpr.Type.IsArray()));
585(collectionConversionClassification.Kind == ConversionKind.ExplicitReference && collectionExpr.Type.SpecialType == SpecialType.System_String));
654Debug.Assert(collectionType.Equals(collectionExpr.Type, TypeCompareKind.AllIgnoreOptions)); // Should not create an Identity conversion that changes type.
693else if (collectionExpr.Type.SpecialType == SpecialType.System_String && builder.CollectionType.SpecialType == SpecialType.System_Collections_IEnumerable)
711TypeSymbol collectionExprType = collectionExpr.Type;
788TypeSymbol collectionExprType = collectionExpr.Type;
827if (!isAsync && collectionExpr.Type?.HasInlineArrayAttribute(out _) == true && collectionExpr.Type.TryGetPossiblyUnsupportedByLanguageInlineArrayElementField() is FieldSymbol elementField)
858diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type);
881builder.CollectionType = collectionExpr.Type;
898CheckInlineArrayTypeIsSupported(collectionExpr.Syntax, collectionExpr.Type, elementField.Type, diagnostics);
906diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type);
919(originalCollectionExpr.Type?.IsNullableType() == true && originalCollectionExpr.Type.StrippedType().Equals(collectionExpr.Type, TypeCompareKind.AllIgnoreOptions)));
930TypeSymbol collectionExprType = collectionExpr.Type;
970var unwrappedCollectionExprType = unwrappedCollectionExpr.Type;
1049builder.CollectionType = collectionExpr.Type;
1359getEnumeratorInfo = FindForEachPatternMethod(syntax, collectionSyntax, collectionExpr.Type, methodName, lookupResult, warningsOnly: true, diagnostics, isAsync);
1603diagnostics.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 (27)
67TypeSymbol leftOperatorSourceOpt = left.Type?.StrippedType();
68TypeSymbol rightOperatorSourceOpt = right.Type?.StrippedType();
360var leftType = left.Type;
362var rightType = right.Type;
504bool isExactSubtraction = TypeSymbol.Equals(right.Type?.StrippedType(), underlying, TypeCompareKind.ConsiderEverything2);
608var leftType = left.Type;
614var rightType = right.Type;
683var leftType = left.Type as PointerTypeSymbol;
684var rightType = right.Type as PointerTypeSymbol;
699if ((object)leftType != null || (object)rightType != null || left.Type is FunctionPointerTypeSymbol || right.Type is FunctionPointerTypeSymbol)
721if ((left.Type is TypeParameterSymbol { AllowsRefLikeType: true } && right.IsLiteralNull()) ||
722(right.Type is TypeParameterSymbol { AllowsRefLikeType: true } && left.IsLiteralNull()))
741this.Compilation.BuiltInOperators.GetSimpleBuiltInOperators(kind, operators, skipNativeIntegerOperators: !left.Type.IsNativeIntegerOrNullableThereof() && !right.Type.IsNativeIntegerOrNullableThereof());
756this.Compilation.BuiltInOperators.GetUtf8ConcatenationBuiltInOperator(left.Type, operators);
767BuiltInOperators.IsValidObjectEquality(conversions, left.Type, left.IsLiteralNull(), leftIsDefault: false, right.Type, right.IsLiteralNull(), rightIsDefault: false, ref useSiteInfo) &&
768((object)left.Type == null || (!left.Type.IsDelegateType() && left.Type.SpecialType != SpecialType.System_String && left.Type.SpecialType != SpecialType.System_Delegate)) &&
769((object)right.Type == null || (!right.Type.IsDelegateType() && right.Type.SpecialType != SpecialType.System_String && right.Type.SpecialType != SpecialType.System_Delegate));
779return (operand.Type is TypeParameterSymbol { AllowsRefLikeType: true }) ? Conversion.Boxing : Conversions.ClassifyConversionFromExpression(operand, objectType, isChecked: isChecked, ref useSiteInfo);
Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (6)
522diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, location, receiver.Type);
662diagnostics.Add(ErrorCode.ERR_QueryNoProvider, location, receiverOpt.Type, symbol.Name);
670diagnostics.Add(ErrorCode.ERR_BadAwaitArg, location, receiverOpt.Type);
1132diagnostics.Add(ErrorCode.ERR_CollectionExpressionMissingAdd, location, receiver.Type);
1371=> argument is BoundLiteral { Type.SpecialType: SpecialType.System_String } &&
1410diagnostics.Add(ErrorCode.ERR_QueryMultipleProviders, location, receiver.Type, name);
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);
737Debug.Assert(argument.Type.IsDynamic() || argument is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None }, "passing args byref should not clone them into temps");
792EmitLoadIndirect(expression.Type, expression.Syntax);
801var meth = expression.MethodOpt ?? receiver.Type.DelegateInvokeMethod();
1014if (((ArrayTypeSymbol)arrayAccess.Expression.Type).IsSZArray)
1101_builder.EmitArrayElementLoad(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Expression.Syntax);
1132if (!field.IsVolatile && !field.IsStatic && fieldAccess.ReceiverOpt.Type.IsVerifierValue() && field.RefKind == RefKind.None)
1171if (fieldType.IsValueType && (object)fieldType == (object)receiver.Type)
1227if (receiver == null || !receiver.Type.IsValueType)
1238EmitSymbolToken(receiver.Type, receiver.Syntax);
1267if (!receiver.Type.IsVerifierValue())
1319var type = expr.Type;
1510if (receiver.Type.IsTypeParameter())
1515Debug.Assert(receiver.Type.IsVerifierReference(), "this is not a reference");
1645Debug.Assert(TypeSymbol.Equals(method.ContainingType, receiver.Type, TypeCompareKind.ConsiderEverything2));
1674EmitSymbolToken(receiver.Type, receiver.Syntax);
1831var receiverType = receiver.Type;
1917var receiverType = receiver.Type;
1977Debug.Assert(receiver.Type.IsVerifierReference());
1988Debug.Assert(receiver.Type.IsVerifierReference());
2008EmitSymbolToken(receiver.Type, receiver.Syntax);
2023var receiverType = receiver.Type;
2086var receiverType = receiver.Type;
2598var rightType = right.Type;
2654if (left.Kind == BoundKind.ArrayAccess && left.Type.TypeKind == TypeKind.TypeParameter && !left.Type.IsValueType)
2678EmitSymbolToken(target.Type, target.Syntax);
3050assignmentOperator.Left.Type,
3097var arrayType = (ArrayTypeSymbol)array.Type;
3111EmitIndirectStore(expression.Type, expression.Syntax);
3116EmitIndirectStore(expression.Type, expression.Syntax);
3122EmitIndirectStore(expression.Type, expression.Syntax);
3134EmitIndirectStore(expression.Type, expression.Syntax);
3139EmitIndirectStore(expression.Type, expression.Syntax);
3385Debug.Assert((object)operand.Type != null);
3386if (!operand.Type.IsVerifierReference())
3389EmitBox(operand.Type, operand.Syntax);
3412var operandType = operand.Type;
3906if (!(expr.Type.IsInterfaceType() || expr.Type.IsDelegateType()))
3908return expr.Type;
3953return expr.Type;
4024temp = AllocateTemp(ptrInvocation.InvokedExpression.Type, ptrInvocation.Syntax);
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)
2059type = boundExpr.Type;
2178convertedType = highestBoundExpr.Type;
2184convertedType = highestBoundExpr.Type;
2273static (TypeSymbol, NullabilityInfo) getTypeAndNullability(BoundExpression expr) => (expr.Type, expr.TopLevelNullability);
3385else if (expr.Type.IsDelegateType())
3694var thisParam = GetThisParameter(boundNode.Type, containingType, containingMember, out resultKind);
3818symbols = OneOrMany.Create<Symbol>(new SynthesizedIntrinsicOperatorSymbol(unaryOperator.Operand.Type.StrippedType(),
3841TypeSymbol opType = increment.Operand.Type.StrippedType();
3868((binaryOperator.Left.IsLiteralNull() && binaryOperator.Right.Type.IsNullableType()) ||
3869(binaryOperator.Right.IsLiteralNull() && binaryOperator.Left.Type.IsNullableType())) &&
3883binaryOperator.Left.Type,
3884binaryOperator.Right.Type,
4094TypeSymbol type = boundNode.Type;
4618if (node.SearchExtensions && receiver.Type is { } receiverType)
4760receiverType = call.ReceiverOpt.Type;
4764receiverType = call.Arguments[0].Type;
4794MethodSymbol reduced = method.ReduceExtensionMethod(receiver.Type, Compilation);
4809MethodSymbol reduced = method.ReduceExtensionMethod(receiverOpt.Type, Compilation);
FlowAnalysis\NullableWalker.cs (62)
411expr.Type?.Equals(result.RValueType.Type, TypeCompareKind.AllIgnoreOptions) == true ? result.RValueType.Type : expr.Type);
547Debug.Assert(AreCloseEnough(placeholder.Type, result.RValueType.Type));
2092receiver.Type is object;
2103TypeSymbol? nodeType = node.Type;
2139var operandType = operand.Type;
2157TypeSymbol.Equals(conv.Type, conv.Operand.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes):
3705Debug.Assert(AreCloseEnough(resultType.Type, node.Type));
4514SetAnalyzedNullability(node.ImplicitReceiverOpt, new VisitResult(node.ImplicitReceiverOpt.Type, NullableAnnotation.NotAnnotated, NullableFlowState.NotNull));
4572SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull));
4577var resultType = TypeWithState.Create(node.Type, NullableFlowState.NotNull);
4624Debug.Assert(node.Type is object);
4625if (IsEmptyStructType(node.Type))
4630return GetOrCreatePlaceholderSlot(node, TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated));
4948Debug.Assert(!node.Expression.Type!.IsValueType);
4962TypeSymbol.Equals(node.Indices[0].Type, compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.ConsiderEverything2))
5282if (expr.Type is null)
5292TypeWithAnnotations.Create(expr.Type),
5306Debug.Assert(binary.Type!.SpecialType == SpecialType.System_Boolean);
5506var receiverType = conditional.Receiver.Type!;
5535if (slot > 0 && PossiblyNullableType(operand.Type))
5605LearnFromNullTest(slot, expressionWithoutConversion.Type, ref state, markDependentSlotsNotNull: false);
5719node.Type?.ContainsErrorType() == true ||
5720TypeSymbol.Equals(targetType.Type.GetNullableUnderlyingType(), node.Type, TypeCompareKind.AllIgnoreOptions));
5726targetType = TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated);
6016if (slot > 0 && receiver.Type?.IsNullableType() == true)
6017slot = GetNullableOfTValueSlot(receiver.Type, slot, out _);
6061TypeSymbol? refResultType = node.Type?.SetUnknownNullabilityForReferenceTypes();
6127resultType ??= node.Type?.SetUnknownNullabilityForReferenceTypes();
7254TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState.Create(argument.Type, result.RValueType.State), argument as BoundConversion, argumentNoConversion);
7372completion(TypeWithAnnotations.Create(argument.Type));
8470if (value.Type is null || value.Type.IsDynamic() || value.ConstantValueOpt != null)
8480value.Type.HasInlineArrayAttribute(out _) == true &&
8481value.Type.TryGetInlineArrayElementField() is not null)
8620if (TypeAllowsConditionalState(targetType.Type) && TypeAllowsConditionalState(operand.Type))
8768var tupleOpt = (NamedTypeSymbol?)node.Type;
9960case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate }:
10074Debug.Assert(arg.Type is not null);
10075TypeSymbol argType = arg.Type;
10093Debug.Assert(arg.Type is not null);
10094TypeSymbol argType = arg.Type;
10274var rvalueResult = TypeWithState.Create(node.Type, NullableFlowState.NotNull);
10275var lvalueResult = TypeWithAnnotations.Create(node.Type, NullableAnnotation.NotAnnotated);
10775if (expr.Type is NamedTypeSymbol { IsTupleType: true } tupleType)
10992SetResultType(node.Expression, TypeWithState.Create(node.Expression.Type, ResultType.State));
11364if (collectionExpression.Type!.SpecialType == SpecialType.System_Collections_IEnumerable)
11367targetTypeWithAnnotations = TypeWithAnnotations.Create(collectionExpression.Type);
11369else if (ForEachLoopBinder.IsIEnumerableT(collectionExpression.Type.OriginalDefinition, isAsync, compilation))
11633var type = TypeWithAnnotations.Create(node.Type);
12029SetResultType(node, TypeWithState.Create(node.Type, node.Type?.CanContainNull() != false && node.ConstantValueOpt?.IsNull == true ? NullableFlowState.MaybeDefault : NullableFlowState.NotNull));
12206SetResultType(expression, TypeWithState.Create(expression.Type, default));
12240Debug.Assert(receiverOpt.Type is null || AreCloseEnough(receiverOpt.Type, resultTypeSymbol));
12328SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull));
12361Debug.Assert(node.Type is null || node.Type.IsErrorType() || node.Type.IsRefLikeType);
12377SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull));
12381Debug.Assert(node.Type is not null);
12382var type = VisitArrayInitialization(node.Type, initialization, node.HasErrors);
Generated\BoundNodes.xml.Generated.cs (187)
488if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
518if (receiver != this.Receiver || localScopeDepth != this.LocalScopeDepth || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
550public new TypeSymbol Type => base.Type!;
587public new TypeSymbol Type => base.Type!;
616public new TypeSymbol? Type => base.Type;
651public new TypeSymbol Type => base.Type!;
688public new TypeSymbol Type => base.Type!;
724public new TypeSymbol Type => base.Type!;
761public new TypeSymbol Type => base.Type!;
797public new TypeSymbol Type => base.Type!;
832public new TypeSymbol Type => base.Type!;
867public new TypeSymbol Type => base.Type!;
902public new TypeSymbol Type => base.Type!;
940if (refKind != this.RefKind || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
968if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
1001if (resultKind != this.ResultKind || symbols != this.Symbols || childBoundNodes != this.ChildBoundNodes || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
1084public new TypeSymbol Type => base.Type!;
1122public new TypeSymbol Type => base.Type!;
1162public new TypeSymbol? Type => base.Type;
1199public new TypeSymbol Type => base.Type!;
1244public new TypeSymbol Type => base.Type!;
1284public new TypeSymbol Type => base.Type!;
1315public new TypeSymbol? Type => base.Type;
1358public new TypeSymbol Type => base.Type!;
1388public new TypeSymbol Type => base.Type!;
1423public new TypeSymbol Type => base.Type!;
1460public new TypeSymbol Type => base.Type!;
1494public new TypeSymbol Type => base.Type!;
1525public new TypeSymbol Type => base.Type!;
1556public new TypeSymbol Type => base.Type!;
1588public new TypeSymbol Type => base.Type!;
1620public new TypeSymbol Type => base.Type!;
1654public new TypeSymbol Type => base.Type!;
1710public new TypeSymbol Type => base.Type!;
1801public new TypeSymbol Type => base.Type!;
1841public new TypeSymbol Type => base.Type!;
1876public new TypeSymbol Type => base.Type!;
1914public new TypeSymbol Type => base.Type!;
1958if (leftOperand != this.LeftOperand || rightOperand != this.RightOperand || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
1985public new TypeSymbol? Type => base.Type;
2027public new TypeSymbol Type => base.Type!;
2065public new TypeSymbol Type => base.Type!;
2095public new TypeSymbol? Type => base.Type;
2125public new TypeSymbol Type => base.Type!;
2191public new TypeSymbol Type => base.Type!;
2231public new TypeSymbol Type => base.Type!;
2318public new TypeSymbol Type => base.Type!;
2360public new TypeSymbol Type => base.Type!;
2403public new TypeSymbol Type => base.Type!;
2440public new TypeSymbol Type => base.Type!;
2475public new TypeSymbol Type => base.Type!;
2513public new TypeSymbol Type => base.Type!;
2548public new TypeSymbol Type => base.Type!;
2583public new TypeSymbol Type => base.Type!;
2618public new TypeSymbol Type => base.Type!;
2653public new TypeSymbol Type => base.Type!;
2692public new TypeSymbol Type => base.Type!;
2734public new TypeSymbol Type => base.Type!;
2777public new TypeSymbol Type => base.Type!;
2808public new TypeSymbol? Type => base.Type;
2831public new TypeSymbol Type => base.Type!;
2865public new TypeSymbol Type => base.Type!;
2901public new TypeSymbol Type => base.Type!;
2935public new TypeSymbol Type => base.Type!;
2972public new TypeSymbol Type => base.Type!;
3010public new TypeSymbol Type => base.Type!;
3047public new TypeSymbol Type => base.Type!;
3076public new TypeSymbol? Type => base.Type;
3112public new TypeSymbol Type => base.Type!;
4322if (constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
4354public new TypeSymbol Type => base.Type!;
4390public new TypeSymbol Type => base.Type!;
4425public new TypeSymbol Type => base.Type!;
4460public new TypeSymbol Type => base.Type!;
4489public new TypeSymbol? Type => base.Type;
4534public new TypeSymbol Type => base.Type!;
4581public new TypeSymbol Type => base.Type!;
4614public new TypeSymbol Type => base.Type!;
4655public new TypeSymbol Type => base.Type!;
4800if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(label, this.Label) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
4961if (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))
4986public new TypeSymbol Type => base.Type!;
5733public new TypeSymbol? Type => base.Type;
5756if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
5782public new TypeSymbol Type => base.Type!;
5818public new TypeSymbol Type => base.Type!;
5855public new TypeSymbol Type => base.Type!;
5910public new TypeSymbol Type => base.Type!;
5944public new TypeSymbol Type => base.Type!;
5981public new TypeSymbol Type => base.Type!;
6024public new TypeSymbol Type => base.Type!;
6056public new TypeSymbol Type => base.Type!;
6169public new TypeSymbol Type => base.Type!;
6216public new TypeSymbol Type => base.Type!;
6258public new TypeSymbol Type => base.Type!;
6299public new TypeSymbol? Type => base.Type;
6339public new TypeSymbol Type => base.Type!;
6417public new TypeSymbol? Type => base.Type;
6454public new TypeSymbol Type => base.Type!;
6497if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
6575public new TypeSymbol? Type => base.Type;
6612if (sourceTuple != this.SourceTuple || wasTargetTyped != this.WasTargetTyped || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || inferredNamesOpt != this.InferredNamesOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
6711public new TypeSymbol Type => base.Type!;
6766public new TypeSymbol Type => base.Type!;
6819public new TypeSymbol Type => base.Type!;
6886public new TypeSymbol Type => base.Type!;
6925public new TypeSymbol Type => base.Type!;
6961public new TypeSymbol Type => base.Type!;
6994public new TypeSymbol Type => base.Type!;
7036public new TypeSymbol Type => base.Type!;
7099public new TypeSymbol Type => base.Type!;
7133public new TypeSymbol Type => base.Type!;
7164public new TypeSymbol? Type => base.Type;
7219if (!TypeSymbol.Equals(elementType, this.ElementType, TypeCompareKind.ConsiderEverything) || count != this.Count || initializerOpt != this.InitializerOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
7241public new TypeSymbol Type => base.Type!;
7275public new TypeSymbol Type => base.Type!;
7320public new TypeSymbol Type => base.Type!;
7354public new TypeSymbol Type => base.Type!;
7391public new TypeSymbol Type => base.Type!;
7435public new TypeSymbol Type => base.Type!;
7489public new TypeSymbol Type => base.Type!;
7532public new TypeSymbol Type => base.Type!;
7571public new TypeSymbol Type => base.Type!;
7613public new TypeSymbol? Type => base.Type;
7657public new TypeSymbol? Type => base.Type;
7695public new TypeSymbol Type => base.Type!;
7758public new TypeSymbol Type => base.Type!;
7809if (parts != this.Parts || constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
7837if (!interpolationData.Equals(this.InterpolationData) || parts != this.Parts || constantValueOpt != this.ConstantValueOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
7865if (!TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
7895public new TypeSymbol Type => base.Type!;
7927public new TypeSymbol? Type => base.Type;
7980if (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))
8580public new TypeSymbol? Type => base.Type;
8617if (expression != this.Expression || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
8639public new TypeSymbol? Type => base.Type;
8712public new TypeSymbol? Type => base.Type;
8810public new TypeSymbol? Type => base.Type;
8843public new TypeSymbol Type => base.Type!;
10866TypeSymbol? type = this.VisitType(node.Type);
10872TypeSymbol? type = this.VisitType(node.Type);
10933TypeSymbol? type = this.VisitType(node.Type);
10939TypeSymbol? type = this.VisitType(node.Type);
10946TypeSymbol? type = this.VisitType(node.Type);
11141TypeSymbol? type = this.VisitType(node.Type);
11557TypeSymbol? type = this.VisitType(node.Type);
11631TypeSymbol? type = this.VisitType(node.Type);
11660TypeSymbol? type = this.VisitType(node.Type);
11808TypeSymbol? type = this.VisitType(node.Type);
11945TypeSymbol? type = this.VisitType(node.Type);
11968TypeSymbol? type = this.VisitType(node.Type);
12079TypeSymbol? type = this.VisitType(node.Type);
12190TypeSymbol? type = this.VisitType(node.Type);
12196TypeSymbol? type = this.VisitType(node.Type);
12201TypeSymbol? type = this.VisitType(node.Type);
12224TypeSymbol? type = this.VisitType(node.Type);
12349TypeSymbol? type = this.VisitType(node.Type);
12463updatedNode = node.Update(receiver, node.LocalScopeDepth, node.Type);
12629updatedNode = node.Update(expression, node.Type);
12647updatedNode = node.Update(node.ResultKind, node.Symbols, childBoundNodes, node.Type);
13042updatedNode = node.Update(leftOperand, rightOperand, node.Type);
13834updatedNode = node.Update(expression, switchArms, reachabilityDecisionDag, node.DefaultLabel, node.ReportedNotExhaustive, node.Type);
13929updatedNode = node.Update(expression, node.Type);
14291updatedNode = node.Update(sourceTuple, node.WasTargetTyped, arguments, node.ArgumentNamesOpt, node.InferredNamesOpt, node.Type);
14574updatedNode = node.Update(elementType, count, initializerOpt, node.Type);
14812updatedNode = node.Update(parts, node.ConstantValueOpt, node.Type);
14829updatedNode = node.Update(node.InterpolationData, parts, node.ConstantValueOpt, node.Type);
14891updatedNode = node.Update(expression, pattern, node.IsNegated, reachabilityDecisionDag, node.WhenTrueLabel, node.WhenFalseLabel, node.Type);
15040updatedNode = node.Update(expression, node.Type);
15182new TreeDumperNode("type", node.Type, null),
15191new TreeDumperNode("type", node.Type, null),
15280new TreeDumperNode("type", node.Type, null),
15288new TreeDumperNode("type", node.Type, null),
15298new TreeDumperNode("type", node.Type, null),
15570new TreeDumperNode("type", node.Type, null),
16132new TreeDumperNode("type", node.Type, null),
16234new TreeDumperNode("type", node.Type, null),
16270new TreeDumperNode("type", node.Type, null),
16456new TreeDumperNode("type", node.Type, null),
16673new TreeDumperNode("type", node.Type, null),
16707new TreeDumperNode("type", node.Type, null),
16873new TreeDumperNode("type", node.Type, null),
17040new TreeDumperNode("type", node.Type, null),
17050new TreeDumperNode("type", node.Type, null),
17057new TreeDumperNode("type", node.Type, null),
17089new TreeDumperNode("type", node.Type, null),
17243new 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)
200TypeSymbol inputType = input.Type;
213Conversion conversion = _factory.Compilation.Conversions.ClassifyBuiltInConversion(inputType, output.Type, isChecked: false, ref useSiteInfo);
221inputType.GetNullableUnderlyingType().Equals(output.Type, TypeCompareKind.AllIgnoreOptions) &&
342Debug.Assert(input.Type is { });
346return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullNotEqual : BinaryOperatorKind.NotEqual);
353return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullEqual : BinaryOperatorKind.Equal);
356Debug.Assert(!input.Type.IsNullableType());
360Debug.Assert(!input.Type.IsNullableType());
361Debug.Assert(input.Type.IsValueType);
371Debug.Assert(!rewrittenExpr.Type.IsSpanOrReadOnlySpanChar());
373if (rewrittenExpr.Type.IsPointerOrFunctionPointer())
391if (value.IsString && input.Type.IsSpanOrReadOnlySpanChar())
396TypeSymbol comparisonType = input.Type.EnumUnderlyingTypeOrSelf();
405if (input.Type.SpecialType == SpecialType.System_Double && double.IsNaN(value.DoubleValue) ||
406input.Type.SpecialType == SpecialType.System_Single && float.IsNaN(value.SingleValue))
412BoundExpression literal = _localRewriter.MakeLiteral(syntax, value, input.Type);
413TypeSymbol comparisonType = input.Type.EnumUnderlyingTypeOrSelf();
435var isReadOnlySpan = input.Type.IsReadOnlySpanChar();
477Debug.Assert(output.Type is { });
479testExpression = _factory.ObjectNotEqual(output, _factory.Null(output.Type));
513Debug.Assert(loweredInput.Type is { });
554if (loweredInput.Type.IsTupleType &&
555!loweredInput.Type.OriginalDefinition.Equals(_factory.Compilation.GetWellKnownType(WellKnownType.System_ValueTuple_TRest)) &&
629var 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)
176Debug.Assert(singleSpread.Expression.Type is not null);
178if (!ShouldUseIEnumerableBulkAddMethod(singleSpread.Expression.Type, toListOfElementType.Parameters[0].Type, singleSpread.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))
224Elements: [BoundCollectionExpressionSpreadElement { Expression: { Type: NamedTypeSymbol spreadType } expr }],
316Debug.Assert(list.Type is { });
317Debug.Assert(list.Type.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_Collections_Generic_List_T), TypeCompareKind.AllIgnoreOptions));
319var listToArray = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_Collections_Generic_List_T__ToArray)).AsMember((NamedTypeSymbol)list.Type);
328Debug.Assert(TypeSymbol.Equals(array.Type, spanConstructor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions));
665var spreadTypeOriginalDefinition = spreadExpression.Type!.OriginalDefinition;
671return _factory.Call(rewrittenSpreadExpression, listToArrayMethod.AsMember((NamedTypeSymbol)spreadExpression.Type!));
681&& ShouldUseIEnumerableBulkAddMethod(spreadExpression.Type!, linqToArrayMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))
688&& TryGetSpanConversion(spreadExpression.Type, writableOnly: false, out var asSpanMethod))
690var spanType = CallAsSpanMethod(spreadExpression, asSpanMethod).Type!.OriginalDefinition;
695return _factory.Call(rewrittenSpreadExpression, toArrayMethod.AsMember((NamedTypeSymbol)rewrittenSpreadExpression.Type!));
789Debug.Assert(arrayTemp.Type is ArrayTypeSymbol);
793var elementType = ((ArrayTypeSymbol)arrayTemp.Type).ElementType;
903var type = expression.Type;
970if (spreadOperandAsSpan.Type!.OriginalDefinition.Equals(this._compilation.GetWellKnownType(wellKnownSpanType))
1009var spreadLength = _factory.Call(spreadOperandAsSpan, getLengthMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!));
1010var targetSlice = _factory.Call(spanTemp, spanSliceMethod.AsMember((NamedTypeSymbol)spanTemp.Type!), indexTemp, spreadLength);
1011sideEffects.Add(_factory.Call(spreadOperandAsSpan, copyToMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!), targetSlice));
1125Debug.Assert(spanTemp.Type is NamedTypeSymbol);
1129var elementType = ((NamedTypeSymbol)spanTemp.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type;
1178Debug.Assert(rewrittenSpreadOperand.Type is not null);
1183if (!ShouldUseIEnumerableBulkAddMethod(rewrittenSpreadOperand.Type, addRangeMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))
1318_factory.Binary(BinaryOperatorKind.Addition, sum.Type!, sum, value);
1353if (convertedExpression.Operand.Type is ArrayTypeSymbol arrayType)
Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (28)
24Debug.Assert(TypeSymbol.Equals(node.Right.Type, node.Operator.RightType, TypeCompareKind.ConsiderEverything2));
47TypeSymbol? leftType = node.Left.Type; // type of the target
139Debug.Assert(rewrittenAssignment.Type is { });
142var condition = _factory.Conditional(isEvent, invokeEventAccessor.ToExpression(), rewrittenAssignment, rewrittenAssignment.Type);
144rewrittenAssignment = new BoundSequence(node.Syntax, eventTemps.ToImmutableAndFree(), sequence.ToImmutableAndFree(), condition, condition.Type!);
151Debug.Assert(rewrittenAssignment.Type is { });
159rewrittenAssignment.Type);
202Debug.Assert(node.Left.Type is { });
214Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.Left.Type, TypeCompareKind.AllIgnoreOptions));
260Debug.Assert(rewrittenReceiver.Type is { });
261var variableRepresentsLocation = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter;
471indexerAccess.Argument.Type,
478throw ExceptionUtilities.UnexpectedValue(indexerAccess.Argument.Type);
499if (isDynamicAssignment || !IsInvariantArray(arrayAccess.Expression.Type))
527Debug.Assert(receiver is { Type: { } });
532else if (!receiver.Type.IsReferenceType)
537Debug.Assert(receiver.Type.IsReferenceType);
541Debug.Assert(rewrittenReceiver.Type is { });
542if (rewrittenReceiver.Type.IsTypeParameter())
680Debug.Assert(implicitIndexerAccess.Argument.Type!.Equals(_compilation.GetWellKnownType(WellKnownType.System_Index))
681|| implicitIndexerAccess.Argument.Type!.Equals(_compilation.GetWellKnownType(WellKnownType.System_Range)));
710if (isDynamicAssignment || !IsInvariantArray(arrayAccess.Expression.Type))
891var type = expression.Type;
907var type = expression.Type;
963Debug.Assert(expression.Type is { });
964if (expression.Type.IsNullableType())
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;
811Debug.Assert(rewrittenOperand.Type is { });
813Conversion conversion = compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, isChecked: @checked, ref useSiteInfo);
819rewrittenOperand.Type.SpecialType != SpecialType.System_Decimal &&
820rewrittenOperand.Type.SpecialType != SpecialType.System_DateTime)
826rewrittenOperand.Type,
872if (!TypeSymbol.Equals(rewrittenOperand.Type, conversion.BestUserDefinedConversionAnalysis.FromType, TypeCompareKind.ConsiderEverything2))
882if (!TypeSymbol.Equals(rewrittenOperand.Type, conversion.Method.GetParameterType(0), TypeCompareKind.ConsiderEverything2))
895Debug.Assert(rewrittenOperand.Type is { });
896if (rewrittenOperand.Type.IsNullableType() &&
897conversion.Method.GetParameterType(0).Equals(rewrittenOperand.Type.GetNullableUnderlyingType(), TypeCompareKind.AllIgnoreOptions) &&
901userDefinedConversionRewrittenType = ((NamedTypeSymbol)rewrittenOperand.Type.OriginalDefinition).Construct(userDefinedConversionRewrittenType);
911if (!TypeSymbol.Equals(userDefined.Type, conversion.BestUserDefinedConversionAnalysis.ToType, TypeCompareKind.ConsiderEverything2))
920if (!TypeSymbol.Equals(userDefined.Type, rewrittenType, TypeCompareKind.ConsiderEverything2))
952Debug.Assert(rewrittenOperand.Type is { });
956var tupleTypeSymbol = (NamedTypeSymbol)rewrittenOperand.Type;
993Debug.Assert(expression.Type is { });
994if (!expression.Type.IsNullableType())
1006when convertedArgument.Type!.Equals(expression.Type.StrippedType(), TypeCompareKind.AllIgnoreOptions):
1011when underlying.Length == 1 && underlying[0].Kind == ConversionKind.ImplicitTuple && !convertedArgument.Type!.IsNullableType():
1046TypeSymbol? rewrittenOperandType = rewrittenOperand.Type;
1096Debug.Assert(rewrittenOperand.Type is { });
1097TypeSymbol rewrittenOperandType = rewrittenOperand.Type;
1310Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2));
1311Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2));
1343Debug.Assert(rewrittenOperand.Type is { });
1344if (rewrittenOperand.Type.IsNullableType())
1347if (parameterType.Equals(rewrittenOperand.Type.GetNullableUnderlyingType(), TypeCompareKind.AllIgnoreOptions) &&
1361if ((rewrittenOperand.Type.IsArray()) && _compilation.IsReadOnlySpanType(rewrittenType))
1373Debug.Assert(TypeSymbol.Equals(result.Type, rewrittenType, TypeCompareKind.ConsiderEverything2));
1396Debug.Assert(rewrittenOperand.Type is { });
1399Conversion conv = TryMakeConversion(syntax, conversion, rewrittenOperand.Type, rewrittenType, @checked: @checked);
1411Debug.Assert(rewrittenOperand.Type.IsNullableType());
1488Debug.Assert(rewrittenOperand.Type is { });
1491TypeSymbol source = rewrittenOperand.Type;
1714Debug.Assert(operand.Type is { });
1715return RewriteDecimalConversionCore(syntax, operand, operand.Type, toType, isImplicit, constantValueOpt);
Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (37)
119Debug.Assert(oldNode.Type is not null);
120Debug.Assert(oldNode.Type.Equals(type, TypeCompareKind.ConsiderEverything));
180Debug.Assert(call.Type is not null);
194call.Type);
203Debug.Assert(node.Expression.Type is object);
204Debug.Assert(node.Argument.Type is object);
219_ = node.Expression.Type.HasInlineArrayAttribute(out int length);
221if (node.Argument.Type.SpecialType == SpecialType.System_Int32)
229if (TypeSymbol.Equals(node.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.AllIgnoreOptions))
241Debug.Assert(TypeSymbol.Equals(node.Argument.Type, _compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.AllIgnoreOptions));
323Debug.Assert(node.Expression.Type is object);
335return createSpan.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type);
340Debug.Assert(node.Expression.Type is object);
341Debug.Assert(index.Type?.SpecialType == SpecialType.System_Int32);
343var intType = (NamedTypeSymbol)index.Type;
362elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type);
381elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type);
436node.Argument.Type,
445node.Argument.Type,
483node.Argument.Type,
499Debug.Assert(receiver.Type is { });
505receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref);
563Debug.Assert(integerArgument.Type!.SpecialType == SpecialType.System_Int32);
659Debug.Assert(loweredExpr.Type!.SpecialType == SpecialType.System_Int32);
670Debug.Assert(loweredExpr.Type!.SpecialType == SpecialType.System_Int32);
677loweredExpr.Type,
710unloweredExpr.Type,
718Debug.Assert(hatExpression.Operand is { Type: { SpecialType: SpecialType.System_Int32 } });
722else if (unloweredExpr is BoundConversion { Operand: { Type: { SpecialType: SpecialType.System_Int32 } } operand })
731arguments[0] is { Type.SpecialType: SpecialType.System_Int32, ConstantValueOpt.Value: int _ and >= 0 } index &&
732arguments[1] is { Type.SpecialType: SpecialType.System_Boolean, ConstantValueOpt.Value: bool fromEnd })
775node.Argument.Type,
801Debug.Assert(receiver.Type is { });
807receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref);
Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (16)
16Debug.Assert(node.Type is { });
20Debug.Assert(node.LeftOperand.Type is { });
24Debug.Assert(transformedLHS.Type is { });
41Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.LeftOperand.Type, TypeCompareKind.AllIgnoreOptions));
45var leftPlaceholder = new BoundValuePlaceholder(lhsRead.Syntax, lhsRead.Type);
46BoundExpression conditionalExpression = MakeNullCoalescingOperator(syntax, lhsRead, assignment, leftPlaceholder: leftPlaceholder, leftConversion: leftPlaceholder, BoundNullCoalescingOperatorResultKind.LeftType, node.LeftOperand.Type);
47Debug.Assert(conditionalExpression.Type is { });
56conditionalExpression.Type);
63Debug.Assert(node.LeftOperand.Type.IsNullableType());
72leftOperand.Type,
80leftOperand.Type,
112Debug.Assert(transformedLHS.Type.GetNullableUnderlyingType().Equals(tmp.Type.StrippedType(), TypeCompareKind.AllIgnoreOptions));
115Debug.Assert(TypeSymbol.Equals(transformedLHS.Type, node.LeftOperand.Type, TypeCompareKind.AllIgnoreOptions));
120MakeConversionNode(tmp, transformedLHS.Type, @checked: false, markAsChecked: true),
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 (18)
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 (8)
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 (26)
132var underlyingType = loweredOperand.Type.GetEnumUnderlyingType();
276Debug.Assert(result.Type is { });
285type: result.Type
328Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Consequence.Type, TypeCompareKind.ConsiderEverything2));
329Debug.Assert(TypeSymbol.Equals(conditional.Type, conditional.Alternative.Type, TypeCompareKind.ConsiderEverything2));
416TypeSymbol? operandType = node.Operand.Type; //type of the variable being incremented
444TypeSymbol? operandType = left.Type; //type of the variable being incremented
453Debug.Assert(TypeSymbol.Equals(operandType, transformedLHS.Type, TypeCompareKind.AllIgnoreOptions));
572TypeSymbol? operandType = transformedLHS.Type; //type of the variable being incremented
645Debug.Assert(boundTemp.Type is not null);
660type: boundTemp.Type);
673Debug.Assert(boundTemp.Type is not null);
676Debug.Assert(tempValue.Type is { });
685tempValue.Type);
699type: boundTemp.Type);
905Debug.Assert(binaryOperand.Type is { TypeKind: TypeKind.Pointer });
906Debug.Assert(boundOne.Type is { SpecialType: SpecialType.System_Int32 });
907return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null, constrainedToTypeOpt: null);
959Debug.Assert(operand.Type is { SpecialType: SpecialType.System_Decimal });
966Debug.Assert(operand.Type is { } && operand.Type.IsNullableType() && operand.Type.GetNullableUnderlyingType().SpecialType == SpecialType.System_Decimal);
970MethodSymbol getValueOrDefault = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T_GetValueOrDefault);
971MethodSymbol ctor = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T__ctor);
982BoundExpression alternative = new BoundDefaultExpression(syntax, operand.Type);
985return RewriteConditionalOperator(syntax, condition, consequence, alternative, ConstantValue.NotAvailable, operand.Type, isRef: false);
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)
1034Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType);
1043var receiverType = receiver.Type;
1074if (!receiver.Type.IsReferenceType && LocalRewriter.CanBePassedByReference(receiver))
1076result = receiver.Type.IsReadOnly ? RefKind.In : RefKind.Ref;
1147Debug.Assert(condition.Type.SpecialType == SpecialType.System_Boolean);
1150var tmp = _F.SynthesizedLocal(condition.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax);
1197type: node.Type));
1254_F.ObjectEqual(_F.Local(tmp), _F.Null(left.Type)),
1286if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None)
1306var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill);
1310var isNotClass = _F.IsNotNullReference(_F.Default(receiver.Type));
1478return UpdateExpression(builder, node.Update(operand, node.Type));
1522return UpdateExpression(builder, node.Update(expression, node.Type));
Lowering\SyntheticBoundNodeFactory.cs (55)
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 } } &&
443Debug.Assert(Conversions.IsValidExtensionMethodThisArgConversion(this.Compilation.Conversions.ClassifyConversionFromType(receiver.Type, extensionParameter.Type, isChecked: false, ref discardedUseSiteInfo)));
457Debug.Assert(left.Type is { } && right.Type is { } &&
458(left.Type.Equals(right.Type, TypeCompareKind.AllIgnoreOptions) ||
460right.Type.IsErrorType() || left.Type.IsErrorType()));
462var assignment = new BoundAssignmentOperator(syntax, left, right, isRef, left.Type, hasErrors) { WasCompilerGenerated = wasCompilerGenerated };
587var conversion = Compilation.Conversions.ClassifyConversionFromType(expression.Type, CurrentFunction.ReturnType, isChecked: false, ref useSiteInfo);
675Conversion c = Compilation.Conversions.ClassifyBuiltInConversion(operand.Type, type, isChecked: false, ref discardedUseSiteInfo);
681Debug.Assert(left.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean);
682Debug.Assert(right.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean);
688Debug.Assert(left.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean);
689Debug.Assert(right.Type?.SpecialType == CodeAnalysis.SpecialType.System_Boolean);
803switch (input.Type)
812throw ExceptionUtilities.UnexpectedValue(input.Type);
937Debug.Assert(valueTypeReceiver.Type is { });
938Debug.Assert(TypeSymbol.Equals(valueTypeReceiver.Type, referenceTypeReceiver.Type, TypeCompareKind.ConsiderEverything2));
939return new BoundComplexConditionalReceiver(Syntax, valueTypeReceiver, referenceTypeReceiver, valueTypeReceiver.Type) { WasCompilerGenerated = true };
944Debug.Assert(left.Type!.Equals(right.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes) || left.Type.IsErrorType());
945Debug.Assert(left.Type.IsReferenceType);
947return new BoundNullCoalescingOperator(Syntax, left, right, leftPlaceholder: null, leftConversion: null, BoundNullCoalescingOperatorResultKind.LeftType, @checked: false, left.Type) { WasCompilerGenerated = true };
1055Debug.Assert(result.Type is { });
1056var resultType = type ?? result.Type;
1062Debug.Assert(result.Type is { });
1066: new BoundSequence(Syntax, locals, sideEffects, result, result.Type) { WasCompilerGenerated = true };
1071Debug.Assert(result.Type is { });
1072return new BoundSpillSequence(Syntax, locals, sideEffects, result, result.Type) { WasCompilerGenerated = true };
1101Debug.Assert(ex.Type is { SpecialType: CodeAnalysis.SpecialType.System_Int32 });
1196Debug.Assert(array.Type is { TypeKind: TypeKind.Array });
1202Debug.Assert(array.Type is { TypeKind: TypeKind.Array });
1203int rank = ((ArrayTypeSymbol)array.Type).Rank;
1215Debug.Assert(array.Type is { TypeKind: TypeKind.Array });
1216return new BoundArrayAccess(Syntax, array, indices, ((ArrayTypeSymbol)array.Type).ElementType);
1502if (TypeSymbol.Equals(type, arg.Type, TypeCompareKind.ConsiderEverything2))
1516arg.Type is TypeParameterSymbol { AllowsRefLikeType: true } && type.IsObjectType())
1532if (conversion.Method is { } && !TypeSymbol.Equals(conversion.Method.Parameters[0].Type, arg.Type, TypeCompareKind.ConsiderEverything2))
1542Debug.Assert(arg.Type is { });
1544arg.Type.IsNullableType() &&
1545arg.Type.GetNullableUnderlyingType().Equals(type, TypeCompareKind.AllIgnoreOptions))
1549return this.Call(arg, this.SpecialMethod(CodeAnalysis.SpecialMember.System_Nullable_T_get_Value).AsMember((NamedTypeSymbol)arg.Type));
1638return new BoundCatchBlock(Syntax, ImmutableArray<LocalSymbol>.Empty, source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false);
1658Debug.Assert(expression is { Type: { SpecialType: CodeAnalysis.SpecialType.System_Boolean } });
1659return new BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.BoolLogicalNegation, expression, null, null, constrainedToTypeOpt: null, LookupResultKind.Viable, expression.Type);
1679Debug.Assert(argument.Type is { });
1712var type = argument.Type;
1782TypeSymbol exprType = rewrittenExpr.Type;
1836LocalRewriter.UnsafeGetNullableMethod(syntax, expression.Type, CodeAnalysis.SpecialMember.System_Nullable_T_get_HasValue, Compilation, Diagnostics));
1900return conditionalAccess.Update(conditionalAccess.Receiver, conditionalAccess.HasValueMethodOpt, whenNotNull, whenNull, conditionalAccess.Id, conditionalAccess.ForceCopyOfNullableValueType, whenNotNull.Type);