82this.Syntax = syntax;

893return new BoundBlock(statement.Syntax, locals, ImmutableArray.Create(statement)) 909return new BoundBlock(statement.Syntax, locals, ImmutableArray<MethodSymbol>.CastUp(localFunctions), hasUnsafeModifier: false, instrumentation: null,

192return new ExecutableCodeBinder(unboundLambda.Syntax, lambdaSymbol, unboundLambda.GetWithParametersBinder(lambdaSymbol, enclosingBinder));

695BindDefaultArguments(indexerAccess.Syntax, parameters, extensionReceiver: null, argumentsBuilder, refKindsBuilderOpt, namesBuilder, ref argsToParams, out defaultArguments, indexerAccess.Expanded, enableCallerInfo: true, diagnostics: diagnostics); 749Debug.Assert(expr.Syntax.Kind() != SyntaxKind.Argument || valueKind == BindValueKind.RefOrOut); 861diagnostics.Add(expr.Syntax, useSiteInfo); 896expr.Syntax, 904if (!hasResolutionErrors && CheckValueKind(expr.Syntax, expr, valueKind, checkingReceiver: false, diagnostics: diagnostics) || 1120return CheckMethodReturnValueKind(call.Method, call.Syntax, node, valueKind, checkingReceiver, diagnostics); 1124expr.Syntax, 1138return CheckMethodReturnValueKind(sliceAccess.Method, sliceAccess.Syntax, node, valueKind, checkingReceiver, diagnostics); 1163return CheckMethodReturnValueKind(getItemOrSliceHelper, elementAccess.Syntax, node, valueKind, checkingReceiver, diagnostics); 1183(CheckValueKind(conditional.Consequence.Syntax, conditional.Consequence, valueKind, checkingReceiver: false, diagnostics: diagnostics) & 1184CheckValueKind(conditional.Alternative.Syntax, conditional.Alternative, valueKind, checkingReceiver: false, diagnostics: diagnostics))) 1262Error(diagnostics, ErrorCode.ERR_BadSKknown, expr.Syntax, ((BoundNamespaceExpression)expr).NamespaceSymbol, MessageID.IDS_SK_NAMESPACE.Localize(), MessageID.IDS_SK_VARIABLE.Localize()); 1268if (!IsInPossibleBadNegCastContext(expr.Syntax)) 1270Error(diagnostics, ErrorCode.ERR_BadSKunknown, expr.Syntax, expr.Type, MessageID.IDS_SK_TYPE.Localize()); 1327diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, local.Syntax.Location, localSymbol); 1377Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnLocal2 : ErrorCode.ERR_RefReturnLocal2, local.Syntax, localSymbol); 1388Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnNonreturnableLocal2 : ErrorCode.ERR_RefReturnNonreturnableLocal2, local.Syntax, localSymbol); 1461diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, parameter.Syntax.Location, parameterSymbol.Name); 1587(checkingReceiver: true, isRefScoped: true, inUnsafeRegion: false, _) => (ErrorCode.ERR_RefReturnScopedParameter2, parameter.Syntax), 1588(checkingReceiver: true, isRefScoped: true, inUnsafeRegion: true, _) => (ErrorCode.WRN_RefReturnScopedParameter2, parameter.Syntax), 1589(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: false, { IsReturnOnly: true }) => (ErrorCode.ERR_RefReturnOnlyParameter2, parameter.Syntax), 1590(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: true, { IsReturnOnly: true }) => (ErrorCode.WRN_RefReturnOnlyParameter2, parameter.Syntax), 1591(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: false, _) => (ErrorCode.ERR_RefReturnParameter2, parameter.Syntax), 1592(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: true, _) => (ErrorCode.WRN_RefReturnParameter2, parameter.Syntax), 2004Error(diagnostics, ErrorCode.ERR_ReturnNotLValue, expr.Syntax, propertySymbol); 2524CheckRefEscape(argument.Syntax, argument, escapeTo, false, diagnostics) : 2525CheckValEscape(argument.Syntax, argument, escapeTo, false, diagnostics); 2550return CheckValEscape(receiver.Syntax, receiver, escapeTo, false, diagnostics); 2589CheckRefEscape(argument.Syntax, argument, escapeTo, false, diagnostics) : 2590CheckValEscape(argument.Syntax, argument, escapeTo, false, diagnostics); 2626? CheckRefEscape(argument.Syntax, argument, escapeTo, checkingReceiver: false, diagnostics) 2627: CheckValEscape(argument.Syntax, argument, escapeTo, checkingReceiver: false, diagnostics); 2669receiver = new BoundCapturedReceiverPlaceholder(receiver.Syntax, receiver, receiver.Type).MakeCompilerGenerated(); 3239if (!hasMixingError && !CheckValEscape(argument.Syntax, argument, escapeTo, false, diagnostics)) 3293? CheckRefEscape(fromArg.Syntax, fromArg, toArgEscape, checkingReceiver: false, diagnostics) 3294: CheckValEscape(fromArg.Syntax, fromArg, toArgEscape, checkingReceiver: false, diagnostics); 3688CheckRefEscape(expr.Syntax, expr, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3692CheckValEscape(expr.Syntax, expr, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4069return CheckRefEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 4070CheckRefEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4106call.Syntax, 4125indexerAccess.Syntax, 4149indexerAccess.Syntax, 4173call.Syntax, 4202elementAccess.Syntax, 4220functionPointerInvocation.Syntax, 4238propertyAccess.Syntax, 5056Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, node, expr.Syntax); 5073return CheckValEscape(underlyingReceiver.Syntax, underlyingReceiver, escapeTo, checkingReceiver, diagnostics); 5088CheckValEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 5089CheckValEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5096var consValid = CheckValEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5105return CheckValEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5110return CheckValEscape(coalescingOp.LeftOperand.Syntax, coalescingOp.LeftOperand, escapeTo, checkingReceiver, diagnostics) && 5111CheckValEscape(coalescingOp.RightOperand.Syntax, coalescingOp.RightOperand, escapeTo, checkingReceiver, diagnostics); 5137call.Syntax, 5150ptrInvocation.Syntax, 5163indexerAccess.Syntax, 5182indexerAccess.Syntax, 5202call.Syntax, 5222elementAccess.Syntax, 5235propertyAccess.Syntax, 5248objectCreation.Syntax, 5260initializerExpr.Syntax, 5280initializerExpr.Syntax, 5296escape = escape && CheckValEscape(initializerExpr.Syntax, initializerExpr, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5306unary.Syntax, 5346conversion.Syntax, 5360conversion.Syntax, 5394increment.Syntax, 5413compound.Syntax, 5422return CheckValEscape(compound.Left.Syntax, compound.Left, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5426return CheckValEscape(compound.Left.Syntax, compound.Left, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 5427CheckValEscape(compound.Right.Syntax, compound.Right, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5440binary.Syntax, 5448return CheckValEscape(binary.Left.Syntax, binary.Left, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 5449CheckValEscape(binary.Right.Syntax, binary.Right, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5454if (range.LeftOperandOpt is { } left && !CheckValEscape(left.Syntax, left, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 5459return !(range.RightOperandOpt is { } right && !CheckValEscape(right.Syntax, right, escapeTo, checkingReceiver: false, diagnostics: diagnostics)); 5465uo.Syntax, 5474return CheckValEscape(clauseValue.Syntax, clauseValue, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5478return CheckValEscape(variableValue.Syntax, variableValue, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5490return CheckValEscape(accessedExpression.Syntax, accessedExpression, escapeTo, checkingReceiver, diagnostics); 5494return CheckValEscape(operandExpression.Syntax, operandExpression, escapeTo, checkingReceiver, diagnostics); 5509if (!CheckValEscape(result.Syntax, result, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 5755if (!CheckValEscape(element.Syntax, element, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 5773colElement.Syntax, 5782else if (!CheckValEscape(expr.Syntax, expr, escapeTo, checkingReceiver: false, diagnostics)) 5797Error(diagnostics, _inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, initExpr.Syntax, expr.Syntax); 5823bool result = CheckValEscape(expression.Syntax, data.Construction, escapeTo, checkingReceiver: false, diagnostics); 5909call.Syntax,

290Debug.Assert(boundAttribute.Syntax.Kind() == SyntaxKind.Attribute); 298return new SourceAttributeData(Compilation, (AttributeSyntax)boundAttribute.Syntax, attributeType, attributeConstructor, hasErrors); 302ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)boundAttribute.Syntax).Name, diagnostics, ref hasErrors); 323(AttributeSyntax)boundAttribute.Syntax, 333diagnostics.Add(boundAttribute.Syntax, useSiteInfo); 337(AttributeSyntax)boundAttribute.Syntax, 893Binder.Error(diagnostics, ErrorCode.ERR_BadAttributeArgument, node.Syntax); 964Binder.Error(diagnostics, ErrorCode.ERR_AttrArgWithTypeVars, node.Syntax, typeOfArgument.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)); 1048Binder.Error(diagnostics, ErrorCode.ERR_BadAttributeArgument, node.Syntax);

32var placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type); 124var syntax = expression.Syntax; 321&& (!isRuntimeAsyncEnabled || getRuntimeAwaitAwaiter(awaiterType, out runtimeAsyncAwaitCall, out runtimeAsyncAwaitCallPlaceholder, expression.Syntax, diagnostics)); 350var asyncHelpersType = GetSpecialType(InternalSpecialType.System_Runtime_CompilerServices_AsyncHelpers, diagnostics, expression.Syntax); 372placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type); 382expression.Syntax, 406reportObsoleteDiagnostics(this, diagnostics, runtimeAwaitCall.Method, expression.Syntax);

28diagnostics.Add(source.Syntax, useSiteInfo); 29return CreateConversion(source.Syntax, source, conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, destination: destination, diagnostics: diagnostics); 38return CreateConversion(source.Syntax, source, conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, destination: destination, diagnostics: diagnostics); 79var placeholder2 = new BoundValuePlaceholder(source.Syntax, source.Type); 280source = new BoundDefaultExpression(source.Syntax, targetType: null, constantValue, type: destination) 292diagnostics.Add(ErrorCode.WRN_ConvertingLock, source.Syntax); 342new BoundValuePlaceholder(source.Syntax, source.Type.GetNullableUnderlyingType()), 373new BoundValuePlaceholder(source.Syntax, source.Type.GetNullableUnderlyingType()), 402new BoundValuePlaceholder(source.Syntax, sourceTypes[i].Type), 732var stringFactory = GetWellKnownType(WellKnownType.System_Runtime_CompilerServices_FormattableStringFactory, diagnostics, unconvertedSource.Syntax); 737unconvertedSource.Syntax, 765BoundExpression expr = bindObjectCreationExpression(node.Syntax, node.InitializerOpt, node.Binder, destination.StrippedType(), arguments, diagnostics); 773Debug.Assert(expr is not BoundBadExpression { ChildBoundNodes: var children } || !children.Any((child, node) => child.Syntax == node.Syntax, node)); 837_ = GetSpecialTypeMember(SpecialMember.System_Nullable_T__ctor, diagnostics, syntax: node.Syntax); 848var syntax = node.Syntax; 934(SpreadElementSyntax)spreadElement.Syntax, 940element.Syntax, 980element.Syntax, 1013var expressionSyntax = element.Expression.Syntax; 1738var syntax = node.Syntax; 1774if (!TryGetCollectionIterationType(node.Syntax, targetType, out elementTypeWithAnnotations)) 1781node.Syntax, 1799if (!HasCollectionExpressionApplicableConstructor(node.Syntax, targetType, constructor: out _, isExpanded: out _, diagnostics)) 1805!HasCollectionExpressionApplicableAddMethod(node.Syntax, targetType, addMethods: out _, diagnostics)) 1819Error(diagnostics, ErrorCode.ERR_NoImplicitConv, spreadElement.Expression.Syntax, spreadElement.Expression.Display, elementType); 1827GenerateImplicitConversionError(diagnostics, this.Compilation, spreadElement.Expression.Syntax, elementConversion, enumeratorInfo.ElementType, elementType); 1837GenerateImplicitConversionError(diagnostics, element.Syntax, elementConversion, (BoundExpression)element, elementType); 1847Error(diagnostics, ErrorCode.ERR_CollectionExpressionTargetTypeNotConstructible, node.Syntax, targetType); 1960? CreateConversion(source.Consequence.Syntax, source.Consequence, underlyingConversions[0], isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, destination, diagnostics) 1964? CreateConversion(source.Alternative.Syntax, source.Alternative, underlyingConversions[1], isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, destination, diagnostics) 1973source.Syntax.Location, 1980return new BoundConditionalOperator(source.Syntax, isRef: false, condition, trueExpr, falseExpr, constantValue, source.Type, wasTargetTyped: targetTyped, destination, hasErrors) 2000? CreateConversion(oldValue.Syntax, oldValue, underlyingConversions[i], isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, destination, diagnostics) 2003new BoundSwitchExpressionArm(oldCase.Syntax, oldCase.Locals, oldCase.Pattern, oldCase.WhenClause, newValue, oldCase.Label, oldCase.HasErrors); 2010source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.ReachabilityDecisionDag, 2079syntax: source.Syntax, 2528var tupleSyntax = (TupleExpressionSyntax)sourceTuple.Syntax; 2557convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, InConversionGroupFlags.Unspecified, destType.Type, diagnostics)); 2561sourceTuple.Syntax, 2574sourceTuple.Syntax, 3158return this.MethodGroupConversionHasErrors(boundMethodGroup.Syntax, conversion, boundMethodGroup.ReceiverOpt, conversion.IsExtensionMethod, isAddressOf: false, delegateType, diagnostics);

132new BoundConversion(boundRHS.Syntax, boundRHS, Conversion.Deconstruction, @checked: false, explicitCastInCode: false, 145boundRHS.Syntax, 162boundRHS.Syntax, 229Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, boundRHS.Syntax); 326diagnostics.Add(single.Syntax, useSiteInfo); 331GenerateImplicitConversionError(diagnostics, Compilation, single.Syntax, nestedConversion, tupleOrDeconstructedTypes[i], single.Type); 410variables[i] = new DeconstructionVariable(errorLocal, errorLocal.Syntax); 416Error(diagnostics, ErrorCode.ERR_TypeInferenceFailedForImplicitlyTypedDeconstructionVariable, pending.Syntax, "_"); 417variables[i] = new DeconstructionVariable(pending.FailInference(this, diagnostics), pending.Syntax); 498Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, element.Syntax); 516Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, element.Syntax); 521locationsBuilder.Add(element.Syntax.Location); 604return InferTupleElementName(expression.Syntax); 623var receiverSyntax = (CSharpSyntaxNode)receiver.Syntax;

241expr.Syntax, 322var exprSyntax = (SwitchExpressionSyntax)expr.Syntax; 360diagnostics.Add(op.NoCommonTypeError, op.Syntax.Location, trueArg, falseArg); 375sourceTuple.Syntax, 390diagnostics.Add(ErrorCode.ERR_DefaultLiteralNoTargetType, defaultExpr.Syntax.GetLocation()); 394defaultExpr.Syntax, 413diagnostics.Add(ErrorCode.ERR_ImplicitObjectCreationNoTargetType, expr.Syntax.GetLocation(), expr.Display); 433diagnostics.Add(ErrorCode.ERR_CollectionExpressionNoTargetType, expr.Syntax.GetLocation()); 450var syntax = expr.Syntax; 2849GenerateAnonymousFunctionConversionError(diagnostics, operand.Syntax, (UnboundLambda)operand, targetType); 2939GenerateImplicitConversionError(diagnostics, operand.Syntax, conversion, operand, targetType); 2986GenerateExplicitConversionErrors(diagnostics, argument.Syntax, elementConversion, argument, targetElementType); 3582coercedArgument = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, parameterTypeWithAnnotations.Type, diagnostics); 3603coercedArgument = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, parameterTypeWithAnnotations.Type, diagnostics); 3727ReportUnsafeIfNotAllowed(argument.Syntax, diagnostics); 3763unconvertedString.Syntax, 3778diagnostics.Add(ErrorCode.ERR_InterpolatedStringHandlerArgumentAttributeMalformed, unconvertedString.Syntax.Location, correspondingParameter, handlerType); 3780unconvertedString.Syntax, 3796unconvertedString.Syntax, 3888unconvertedString.Syntax.Location, 3907arguments[argumentIndex].Syntax.Location, 3928placeholderSyntax = receiver.Syntax; 3931placeholderSyntax = unconvertedString.Syntax; 3935placeholderSyntax = arguments[argumentIndex].Syntax; 3963interpolatedString.Syntax, 3990var available = CheckFeatureAvailability(argument.Syntax, MessageID.IDS_FeatureRefReadonlyParameters, diagnostics); 4008argument.Syntax, 4014if (!this.CheckValueKind(argument.Syntax, argument, BindValueKind.RefersToLocation, checkingReceiver: false, BindingDiagnosticBag.Discarded)) 4020argument.Syntax, 4026if (this.CheckValueKind(argument.Syntax, argument, BindValueKind.Assignable, checkingReceiver: false, BindingDiagnosticBag.Discarded)) 4031argument.Syntax, 4039argument.Syntax, 4534Error(diagnostics, ErrorCode.ERR_ConstantExpected, size.Syntax); 4771Error(diagnostics, ErrorCode.ERR_ConstantExpected, sizeOpt.Syntax); 5241return (parameter, boundParameter.Syntax); 5277Debug.Assert(result is not BoundBadExpression { ChildBoundNodes: var children } || !children.Any((child, node) => child.Syntax == node, node)); 5405lengthOrCount = new BoundLiteral(expression.Syntax, ConstantValue.Create(length), @this.GetSpecialType(SpecialType.System_Int32, diagnostics, expression.Syntax)) { WasCompilerGenerated = true }; 5452var argSyntax = analyzedArguments.Arguments[0].Syntax; 5454var end = analyzedArguments.Arguments[analyzedArguments.Arguments.Count - 1].Syntax.Span.End; 5495GenerateImplicitConversionError(diagnostics, unboundLambda.Syntax, conversion, unboundLambda, type); 5508CheckParameterModifierMismatchMethodConversion(unboundLambda.Syntax, boundLambda.Symbol, type, invokedAsExtensionMethod: false, diagnostics); 5535diagnostics.Add(ErrorCode.ERR_MethodNameExpected, argument.Syntax.Location); 5559Conversion conv = Conversions.MethodGroupConversion(argument.Syntax, methodGroup, type, ref useSiteInfo); 5564argument.Syntax, default, WellKnownMemberNames.DelegateInvokeName, ImmutableArray.Create(sourceDelegate.DelegateInvokeMethod), 5580if (!this.MethodGroupConversionHasErrors(argument.Syntax, conv, argument, conv.IsExtensionMethod, isAddressOf: false, type, diagnostics)) 5596diagnostics.Add(ErrorCode.ERR_MethodNameExpected, argument.Syntax.Location); 5672var result = MakeBadExpressionForObjectCreation(node.Syntax, CreateErrorType(), arguments, node.InitializerOpt, typeSyntax: node.Syntax, diagnostics); 5843typeSyntax: boundLeft.Syntax, 6064diagnostics.Add(ErrorCode.ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers, argument.Syntax.Location); 6075MessageID.IDS_FeatureImplicitIndexerInitializer.CheckFeatureAvailability(diagnostics, implicitIndexer.Syntax); 6110if (!CheckValueKind(boundMember.Syntax, boundMember, valueKind, checkingReceiver: false, diagnostics: diagnostics)) 6208var memberInitializerSyntax = boundMemberInitializer.Syntax; 6297diagnostics.Add(ErrorCode.ERR_RequiredMembersMustBeAssignedValue, initializerExpression.Syntax.Location, requiredMember); 6450var boundElementInitializer = BindInitializerExpressionOrValue(elementInitializer, initializerType, BindValueKind.RValue, implicitReceiver.Syntax, diagnostics); 6936CheckRequiredMembersInObjectInitializer(creation.Constructor, creation.InitializerExpressionOpt?.Initializers ?? default, creation.Syntax, diagnostics); 8020CheckFeatureAvailability(boundLeft.Syntax, MessageID.IDS_FeatureStaticAbstractMembersInInterfaces, diagnostics); 8025Error(diagnostics, ErrorCode.ERR_LookupInTypeVariable, boundLeft.Syntax, leftType); 8088diagnostics.Add(expr.Syntax, useSiteInfo); 8986propertyResult.ReportDiagnostics(binder, expression.Location, expression, diagnostics, memberName, left, left.Syntax, actualReceiverArguments, symbols, 9650if (expr.Syntax.Parent is ConditionalAccessExpressionSyntax conditional && 9651conditional.Expression == expr.Syntax) 9653location = expr.Syntax.SyntaxTree.GetLocation(TextSpan.FromBounds(expr.Syntax.SpanStart, conditional.OperatorToken.Span.End)); 9657location = expr.Syntax.GetLocation(); 9672checkInlineArrayBounds(convertedIndex.Syntax, constIndex, length, excludeEnd: true, diagnostics); 9753location = hatExpression.Syntax; 9759location = operand.Syntax; 9767location = index.Syntax; 9873Error(diagnostics, ErrorCode.WRN_NegativeArrayIndex, index.Syntax); 9887var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(expr.Syntax, isEquivalentToThisReference: expr.IsEquivalentToThisReference, expr.Type) { WasCompilerGenerated = true }; 9888var argumentPlaceholders = ImmutableArray.Create(new BoundImplicitIndexerValuePlaceholder(convertedArguments[0].Syntax, int32) { WasCompilerGenerated = true }); 9919var node = index.Syntax; 10027BoundExpression result = CreateConversion(expr.Syntax, expr, conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, destination: targetType, diagnostics); // UNDONE: was cast? 10068Error(diagnostics, ErrorCode.ERR_VoidError, expr.Syntax); 10086Error(diagnostics, ErrorCode.ERR_BadArgExtraRef, analyzedArguments.Argument(i).Syntax, i + 1, refKind.ToArgumentDisplayString()); 10166var syntax = propertyGroup.Syntax; 10432var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(receiver.Syntax, isEquivalentToThisReference: receiver.IsEquivalentToThisReference, receiver.Type) { WasCompilerGenerated = true }; 10770node, node.Syntax, node.Name, analyzedArguments, ref useSiteInfo, 10973return GetMethodGroupOrLambdaDelegateType(node.Syntax, method, hasParams: useParams); 11506if (access.Syntax is AssignmentExpressionSyntax assignment) 11612diagnostics.Add(new CSDiagnostic(diagnosticInfo, access.Syntax.Location)); 11613receiver = BadExpression(receiver.Syntax, receiver); 11655if (receiver?.Syntax != GetConditionalReceiverSyntax(conditionalAccessNode)) 11670receiver = new BoundConditionalReceiver(receiver.Syntax, 0, receiverType ?? CreateErrorType(), hasErrors: receiver.HasErrors) { WasCompilerGenerated = true };

263statement = new BoundExpressionStatement(statement.Syntax, expression, expression.HasErrors); 278Error(diagnostics, ErrorCode.ERR_SemicolonExpected, ((ExpressionStatementSyntax)labeledStatementBody.Syntax).SemicolonToken);

112diagnostics.Add(ErrorCode.WRN_AlignmentMagnitude, alignment.Syntax.Location, alignmentConstant.Int32Value, magnitudeLimit); 268unconvertedInterpolatedString.Syntax, 339SyntaxNode syntax = unconvertedSource.Syntax; 495binaryOperator.Syntax, 504convertedBinaryOperator = UpdateBinaryOperatorWithInterpolatedContents(binaryOperator, appendCalls, data, binaryOperator.Syntax, diagnostics); 532expression.Syntax, 542original.Syntax, 583unconvertedInterpolatedString.Syntax, 593unconvertedInterpolatedString.Syntax, 620binaryOperator.Syntax, 628var result = UpdateBinaryOperatorWithInterpolatedContents(binaryOperator, appendCalls, data, binaryOperator.Syntax, diagnostics); 689CheckFeatureAvailability(value.Syntax, MessageID.IDS_FeatureImprovedInterpolatedStrings, diagnostics); 699CheckFeatureAvailability(value.Syntax, MessageID.IDS_FeatureImprovedInterpolatedStrings, diagnostics); 853var objectType = GetSpecialType(SpecialType.System_Object, diagnostics, unconvertedInterpolatedString.Syntax); 939parameterNamesAndLocationsBuilder.Add(("alignment", insert.Alignment.Syntax.Location)); 945parameterNamesAndLocationsBuilder.Add(("format", insert.Format.Syntax.Location)); 975var call = MakeInvocationExpression(part.Syntax, implicitBuilderReceiver, methodName, arguments, diagnostics, names: parameterNamesAndLocations, searchExtensionsIfNecessary: false); 989diagnostics.Add(ErrorCode.ERR_InterpolatedStringHandlerMethodReturnMalformed, part.Syntax.Location, method); 999diagnostics.Add(ErrorCode.ERR_InterpolatedStringHandlerMethodReturnInconsistent, part.Syntax.Location, method, expected);

298Error(diagnostics, ErrorCode.ERR_CantUseVoidInArglist, argument.Syntax); 313Error(diagnostics, ErrorCode.ERR_CantUseInOrOutInArglist, argument.Syntax); 526Error(diagnostics, ErrorCode.ERR_NamedArgumentSpecificationBeforeFixedArgumentInDynamicInvocation, arguments.Arguments[i].Syntax); 566Error(diagnostics, ErrorCode.ERR_CannotDynamicInvokeOnExpression, receiver.Syntax, receiver.Type); 576Error(diagnostics, ErrorCode.ERR_InDynamicMethodArg, arguments[argIndex].Syntax); 597Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArgLambda, arg.Syntax); 603Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArgMemgrp, arg.Syntax); 611Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, "__arglist"); 620Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, arg.Type); 772methodGroup.Syntax, 910argumentSyntax = arg.Syntax; 1093Error(diagnostics, ErrorCode.ERR_NoImplicitConv, call.ReceiverOpt.Syntax, distinguisher.First, distinguisher.Second); 1099Error(diagnostics, ErrorCode.ERR_NoImplicitConv, call.ReceiverOpt.Syntax, distinguisher.First, distinguisher.Second); 1113Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, dynInvoke.Expression.Syntax, dynInvoke.Expression.Type); 1285CheckFeatureAvailability(receiverArgument.Syntax, MessageID.IDS_FeatureRefExtensionMethods, diagnostics); 1291CheckFeatureAvailability(receiverArgument.Syntax, MessageID.IDS_FeatureRefExtensionMethods, diagnostics); 1408var result = !CheckValueKind(receiver.Syntax, receiver, valueKind, checkingReceiver: true, BindingDiagnosticBag.Discarded); 1713defaultValue = new BoundLiteral(syntax, ConstantValue.Create(argument.Syntax.ToString()), Compilation.GetSpecialType(SpecialType.System_String)) { WasCompilerGenerated = true }; 1764defaultValue.Syntax, 1912Error(diagnostics, ErrorCode.WRN_ImplicitCopyInReadOnlyMember, receiver.Syntax, method, ThisParameterSymbol.SymbolName); 1958var identifier = (IdentifierNameSyntax)typeOrValue.Syntax; 2405diagnostics.Add(ErrorCode.ERR_NameofExtensionMember, boundArgument.Syntax); 2436diagnostics.Add(methodGroup.Syntax, useSiteInfo); 2440diagnostics.Add(ErrorCode.ERR_NameofExtensionMethod, methodGroup.Syntax.Location); 2552boundExpression.Syntax,

75var placeholder = new BoundValuePlaceholder(right.Syntax, left.HasDynamicType() ? left.Type : right.Type).MakeCompilerGenerated(); 318var leftPlaceholder = new BoundValuePlaceholder(left.Syntax, leftType).MakeCompilerGenerated(); 508leftPlaceholder = new BoundValuePlaceholder(left.Syntax, leftType).MakeCompilerGenerated(); 1280left = BindSimpleBinaryOperator((BinaryExpressionSyntax)current.Syntax, diagnostics, left ?? current.Left, right, leaveUnconvertedIfInterpolatedString: false); 1321GenerateImplicitConversionError(diagnostics, right.Syntax, conversion, right, left.Type); 1546var operandPlaceholder = new BoundValuePlaceholder(resultLeft.Syntax, resultLeft.Type).MakeCompilerGenerated(); 1549resultLeft.Syntax, 1621CreateConversion(left.Syntax, new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated(), implicitConversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, booleanType, diagnostics); 1628diagnostics.Add(left.Syntax, useSiteInfo); 1634diagnostics.Add(left.Syntax, useSiteInfo); 1651var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, namedType).MakeCompilerGenerated(); 1652UnaryOperatorAnalysisResult result = operatorOverloadResolution(left.Syntax, operandPlaceholder, isNegative ? UnaryOperatorKind.False : UnaryOperatorKind.True, diagnostics); 1660CreateConversion(left.Syntax, operandPlaceholder, result.Conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, parameterType, diagnostics); 2829Error(diagnostics, ErrorCode.ERR_ConstantStringTooLong, right.Syntax); 3410var operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operandType).MakeCompilerGenerated(); 3596operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operandType).MakeCompilerGenerated(); 4047Error(diagnostics, ErrorCode.ERR_IllegalSuppression, expr.Syntax); 4053Error(diagnostics, ErrorCode.ERR_DuplicateNullSuppression, expr.Syntax); 4198bool receiverIsLValue = CheckValueKind(receiver.Syntax, receiver, BindValueKind.AddressOf, checkingReceiver: false, diagnostics: BindingDiagnosticBag.Discarded); 4317Error(diagnostics, ErrorCode.ERR_IllegalSuppression, expr.Syntax); 4392var resultOperand = CreateConversion(operand.Syntax, operand, best.Conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, signature.OperandType, diagnostics); 4688if (node.Operand != operand.Syntax || operand.Syntax.Kind() != SyntaxKind.NumericLiteralExpression) 4693var literal = (LiteralExpressionSyntax)operand.Syntax; 5387operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 5397operand = new BoundDefaultExpression(operand.Syntax, targetType: null, constantValueOpt: ConstantValue.Null, 5434operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 5652var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 5674var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType0).MakeCompilerGenerated(); 5693var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 5743var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType0).MakeCompilerGenerated(); 5757var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 5953diagnostics.Add(ErrorCode.ERR_RefConditionalDifferentTypes, falseExpr.Syntax.Location, trueType); 5987CheckValEscape(falseExpr.Syntax, falseExpr, whenTrueEscape, checkingReceiver: false, diagnostics: diagnostics); 5989CheckValEscape(trueExpr.Syntax, trueExpr, whenFalseEscape, checkingReceiver: false, diagnostics: diagnostics);

35expression = BadExpression(expression.Syntax, expression); 60this.Compilation, pattern.Syntax, expression, innerPattern, whenTrueLabel: whenTrueLabel, whenFalseLabel: whenFalseLabel, diagnostics); 133DecisionDagBuilder.CheckRedundantPatternsForIsPattern(this.Compilation, pattern.Syntax, expression, pattern, diagnostics); 625diagnostics.Add(ErrorCode.ERR_ValueCantBeNull, expression.Syntax.Location, inputType); 635diagnostics.Add(ErrorCode.ERR_PatternWrongType, expression.Syntax.Location, inputType, expression.Display); 647expression.Syntax.Location, inputType, expression.Display, new CSharpRequiredLanguageVersion(requiredVersion)); 685diagnostics.Add(ErrorCode.ERR_PatternSpanCharCannotBeStringNull, convertedExpression.Syntax.Location, inputType);

741yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), CreateErrorType()); 747yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), yExpression.Type); 808field2Value = new BoundBadExpression(field2Value.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(field2Value), field2Value.Type, true); 823new AnonymousTypeField(fieldName, fieldValue.Syntax.Location, TypeWithAnnotations.Create(TypeOrError(fieldValue)), RefKind.None, ScopedKind.None); 956diagnostics.Add(ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax.Location, ((BoundNamespaceExpression)ultimateReceiver).NamespaceSymbol, MessageID.IDS_SK_NAMESPACE.Localize()); 964receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType()); 971Error(diagnostics, ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax, ultimateReceiver.Type, MessageID.IDS_SK_TYVAR.Localize()); 986receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType());

156Debug.Assert(result.Syntax is StatementSyntax, "BoundStatement should be associated with a statement syntax."); 158Debug.Assert(System.Linq.Enumerable.Contains(result.Syntax.AncestorsAndSelf(), node), @"Bound statement (or one of its parents) 684Error(diagnostics, ErrorCode.WRN_UnobservedAwaitableExpression, expression.Syntax); 1238SyntaxNode initializerSyntax = initializerOpt.Syntax; 1305CheckFeatureAvailability(initializerOpt.Syntax, MessageID.IDS_FeatureExtensibleFixedStatement, diagnostics); 1334var result = PerformPatternMethodLookup(initializer, methodName, initializer.Syntax, additionalDiagnostics, out var patternMethodSymbol, out bool isExpanded); 1347additionalDiagnostics.Add(ErrorCode.WRN_PatternBadSignature, initializer.Syntax.Location, initializer.Type, "fixed", patternMethodSymbol); 1368SyntaxNode initializerSyntax = initializer.Syntax; 1473diagnostics.Add(ErrorCode.ERR_VoidAssignment, op1.Syntax.Location); 1582Error(diagnostics, errorCode, node, getName(op1), op2.Syntax); 1604Error(diagnostics, errorCode, node, getName(op1), op2.Syntax); 1719var syntax = expr.Syntax; 1768SyntaxNode syntax = expr.Syntax; 1989diagnostics.Add(expression.Syntax, useSiteInfo); 1995Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, expression.Syntax, targetType); 2018expression.Syntax, 2024GenerateImplicitConversionError(diagnostics, expression.Syntax, conversion, expression, targetType); 2032return CreateConversion(expression.Syntax, expression, conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, targetType, diagnostics); 2454Error(diagnostics, ErrorCode.ERR_InvalidAddrOp, ((BoundAddressOfOperator)operand).Operand.Syntax); 2473GenerateImplicitConversionError(diagnostics, expr.Syntax, conversion, expr, targetType); 2573GenerateImplicitConversionError(diagnostics, argument.Syntax, elementConversion, argument, targetElementType); 2719diagnostics.Add(expr.Syntax, useSiteInfo); 2734Error(diagnostics, ErrorCode.WRN_IncorrectBooleanAssg, assignment.Syntax); 2740syntax: expr.Syntax, 3215Error(diagnostics, ErrorCode.ERR_RefReturnMustHaveIdentityConversion, argument.Syntax, returnType); 3232Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType, argument.Type); 3236GenerateImplicitConversionError(diagnostics, argument.Syntax, conversion, argument, returnType); 3239ReportCantConvertLambdaReturn(argument.Syntax, diagnostics); 3246return CreateConversion(argument.Syntax, argument, conversion, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, returnType, diagnostics); 3501var syntax = expressionSyntax ?? expression.Syntax;

1502diagnostics.Add(receiver.Syntax, useSiteInfo); 1509Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, receiver.Syntax, parameter.Name, parameter.Type, parameter); 1519receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Ambiguous, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(receiver), receiver.Type, hasErrors: true).MakeCompilerGenerated(); 1529receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, childBoundNodes: [AdjustBadExpressionChild(receiver)], receiver.Type, hasErrors: true).MakeCompilerGenerated();

65tuple.Syntax, tuple, wasTargetTyped: false, builder.ToImmutableAndFree(), tuple.ArgumentNamesOpt, tuple.InferredNamesOpt, tuple.Type, tuple.HasErrors); 325Location location = ((BoundTupleExpression)(useRight ? right : left)).Arguments[i].Syntax.Parent.Location; 340return new BoundDefaultExpression(expr.Syntax, targetType); 392.SelectAsArray((t, s) => (BoundExpression)new BoundTupleOperandPlaceholder(s, t.Type), expr.Syntax); 414ImmutableArray<Location> elementLocations = elements.SelectAsArray(e => e.Syntax.Location);

136builder.Add(MakeTestsForPattern(index: 1, pattern.Syntax, rootIdentifier, pattern, whenClause: null, whenTrueLabel)); 153if (label.Syntax.Kind() != SyntaxKind.DefaultSwitchLabel) 155builder.Add(MakeTestsForPattern(++i, label.Syntax, rootIdentifier, label.Pattern, label.WhenClause, label.Label)); 175builder.Add(MakeTestsForPattern(++i, arm.Syntax, rootIdentifier, arm.Pattern, arm.WhenClause, arm.Label)); 370var syntax = pattern.Syntax; 448input = MakeConvertToType(input, declaration.Syntax, type!, isExplicitTest: false, tests); 472output = MakeConvertToType(input: input, syntax: typePattern.Syntax, type: type, isExplicitTest: typePattern.IsExplicitNotNullTest, tests: tests); 536return new Tests.One(new BoundDagExplicitNullTest(constant.Syntax, input)); 541return new Tests.One(new BoundDagValueTest(constant.Syntax, constant.ConstantValue, input)); 547output = input = constant.Value.Type is { } type ? MakeConvertToType(input, constant.Syntax, type, isExplicitTest: false, tests) : input; 556tests.Add(new Tests.One(new BoundDagValueTest(constant.Syntax, constant.ConstantValue, input))); 571output = input = MakeConvertToType(input, recursive.Syntax, inputType, isExplicitTest: recursive.IsExplicitNotNullTest, tests); 579var evaluation = new BoundDagDeconstructEvaluation(recursive.Syntax, method, OriginalInput(input, method)); 586SyntaxNode syntax = pattern.Syntax; 607SyntaxNode syntax = pattern.Syntax; 620tests.Add(new Tests.One(new BoundDagTypeTest(recursive.Syntax, ErrorType(), input, hasErrors: true))); 634tests.Add(new Tests.One(new BoundDagTypeTest(recursive.Syntax, ErrorType(), input, hasErrors: true))); 660input = MakeConvertToType(input, member.Syntax, member.Receiver.Type.StrippedType(), isExplicitTest: false, tests); 667evaluation = new BoundDagPropertyEvaluation(member.Syntax, property, isLengthOrCount, OriginalInput(input, property)); 670evaluation = new BoundDagFieldEvaluation(member.Syntax, field, OriginalInput(input, field)); 677input = new BoundDagTemp(member.Syntax, member.Type, evaluation); 734var evaluation = new BoundDagTypeEvaluation(bin.Syntax, bin.NarrowedType, input); 735output = new BoundDagTemp(bin.Syntax, bin.NarrowedType, evaluation); 760output = MakeConvertToType(input, rel.Syntax, type, isExplicitTest: false, tests); 769tests.Add(new Tests.One(new BoundDagRelationalTest(rel.Syntax, rel.Relation, rel.ConstantValue, output, rel.HasErrors))); 804var boundDecisionDag = new BoundDecisionDag(rootDecisionDagNode.Syntax, rootDecisionDagNode); 1006state.SelectedTest = new BoundDagNonNullTest(t.Syntax, isExplicitTest: true, t.Input, t.HasErrors); 1096state.Dag = uniqifyDagNode(new BoundEvaluationDecisionDagNode(e.Syntax, e, next)); 1105state.Dag = uniqifyDagNode(new BoundTestDecisionDagNode(d.Syntax, d, whenTrue, whenFalse)); 1770builder.Append($" WHEN[{cd.WhenClause.Syntax}]"); 2190SyntaxNode syntax = test.Syntax; 2262if (e.Syntax.IsKind(SyntaxKind.ListPattern)) 2285new One(new BoundDagValueTest(t.Syntax, safeAdd(t.Value, offset), lengthTemp)); 2289new One(new BoundDagRelationalTest(t.Syntax, t.OperatorKind, safeAdd(t.Value, offset), lengthTemp));

129existingCases.Add(builder.MakeTestsForPattern(++index, switchArm.Syntax, rootIdentifier, switchArm.Pattern, whenClause: switchArm.WhenClause, label: switchArm.Label)); 176if (label.Syntax.Kind() != SyntaxKind.DefaultSwitchLabel) 183existingCases.Add(builder.MakeTestsForPattern(++index, label.Syntax, rootIdentifier, label.Pattern, label.WhenClause, label.Label)); 193if (label.Syntax.Kind() != SyntaxKind.DefaultSwitchLabel) 362var negated = new BoundNegatedPattern(pattern.Syntax, negated: pattern, pattern.InputType, narrowedType: pattern.InputType); 379diagnostics.Add(ErrorCode.HDN_RedundantPatternStackGuard, pattern.Syntax); 398SyntaxNode? diagSyntax = pattern.Syntax; 480var wrappedPattern = new BoundBinaryPattern(newPattern.Syntax, disjunction: false, current.Left, newPattern, current.InputType, newPattern.NarrowedType); 860PushBinaryOperation(current.Syntax, endOfLeft, disjunction); 931var result = new BoundNegatedPattern(node.Syntax, node, node.InputType, narrowedType: node.InputType); 986new BoundTypeExpression(recursivePattern.Syntax, aliasOpt: null, recursivePattern.InputType.StrippedType()), 1027BoundPattern typePattern = new BoundTypePattern(pattern.Syntax, 1028new BoundTypeExpression(pattern.Syntax, aliasOpt: null, pattern.InputType), 1031var result = new BoundBinaryPattern(pattern.Syntax, disjunction: false, left: typePattern, right: pattern, inputType, pattern.NarrowedType); 1043var result = new BoundDeclarationPattern(node.Syntax, node.DeclaredType, node.IsVar, node.Variable, node.VariableAccess, node.InputType, node.NarrowedType) 1083initialCheck = new BoundTypePattern(node.Syntax, node.DeclaredType, node.IsExplicitNotNullTest, node.InputType, node.NarrowedType, node.HasErrors); 1088var nullCheck = new BoundConstantPattern(node.Syntax, 1089new BoundLiteral(node.Syntax, constantValueOpt: ConstantValue.Null, type: node.InputType, hasErrors: false), 1091initialCheck = new BoundNegatedPattern(node.Syntax, nullCheck, node.InputType, narrowedType: node.InputType); 1096initialCheck = new BoundRecursivePattern(node.Syntax, declaredType: null, deconstructMethod: null, deconstruction: default, 1106var discards = deconstruction.SelectAsArray(d => d.WithPattern(MakeDiscardPattern(d.Syntax, d.Pattern.InputType))); 1120newPattern.Syntax, declaredType: node.DeclaredType, deconstructMethod: node.DeconstructMethod, 1135VisitPatternAndCombine(node.Syntax, deconstruction[i].Pattern, startOfLeft); 1155newPattern.Syntax, declaredType: node.DeclaredType, deconstructMethod: null, deconstruction: default, 1171VisitPatternAndCombine(node.Syntax, property.Pattern, startOfLeft); 1219var discards = subpatterns.SelectAsArray(d => d.WithPattern(MakeDiscardPattern(d.Syntax, d.Pattern.InputType))); 1225var lengthTest = new BoundITuplePattern(ituplePattern.Syntax, ituplePattern.GetLengthMethod, ituplePattern.GetItemMethod, discards, 1242BoundPattern newITuple = new BoundITuplePattern(newPattern.Syntax, ituplePattern.GetLengthMethod, 1256VisitPatternAndCombine(ituplePattern.Syntax, subpatterns[i].Pattern, startOfLeft); 1306newPattern.Syntax, newSubpatterns, hasSlice, listPattern.LengthAccess, listPattern.IndexerAccess, 1331BoundPattern newSlice = new BoundSlicePattern(newPattern.Syntax, newPattern, slice.IndexerAccess, 1337newPattern.Syntax, newSubpatterns, hasSlice: true, listPattern.LengthAccess, listPattern.IndexerAccess, 1361VisitPatternAndCombine(listPattern.Syntax, slicePattern.Pattern, startOfLeft); 1367VisitPatternAndCombine(listPattern.Syntax, listPattern.Subpatterns[i], startOfLeft); 1388return MakeDiscardPattern(pattern.Syntax, pattern.InputType);

22var syntax = list.Syntax; 25output = input = MakeConvertToType(input, list.Syntax, list.NarrowedType, isExplicitTest: false, tests); 29tests.Add(new Tests.One(new BoundDagTypeTest(list.Syntax, ErrorType(), input, hasErrors: true))); 64var sliceEvaluation = new BoundDagSliceEvaluation(slicePattern.Syntax, slicePattern.InputType, lengthTemp, startIndex: startIndex, endIndex: index, 68var sliceTemp = new BoundDagTemp(slicePattern.Syntax, slicePattern.InputType, sliceEvaluation); 79var indexEvaluation = new BoundDagIndexerEvaluation(subpattern.Syntax, subpattern.InputType, lengthTemp, index++, 83var indexTemp = new BoundDagTemp(subpattern.Syntax, subpattern.InputType, indexEvaluation);

244messageId.CheckFeatureAvailability(diagnostics, Compilation, collectionExpr.Syntax.Location); 248Error(diagnostics, ErrorCode.ERR_RefLvalueExpected, collectionExpr.Syntax); 254Error(diagnostics, ErrorCode.ERR_RefLvalueExpected, collectionExpr.Syntax); 364collectionExpr.Syntax, 371hasErrors |= !CheckValueKind(collectionExpr.Syntax, collectionExpr, requiredCurrentKind, checkingReceiver: false, diagnostics); 486Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, collectionExpr.Syntax, iterationVariableType.Type); 649collectionExpr.Syntax, 665collectionExpr.Syntax, 708inferredType = TypeWithAnnotations.Create(GetSpecialType(SpecialType.System_Char, diagnostics, collectionExpr.Syntax)); 726SyntaxNode exprSyntax = collectionExpr.Syntax; 841if (CheckValueKind(collectionExpr.Syntax, collectionExpr, BindValueKind.RefersToLocation | BindValueKind.Assignable, checkingReceiver: false, BindingDiagnosticBag.Discarded)) 849if (!CheckValueKind(collectionExpr.Syntax, collectionExpr, BindValueKind.RefersToLocation, checkingReceiver: false, BindingDiagnosticBag.Discarded)) 855NamedTypeSymbol spanType = GetWellKnownType(wellKnownSpan, diagnostics, collectionExpr.Syntax); 867diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type); 873BoundExpression span = new BoundValuePlaceholder(collectionExpr.Syntax, spanType).MakeCompilerGenerated(); 895CheckFeatureAvailability(collectionExpr.Syntax, MessageID.IDS_FeatureInlineArrays, diagnostics); 901_ = GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_Unsafe__AsRef_T, diagnostics, syntax: collectionExpr.Syntax); 904_ = GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_Unsafe__Add_T, diagnostics, syntax: collectionExpr.Syntax); 905_ = GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_Unsafe__As_T, diagnostics, syntax: collectionExpr.Syntax); 907CheckInlineArrayTypeIsSupported(collectionExpr.Syntax, collectionExpr.Type, elementField.Type, diagnostics); 915diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type); 945diagnostics.Add(ErrorCode.ERR_NullNotValid, collectionExpr.Syntax.Location); 1134collectionExpr.Syntax, 1239CheckFeatureAvailability(expr.Syntax, MessageID.IDS_FeatureDisposalPattern, diagnostics); 1258Error(diagnostics, ErrorCode.ERR_BadAllowByRefLikeEnumerator, expr.Syntax, enumeratorType); 1560collectionExpr.Syntax, 1574collectionExpr.Syntax, 1586collectionExpr.Syntax,

120increment = new BoundBlock(increment.Syntax, locals, ImmutableArray.Create(increment))

384var typedTemp = new BoundDagTemp(te.Syntax, te.Type, te); 399var typedTemp = new BoundDagTemp(te.Syntax, te.Type, te); 443var lengthTemp = new BoundDagTemp(lengthOrCount.Syntax, lengthOrCount.Property.Type, lengthOrCount); 471var indexerTemp = new BoundDagTemp(e.Syntax, e.IndexerType, e); 490var sliceTemp = new BoundDagTemp(slice.Syntax, slice.SliceType, slice); 519var elementTemp = new BoundDagTemp(e.Syntax, e.Field.Type, e); 587var elementTemp = new BoundDagTemp(e.Syntax, method.Parameters[j + extensionExtra].Type, e, j); 606var subInput = new BoundDagTemp(e.Syntax, e.Field.Type, e); 613var subInput = new BoundDagTemp(e.Syntax, e.Property.Type, e);

346RoslynDebug.Assert(added, $"Expression {expr} `{expr.Syntax}` visited more than once."); 359RoslynDebug.Assert(_visited.Contains(expr), $"Expected {expr} `{expr.Syntax}` to be visited."); 604ValidateAssignment(node.Syntax, node.Left, node.Right, node.IsRef, _diagnostics); 618node.Syntax, 629ValidateAssignment(node.Syntax, node.Left, node, isRef: false, _diagnostics); 737ValidateRefConditionalOperator(node.Syntax, node.Consequence, node.Alternative, _diagnostics); 862node.Syntax, 980node.Syntax, 1024Error(_diagnostics, ErrorCode.ERR_CallArgMixing, argument.Syntax, node.Constructor, parameter.Name); 1050node.Syntax, 1067node.Syntax, 1116VisitDeconstructionArguments(variables, right.Syntax, right.Conversion, right.Operand);

164var syntax = node.Syntax; 241new BoundValuePlaceholder(element.Syntax, enumeratorInfo.ElementType), 257GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateInvokeMethodOpt.Parameters, binder.Compilation); 305diagnostics.Add(expr.Syntax, useSiteInfo); 355expr.Syntax.Location, 366expr.Syntax.Location, 378binder: binder, location: expr.Syntax.Location, nodeOpt: expr.Syntax, diagnostics: overloadDiagnostics, 380receiver: resolution.MethodGroup.Receiver, invokedExpression: expr.Syntax, arguments: resolution.AnalyzedArguments,

1609if (anonymousFunction.Syntax.Kind() == SyntaxKind.AnonymousMethodExpression)

682if (!binder.TryGetCollectionIterationType((ExpressionSyntax)argument.Syntax, targetType.StrippedType(), out TypeWithAnnotations targetElementType)) 907if (!binder.TryGetCollectionIterationType((ExpressionSyntax)argument.Syntax, formalType.Type, out TypeWithAnnotations targetElementType)) 1513Conversions.GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateParameters, binder.Compilation);

1199SourceLocation sourceLocation = new SourceLocation(argument.Syntax);

104if (!label.HasErrors && isSubsumed(label, reachableLabels) && label.Syntax.Kind() != SyntaxKind.DefaultSwitchLabel) 106var syntax = label.Syntax; 134newLabel = new BoundSwitchLabel(label.Syntax, label.Label, label.Pattern, label.WhenClause, hasErrors: true);

80diagnostics.Add(ErrorCode.ERR_SwitchArmSubsumed, arm.Pattern.Syntax.Location);

122CheckRestrictedTypeInAsyncMethod(originalBinder.ContainingMemberOrLambda, expressionOpt.Type, diagnostics, expressionOpt.Syntax);

98? $"({when.Syntax}) " 112? $"leaf {generated.NameNoSequence} `{node.Syntax}`"

23Binder.Error(diagnosticsOpt, ErrorCode.ERR_DiscardTypeInferenceFailed, this.Syntax);

22Debug.Assert(this.WasCompilerGenerated || this.Syntax is InvocationExpressionSyntax or ConstructorInitializerSyntax or PrimaryConstructorBaseTypeSyntax { ArgumentList: { } }, 23$"Unexpected syntax kind for BoundCall: {this.Syntax.Kind()}"); 25if (this.WasCompilerGenerated || this.Syntax is not InvocationExpressionSyntax syntax)

20this.Syntax,

37return this.Syntax as MemberAccessExpressionSyntax; 52return this.Syntax;

106if (this.HasErrors || this.Syntax != null && this.Syntax.HasErrors) 149return Syntax?.SyntaxTree; 428if (Syntax != null) 430result += " " + Syntax.ToString();

29expression => new BoundExpressionStatement(expression.Syntax, expression, expression.HasErrors));

21this.Syntax,

19this.Syntax,

185SyntaxNode syntax = node.Syntax;

14Debug.Assert(Syntax is IdentifierNameSyntax);

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

155=> (Type is null) ? FormattableStringFactory.Create("stackalloc {0}[{1}]", ElementType, Count.WasCompilerGenerated ? null : Count.Syntax.ToString()) : base.Display;

18Placeholder = new BoundDeconstructValuePlaceholder(this.Syntax, variableSymbol: VariableSymbol, isDiscardExpression: IsDiscardExpression, type.Type, hasErrors: this.HasErrors || !success);

33SyntaxNode IBoundLambdaOrFunction.Syntax { get { return Syntax; } } 75public MessageID MessageID { get { return Syntax.Kind() == SyntaxKind.AnonymousMethodExpression ? MessageID.IDS_AnonMethod : MessageID.IDS_Lambda; } } 83SyntaxNode IBoundLambdaOrFunction.Syntax { get { return Syntax; } } 447var lambda = new UnboundLambda(Syntax, data, FunctionType, WithDependencies, nullableState, getterNullResilienceData, HasErrors); 460var lambda = new UnboundLambda(Syntax, data, FunctionType, WithDependencies, _nullableState, _getterNullResilienceData, HasErrors); 613Binder.RecordLambdaBinding(UnboundLambda.Syntax); 632this.Binder.GenerateAnonymousFunctionConversionError(diagnostics, _unboundLambda.Syntax, _unboundLambda, targetType); 759var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder)); 807_unboundLambda.Syntax, 855lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder), inExpressionTree ? BinderFlags.InExpressionTree : BinderFlags.None); 918var result = new BoundLambda(_unboundLambda.Syntax, _unboundLambda, block, diagnostics.ToReadOnlyAndFree(), lambdaBodyBinder, delegateType, inferredReturnType: default) 1022_unboundLambda.Syntax, 1057var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder)); 1280_unboundLambda.Syntax, 1553public override MessageID MessageID { get { return this.UnboundLambda.Syntax.Kind() == SyntaxKind.AnonymousMethodExpression ? MessageID.IDS_AnonMethod : MessageID.IDS_Lambda; } } 1559return UnboundLambda.Syntax.AnonymousFunctionBody(); 1566var syntax = UnboundLambda.Syntax;

37Debug.Assert(this.Syntax.Kind() == SyntaxKind.SingleVariableDesignation || 38(this.Syntax.Kind() == SyntaxKind.DeclarationExpression && 39((DeclarationExpressionSyntax)this.Syntax).Designation.Kind() == SyntaxKind.SingleVariableDesignation)); 61SyntaxNode typeOrDesignationSyntax = this.Syntax.Kind() == SyntaxKind.DeclarationExpression ? 62((DeclarationExpressionSyntax)this.Syntax).Type : 63this.Syntax; 76return new BoundLocal(this.Syntax, localSymbol, BoundLocalDeclarationKind.WithInferredType, constantValueOpt: null, isNullableUnknown: false, type: type.Type, hasErrors: this.HasErrors || inferenceFailed).WithWasConverted(); 100return new BoundFieldAccess(this.Syntax, 122switch (this.Syntax.Kind()) 125designation = (SingleVariableDesignationSyntax)((DeclarationExpressionSyntax)this.Syntax).Designation; 128designation = (SingleVariableDesignationSyntax)this.Syntax;

209result = AllocateTemp(returnTypeWithAnnotations.Type, _boundBody.Syntax, slotConstraints); 387SyntaxNode syntax = node.Syntax; 462Debug.Assert(node.Syntax is { }); 466EmitStepThroughSequencePoint(node.Syntax, span); 471EmitStepThroughSequencePoint(node.Syntax, node.Span);

136var temp = this.AllocateTemp(type, expression.Syntax); 140EmitSymbolToken(type, expression.Syntax); 244EmitInitObj(receiverType, true, expression.Syntax); 245EmitBox(receiverType, expression.Syntax); 318EmitSymbolToken(refValue.Type, refValue.Syntax); 331var value = this.AllocateTemp(expression.Type, expression.Syntax); 407EmitSymbolToken(elementType, arrayAccess.Syntax); 412arrayAccess.Syntax); 447EmitStaticFieldAddress(field, fieldAccess.Syntax); 524EmitBox(receiver.Type, receiver.Syntax); 559EmitSymbolToken(field, fieldAccess.Syntax); 582EmitSymbolToken(fixedElementField, fieldAccess.Syntax);

58_builder.EmitArrayBlockInitializer(data, inits.Syntax); 93EmitVectorElementStore(arrayType, init.Syntax); 208EmitArrayElementStore(arrayType, init.Syntax); 462var rosPointerCtor = (MethodSymbol?)Binder.GetWellKnownTypeMember(_module.Compilation, WellKnownMember.System_ReadOnlySpan_T__ctor_Pointer, _diagnostics, syntax: wrappedExpression.Syntax, isOptional: true); 555var field = _builder.module.GetFieldForData(data, alignment: 1, wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 557_builder.EmitToken(field, wrappedExpression.Syntax); 573EmitSymbolToken(rosPointerCtor.AsMember(spanType), wrappedExpression.Syntax, optArgList: null); 608MethodSymbol? createSpan = (MethodSymbol?)Binder.GetWellKnownTypeMember(_module.Compilation, WellKnownMember.System_Runtime_CompilerServices_RuntimeHelpers__CreateSpanRuntimeFieldHandle, _diagnostics, syntax: wrappedExpression.Syntax, isOptional: true); 616var field = _builder.module.GetFieldForData(data, alignment: (ushort)specialElementType.SizeInBytes(), wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 618_builder.EmitToken(field, wrappedExpression.Syntax); 620EmitSymbolToken(createSpan.Construct(elementType), wrappedExpression.Syntax, optArgList: null); 632if (!tryGetReadOnlySpanArrayCtor(wrappedExpression.Syntax, out var rosArrayCtor)) 649var cachingField = _builder.module.GetArrayCachingFieldForData(data, _module.Translate(arrayType), wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 655_builder.EmitToken(cachingField, wrappedExpression.Syntax); 665EmitSymbolToken(arrayType.ElementType, wrappedExpression.Syntax); 666_builder.EmitArrayBlockInitializer(data, wrappedExpression.Syntax); 669_builder.EmitToken(cachingField, wrappedExpression.Syntax); 675EmitSymbolToken(rosArrayCtor.AsMember(spanType), wrappedExpression.Syntax, optArgList: null); 696if (!tryGetReadOnlySpanArrayCtor(arrayCreation.Syntax, out var rosArrayCtor)) 708arrayCreation.Syntax, _diagnostics.DiagnosticBag); 715_builder.EmitToken(cachingField, arrayCreation.Syntax); 725_builder.EmitToken(cachingField, arrayCreation.Syntax); 743EmitSymbolToken(rosArrayCtor.AsMember(spanType), arrayCreation.Syntax, optArgList: null); 761EmitSymbolToken(spanType, wrappedExpression.Syntax); 771EmitDefaultValue(spanType, used, wrappedExpression.Syntax);

86EmitSymbolToken(expression.ConversionMethod, expression.Syntax, optArgList: null); 262EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 273EmitSymbolToken(conversion.Type, conversion.Syntax); 281EmitStaticCast(conversion.Type, conversion.Syntax); 294EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 305EmitSymbolToken(conversion.Type, conversion.Syntax); 310EmitSymbolToken(conversion.Type, conversion.Syntax); 367EmitSymbolToken(receiver.Type, receiver.Syntax); 375EmitBox(receiver.Type, receiver.Syntax); 398EmitSymbolToken(method, node.Syntax, null); 403var ctor = DelegateConstructor(node.Syntax, delegateType); 404if ((object)ctor != null) EmitSymbolToken(ctor, node.Syntax, null);

56EmitConstantExpression(expression.Type, constantValue, used, expression.Syntax); 183EmitLoadIndirect(thisType, expression.Syntax); 184EmitBox(thisType, expression.Syntax); 247EmitThrowIfModuleCancellationRequested(expression.Syntax); 252EmitModuleCancellationTokenLoad(expression.Syntax); 374EmitDefaultValue(node.Type, used, node.Syntax); 387EmitInitObj(receiverType, true, expression.Syntax); 388EmitBox(receiverType, expression.Syntax); 471EmitDefaultValue(receiverType, true, receiver.Syntax); 472EmitBox(receiverType, receiver.Syntax); 474EmitLoadIndirect(receiverType, receiver.Syntax); 476cloneTemp = AllocateTemp(receiverType, receiver.Syntax); 480EmitBox(receiverType, receiver.Syntax); 491EmitLoadIndirect(receiverType, receiver.Syntax); 492EmitBox(receiverType, receiver.Syntax); 524EmitSymbolToken(hasValueOpt, expression.Syntax, null); 545EmitDefaultValue(expression.Type, used, expression.Syntax); 658EmitLoadIndirect(expression.Type, expression.Syntax); 667EmitLoadIndirect(expression.Type, expression.Syntax); 680EmitSymbolToken(expression.Operand.Type, expression.Operand.Syntax); 695EmitSymbolToken(getTypeMethod, expression.Syntax, null); 782EmitLoadIndirect(expression.Type, expression.Syntax); 803EmitLoadIndirect(expression.Type, expression.Syntax); 825EmitLoadIndirect(thisType, thisRef.Syntax); 845var syntax = node.Syntax; 891DefineLocal(local, sequence.Syntax); 925var seqLocal = DefineLocal(local, sequence.Syntax); 1105EmitSymbolToken(elementType, arrayAccess.Syntax); 1112_builder.EmitArrayElementLoad(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Expression.Syntax); 1157EmitLoadIndirect(field.Type, fieldAccess.Syntax); 1176EmitSymbolToken(field, fieldAccess.Syntax); 1203EmitSymbolToken(field, fieldAccess.Syntax); 1249EmitSymbolToken(receiver.Type, receiver.Syntax); 1263EmitSymbolToken(field, fieldAccess.Syntax); 1425EmitLoadIndirect(local.LocalSymbol.Type, local.Syntax); 1438EmitLoadIndirect(parameterType, parameter.Syntax); 1661EmitSymbolToken(method.ContainingType, call.Syntax); 1691EmitSymbolToken(receiver.Type, receiver.Syntax); 1696EmitSymbolToken(method, call.Syntax, 1699EmitCallCleanup(call.Syntax, useKind, method); 1797EmitBox(parentCallReceiverType, nested.Syntax); 1816tempOpt = this.AllocateTemp(parentCallReceiverType, nested.Syntax); 1953EmitBox(receiverType, receiver.Syntax); 2035EmitSymbolToken(receiver.Type, receiver.Syntax); 2040EmitSymbolToken(actualMethodTargetedByTheCall, call.Syntax, 2043EmitCallCleanup(call.Syntax, useKind, method); 2078EmitDefaultValue(receiverType, true, receiver.Syntax); 2079EmitBox(receiverType, receiver.Syntax); 2086EmitLoadIndirect(receiverType, receiver.Syntax); 2087tempOpt = AllocateTemp(receiverType, receiver.Syntax); 2408EmitSymbolToken(arrayType.ElementType, expression.Syntax); 2412_builder.EmitArrayCreation(_module.Translate(arrayType), expression.Syntax); 2453EmitInitObj(expression.Type, used, expression.Syntax); 2488EmitSymbolToken(constructor, expression.Syntax, 2710EmitSymbolToken(target.Type, target.Syntax); 2751EmitSymbolToken(constructor, objCreation.Syntax, 3090assignmentOperator.Left.Syntax, 3118EmitIndirectStore(local.LocalSymbol.Type, local.Syntax); 3137EmitArrayElementStore(arrayType, expression.Syntax); 3150EmitIndirectStore(expression.Type, expression.Syntax); 3155EmitIndirectStore(expression.Type, expression.Syntax); 3161EmitIndirectStore(expression.Type, expression.Syntax); 3173EmitIndirectStore(expression.Type, expression.Syntax); 3178EmitIndirectStore(expression.Type, expression.Syntax); 3195EmitIndirectStore(nested.Type, expression.Syntax); 3222EmitLoadIndirect(assignment.Type, assignment.Syntax); 3231EmitSymbolToken(thisRef.Type, thisRef.Syntax); 3325EmitIndirectStore(field.Type, fieldAccess.Syntax); 3330EmitSymbolToken(field, fieldAccess.Syntax); 3340EmitIndirectStore(parameter.ParameterSymbol.Type, parameter.Syntax); 3428EmitBox(operand.Type, operand.Syntax); 3431EmitSymbolToken(isOp.TargetType.Type, isOp.Syntax); 3457EmitBox(operandType, operand.Syntax); 3460EmitSymbolToken(targetType, asOp.Syntax); 3465EmitSymbolToken(targetType, asOp.Syntax); 3511EmitDefaultValue(expression.Type, used, expression.Syntax); 3551EmitSymbolToken(getTypeMethod, boundTypeOf.Syntax, null); 3558EmitSymbolToken(type, boundTypeOfOperator.SourceType.Syntax); 3566EmitSymbolToken(type, boundSizeOfOperator.SourceType.Syntax); 3584EmitSymbolToken(symbol, node.Syntax, null, encodeAsRawDefinitionToken: true); 3597EmitHoistedVariableId(node.HoistedField, node.Syntax); 3611EmitHoistedVariableId(node.HoistedField, node.Syntax); 3646_module.GetModuleVersionId(_module.Translate(node.Type, node.Syntax, _diagnostics.DiagnosticBag), node.Syntax, _diagnostics.DiagnosticBag), 3647node.Syntax); 3700_builder.EmitToken(_module.GetInstrumentationPayloadRoot(node.AnalysisKind, _module.Translate(node.Type, node.Syntax, _diagnostics.DiagnosticBag), node.Syntax, _diagnostics.DiagnosticBag), node.Syntax); 3713EmitSymbolToken(node.Method, node.Syntax, null); 3726EmitSymbolToken(node.Method.ContainingType, node.Syntax); 3730EmitSymbolToken(getMethod, node.Syntax, null); 3734EmitSymbolToken(node.Type, node.Syntax); 3741EmitSymbolToken(node.Field, node.Syntax); 3753EmitSymbolToken(node.Field.ContainingType, node.Syntax); 3757EmitSymbolToken(getField, node.Syntax, null); 3761EmitSymbolToken(node.Type, node.Syntax); 3828EmitStaticCast(expr.Type, expr.Syntax); 3833EmitStaticCast(expr.Type, expr.Syntax); 3852EmitStaticCast(expr.Type, expr.Syntax); 3857EmitStaticCast(expr.Type, expr.Syntax); 3889EmitStaticCast(expr.Type, expr.Syntax); 3894EmitStaticCast(expr.Type, expr.Syntax); 3902EmitBox(expr.Type, expr.LeftOperand.Syntax); 3919EmitStaticCast(expr.Type, expr.Syntax); 4063temp = AllocateTemp(ptrInvocation.InvokedExpression.Type, ptrInvocation.Syntax); 4085EmitSignatureToken(ptrInvocation.FunctionPointer, ptrInvocation.Syntax); 4086EmitCallCleanup(ptrInvocation.Syntax, useKind, method); 4157EmitSymbolToken(load.ConstrainedToTypeOpt, load.Syntax); 4161EmitSymbolToken(load.TargetMethod, load.Syntax, optArgList: null);

461EmitBox(comparandType, comparand.Syntax); 464_builder.EmitConstantValue(nullOrZero, comparand.Syntax); 475EmitBox(comparandType, comparand.Syntax); 478_builder.EmitConstantValue(nullOrZero, comparand.Syntax);

59var field = _builder.module.GetFieldForData(data, alignment: 1, inits.Syntax, _diagnostics.DiagnosticBag); 62_builder.EmitToken(field, inits.Syntax); 69var syntaxNode = inits.Syntax; 192EmitIndirectStore(elementType, init.Syntax); 231EmitSymbolToken(elementType, init.Syntax);

182this.EmitBox(exprType, thrown.Syntax); 593EmitBox(operand.Type, operand.Syntax); 596EmitSymbolToken(isOp.TargetType.Type, isOp.TargetType.Syntax); 613EmitBox(conditionType, condition.Syntax); 686DefineLocal(local, block.Syntax); 711_diagnostics.Add(ErrorCode.ERR_ModuleEmitFailure, block.Syntax.Location, ((Cci.INamedEntity)_module).Name, "Exception handling is not allowed in exception filters"); 763DefineLocal(local, !declaringReferences.IsEmpty ? (CSharpSyntaxNode)declaringReferences[0].GetSyntax() : block.Syntax); 868(boundReturnStatement.Syntax.IsKind(SyntaxKind.Block) || _method?.IsImplicitConstructor == true) && 925_module.Translate(expressionOpt.Type, boundReturnStatement.Syntax, _diagnostics.DiagnosticBag); 940_diagnostics.Add(ErrorCode.ERR_ModuleEmitFailure, statement.Syntax.Location, ((Cci.INamedEntity)_module).Name, "Exception handling is not allowed in exception filters"); 1071_module.Translate(catchBlock.ExceptionTypeOpt, catchBlock.Syntax, _diagnostics.DiagnosticBag) : 1072_module.GetSpecialType(SpecialType.System_Object, catchBlock.Syntax, _diagnostics.DiagnosticBag); 1086var syntax = catchBlock.Syntax as CatchClauseSyntax; 1119var exceptionType = _module.Translate(catchBlock.ExceptionTypeOpt, catchBlock.Syntax, _diagnostics.DiagnosticBag); 1122_builder.EmitToken(exceptionType, catchBlock.Syntax); 1140var localSyntax = !declaringReferences.IsEmpty ? (CSharpSyntaxNode)declaringReferences[0].GetSyntax() : catchBlock.Syntax; 1154EmitSymbolToken(exceptionSourceOpt.Type, exceptionSourceOpt.Syntax); 1192var temp = AllocateTemp(exceptionSource.Type, exceptionSource.Syntax); 1328temp = AllocateTemp(expression.Type, expression.Syntax); 1342this.EmitStringSwitchJumpTable(switchCaseLabels, fallThroughLabel, key, expression.Syntax, expression.Type); 1346this.EmitLengthBasedStringSwitchJumpTable(lengthBasedSwitchStringJumpTableOpt, fallThroughLabel, key, expression.Syntax, expression.Type); 1351_builder.EmitIntegerSwitchJumpTable(switchCaseLabels, fallThroughLabel, key, expression.Type.EnumUnderlyingTypeOrSelf().PrimitiveTypeCode, expression.Syntax);

1669PushEvalStack(new BoundDefaultExpression(node.Syntax, node.Operand.Type), ExprContext.Value); 2146return new BoundDup(node.Syntax, node.LocalSymbol.RefKind, node.Type); 2208return new BoundRefArrayAccess(arrayAccess.Syntax, arrayAccess);

2206var binder = this.GetEnclosingBinder(boundExpr.Syntax.Span.Start); 3369if (expr.Syntax.Kind() is SyntaxKind.ObjectCreationExpression or SyntaxKind.ImplicitObjectCreationExpression) 3396boundNodeForSyntacticParent.Syntax.Kind() == SyntaxKind.ObjectCreationExpression && 3397((ObjectCreationExpressionSyntax)boundNodeForSyntacticParent.Syntax).Type == boundType.Syntax && 3681Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 3978SyntaxNode parentSyntax = boundNodeForSyntacticParent.Syntax; 3980parentSyntax == boundNode.Syntax.Parent && 3981parentSyntax.Kind() == SyntaxKind.Attribute && ((AttributeSyntax)parentSyntax).Name == boundNode.Syntax) 4028Debug.Assert(binderOpt != null || IsInTree(lowestBoundNode.Syntax)); 4032Debug.Assert(lowestBoundNode.Syntax != null); 4037Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(lowestBoundNode.Syntax)); 4088Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4097Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 4245Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4258Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 4270InvocationExpressionSyntax invocation = call.Syntax as InvocationExpressionSyntax; 4271if (invocation != null && invocation.Expression.SkipParens() == ((ExpressionSyntax)boundNode.Syntax).SkipParens() && (object)call.Method != null) 4397Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4419var elementAccess = indexer.Syntax as ElementAccessExpressionSyntax; 4420if (elementAccess != null && elementAccess.Expression == boundNode.Syntax && (object)indexer.Indexer != null)

168return new BoundPropertyEqualsValue(result.Syntax, property, result.Locals, result.Value);

1497alreadyInTree = _guardedBoundNodeMap.ContainsKey(bound.Syntax); 1505Debug.Assert(syntax != _root || _guardedBoundNodeMap.ContainsKey(bound.Syntax)); 1529alreadyInTree = _guardedBoundNodeMap.ContainsKey(bound.Syntax); 1541Debug.Assert(syntax != _root || _guardedBoundNodeMap.ContainsKey(bound.Syntax)); 1850return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, unbound.Syntax), 1851position, unbound.BindForErrorRecovery().Binder, unbound.Syntax); 1854return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, lambda.Body.Syntax), 1855position, lambda.Binder, lambda.Body.Syntax); 1863return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, queryClause.Syntax), 1864position, queryClause.Binder, queryClause.Syntax); 1879var span = expr.Syntax.FullSpan; 1898if (value.Syntax.FullSpan.Contains(position)) 1903if (expr.Syntax.FullSpan.Contains(position)) 1992_guardedBoundNodeMap.ContainsKey(bind(bindableRoot, out _).Syntax));

41Debug.Assert(node == null || root == null || !(root.Syntax is StatementSyntax), "individually added nodes are not supposed to be statements."); 43if (root == null || map.ContainsKey(root.Syntax)) 187_map.Add(current.Syntax, current); 206_map.Add(binOp.Syntax, binOp); 235_map.Add(binaryPattern.Syntax, binaryPattern); 271if (_thisSyntaxNodeOnly != null && currentBoundNode.Syntax != _thisSyntaxNodeOnly) 300if (node.Syntax != node.Initializer?.Syntax) 332_map.Add(node.Syntax, node);

51Debug.Assert(boundRoot.Syntax is TypeSyntax);

34SyntaxNode syntax = loweredBody.Syntax; 532var syntax = block.Syntax;

1019body = BoundBlock.SynthesizedNoLocals(initializerStatements.Syntax, initializerStatements.Statements); 1052new BoundBlock(analyzedInitializers.Syntax, ImmutableArray<LocalSymbol>.Empty, analyzedInitializers.Statements), // The block is necessary to establish the right local scope for the analysis 1175var syntax = body.Syntax; 1624return new BoundBadStatement(body.Syntax, ImmutableArray.Create<BoundNode>(body), hasErrors: true); 2010body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer)); 2014body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer, body)); 2363if (!LambdaUtilities.TryGetLambdaBodies(node.Syntax, out var body1, out var body2)) 2498var constructorInitializer = new BoundExpressionStatement(initializerInvocation.Syntax, initializerInvocation) { WasCompilerGenerated = method.IsImplicitlyDeclared }; 2513compilationState.ReportCtorInitializerCycles(method, ctorCall.Method, ctorCall.Syntax, diagnostics);

201int startLocation = firstInRegion.Syntax.SpanStart; 202int endLocation = lastInRegion.Syntax.Span.End; 897Diagnostics.Add(ErrorCode.ERR_InternalError, node.Syntax.Location); 1386VisitLocalFunctionUse(localFunc, node.Syntax, isCall: true); 1626VisitLocalFunctionUse(localFunc, node.Syntax, isCall: false); 1753VisitLocalFunctionUse(localFunc, node.Syntax, isCall: false); 2909if (AwaitUsingAndForeachAddsPendingBranch && ((CommonForEachStatementSyntax)node.Syntax).AwaitKeyword != default)

116LeaveParameters(localFuncSymbol.Parameters, localFunc.Syntax, location); 128branch?.Syntax,

106foreach (var sectionSyntax in ((SwitchStatementSyntax)node.Syntax).Sections)

85if (IsInside && pending.Branch != null && !RegionContains(pending.Branch.Syntax.Span)) 107if (node.Syntax != null && RegionContains(node.Syntax.Span)) _labelsInside.Add(label); 137if (branch.Branch != null && RegionContains(branch.Branch.Syntax.Span) && !_labelsInside.Contains(branch.Label))

218var loc = new SourceLocation(leave.Syntax.GetFirstToken()); 226var loc = new SourceLocation(leave.Syntax.GetFirstToken()); 265statement.Syntax.Span.Length != 0) 267var firstToken = statement.Syntax.GetFirstToken(); 303var location = new SourceLocation(branch.Branch.Syntax.GetFirstToken()); 341var sourceLocation = node.Syntax.Location; 379var syntax = node.SwitchLabels.Last().Syntax;

85if (!gotoStmt.WasCompilerGenerated && !targetStmt.WasCompilerGenerated && !RegionContains(gotoStmt.Syntax.Span) && RegionContains(targetStmt.Syntax.Span))

394LeaveParameters(methodParameters, returnBranch.Branch.Syntax, null); 395if ((object)methodThisParameter != null) LeaveParameter(methodThisParameter, returnBranch.Branch.Syntax, null); 396if ((object)extensionParameter != null) LeaveParameter(extensionParameter, returnBranch.Branch.Syntax, null); 1472CheckAssigned(fieldAccess, node.Syntax); 1576LeaveParameter(param, node.Syntax, paramExpr.Syntax.Location); 2324CheckAssigned(localSymbol, node.Syntax); 2331Diagnostics.Add(ErrorCode.ERR_FixedLocalInLambda, new SourceLocation(node.Syntax), localSymbol); 2399LeaveParameters(node.Symbol.Parameters, node.Syntax, null); 2408LeaveParameters(node.Symbol.Parameters, pending.Branch.Syntax, null); 2427CheckAssigned(MethodThisParameter, node.Syntax); 2435CheckAssigned(node.ParameterSymbol, node.Syntax); 2506if (_unassignedVariableAddressOfSyntaxes?.Contains(node.Syntax as PrefixUnaryExpressionSyntax) == false) 2513_unsafeAddressTakenVariables.Add(variable, node.Syntax.Location); 2530CheckAssigned(arg, arg.Syntax); 2631CheckAssigned(MethodThisParameter, node.Syntax); 2660if (node.FieldSymbol.IsFixedSizeBuffer && node.Syntax != null && !SyntaxFacts.IsFixedStatementExpression(node.Syntax)) 2668_unsafeAddressTakenVariables.Add(receiver, node.Syntax.Location); 2675CheckAssigned(node, node.FieldSymbol, node.Syntax); 2696ReportUnassignedIfNotCapturedInLocalFunction(backingField, node.Syntax, unassignedSlot); 2715CheckAssigned(node, associatedField, node.Syntax);

62if (!gotoStmt.WasCompilerGenerated && !targetStmt.WasCompilerGenerated && RegionContains(targetStmt.Syntax.Span) && !RegionContains(gotoStmt.Syntax.Span)) 63_entryPoints.Add((LabeledStatementSyntax)targetStmt.Syntax);

124if (pending.Branch == null || !RegionContains(pending.Branch.Syntax.Span)) continue; 150_branchesOutOf.Add((StatementSyntax)pending.Branch.Syntax);

85var newStatements = block.Statements.Add(new BoundReturnStatement(trailingExpression.Syntax, RefKind.None, trailingExpression, @checked: false)); 86block = new BoundBlock(block.Syntax, ImmutableArray<LocalSymbol>.Empty, newStatements) { WasCompilerGenerated = true }; 120var F = new SyntheticBoundNodeFactory(method, body.Syntax, compilationState, diagnostics); 195SyntaxNode syntax = body.Syntax;

648enforceMemberNotNull(syntaxOpt: pendingReturn.Branch.Syntax, pendingReturn.State); 652EnforceParameterNotNullOnExit(returnStatement.Syntax, pendingReturn.State); 1087_ => syntaxOpt ?? (SyntaxNodeOrToken)methodMainNode.Syntax.GetLastToken() 1102enforceMemberNotNullWhen(returnStatement.Syntax, sense: value, pendingReturn.State); 1115enforceMemberNotNullWhenIfAffected(returnStatement.Syntax, sense: true, members: method.ContainingType.GetMembers(memberName), state: pendingReturn.StateWhenTrue, otherState: pendingReturn.StateWhenFalse); 1120enforceMemberNotNullWhenIfAffected(returnStatement.Syntax, sense: false, members: method.ContainingType.GetMembers(memberName), state: pendingReturn.StateWhenFalse, otherState: pendingReturn.StateWhenTrue); 1160Diagnostics.Add(ErrorCode.WRN_MemberNotNullWhen, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name, sense ? "true" : "false"); 1267EnforceParameterNotNullWhenOnExit(returnStatement.Syntax, parameters, sense: value, stateWhen: pendingReturn.State); 1281ReportParameterIfBadConditionalState(returnStatement.Syntax, parameter, sense: true, stateWhen: pendingReturn.StateWhenTrue); 1282ReportParameterIfBadConditionalState(returnStatement.Syntax, parameter, sense: false, stateWhen: pendingReturn.StateWhenFalse); 1289EnforceParameterNotNullWhenOnExit(returnStatement.Syntax, parameters, sense: value, stateWhen: pendingReturn.State); 1328location = syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(); 1414var location = syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(); 1437ReportDiagnostic(ErrorCode.WRN_ShouldNotReturn, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation()); 1491compilation.GetBinderFactory(node.SyntaxTree).GetBinder(node.Syntax); 1930var key = (object?)symbol ?? methodMainNode.Syntax; 1973RoslynDebug.Assert(AreCloseEnough(originalSymbol, updatedSymbol), $"Attempting to set {node.Syntax} from {originalSymbol.ToDisplayString()} to {updatedSymbol.ToDisplayString()}"); 2440location ??= value.Syntax.GetLocation(); 3039CheckDisallowedNullAssignment(resultType, parameterAnnotations, equalsValue.Value.Syntax); 3066EnforceDoesNotReturn(node.Syntax); 3096CheckDisallowedNullAssignment(returnState, ToInwardAnnotations(returnAnnotations), node.Syntax, boundValueOpt: expr); 3108EnforceDoesNotReturn(node.Syntax); 3125EnforceNotNullIfNotNull(node.Syntax, this.State, parameters, method.ReturnNotNullIfParameterNotNull, ResultType.State, outputParam: null); 3143ReportNullabilityMismatchInAssignment(expr.Syntax, lvalueResultType, destinationType); 3481enforceMemberNotNull(syntax: pendingReturn.Branch?.Syntax, pendingReturn.State); 3486EnforceParameterNotNullOnExit(returnStatement.Syntax, pendingReturn.State); 4044var foundIterationType = _binder.TryGetCollectionIterationType((ExpressionSyntax)node.Syntax, collectionType, out targetElementType); 4051_binder.TryGetCollectionIterationType(node.Syntax, collectionType, out targetElementType); 4370receiver: new BoundExpressionWithNullability(objectInitializer.Syntax, objectInitializer, NullableAnnotation.NotAnnotated, containingType)); 4486[new BoundExpressionWithNullability(objectInitializer.Syntax, objectInitializer, nullableAnnotation: NullableAnnotation.NotAnnotated, containingType)], 4531ReportDiagnostic(ErrorCode.WRN_NullReferenceInitializer, initializer.Syntax, symbol); 5397MethodSymbol reinferredMethod = ReInferBinaryOperator(binary.Syntax, method, leftOperand, rightOperand, leftUnderlyingType, rightUnderlyingType); 5486[new BoundExpressionWithNullability(leftOperand.Syntax, leftOperand, leftUnderlyingType.ToTypeWithAnnotations(compilation).NullableAnnotation, leftUnderlyingType.Type), 5487new BoundExpressionWithNullability(rightOperand.Syntax, rightOperand, rightUnderlyingType.ToTypeWithAnnotations(compilation).NullableAnnotation, rightUnderlyingType.Type)], 5555if (CheckDisallowedNullAssignment(resultType, parameterAnnotations, expr.Syntax, operand)) 6455ReportNullabilityMismatchInAssignment(node.Syntax, source, destination); 6516new BoundExpressionWithNullability(expr.Syntax, expr, type.NullableAnnotation, type.Type); 7238var syntax = node.Syntax; 7378var syntaxForConstraintCheck = node.Syntax switch 7382_ => node.Syntax 7947ReportNullabilityMismatchInArgument(argumentNoConversion.Syntax, argumentResultType, parameter, parameterType.Type, forOutput: false); 7967if (CheckDisallowedNullAssignment(stateAfterConversion, parameterAnnotations, argumentNoConversion.Syntax)) 7989CheckDisallowedNullAssignment(resultType, parameterAnnotations, argumentNoConversion.Syntax); 8089var parameterValue = new BoundParameter(argument.Syntax, parameter); 8129var parameterValue = new BoundParameter(argument.Syntax, parameter); 8132CheckDisallowedNullAssignment(parameterWithState, leftAnnotations, argument.Syntax); 8145ReportNullabilityMismatchInArgument(argument.Syntax, lValueType.Type, parameter, parameterType.Type, forOutput: true); 8603return new BoundUnconvertedCollectionExpression(collection.Syntax, elementsBuilder.ToImmutableAndFree()) { WasCompilerGenerated = true }; 8617return new BoundExpressionWithNullability(argument.Syntax, argument, NullableAnnotation.Oblivious, type: null); 8620return new BoundExpressionWithNullability(argument.Syntax, argument, argumentType.NullableAnnotation, argumentType.Type); 8744ReportNullabilityMismatchInAssignment(sourceExpression.Syntax, GetTypeAsDiagnosticArgument(sourceType), destinationType); 9100var locations = tupleOpt.TupleElements.SelectAsArray((element, location) => element.TryGetFirstLocation() ?? location, node.Syntax.Location); 9104tupleOpt.CheckConstraints(new ConstraintsHelper.CheckConstraintsArgs(compilation, _conversions, includeNullability: true, node.Syntax.Location, diagnostics: null), 9105typeSyntax: node.Syntax, locations, nullabilityDiagnosticsOpt: diagnostics); 9273diagnosticLocation: (conversionOpt ?? convertedNode).Syntax.GetLocation()); 9346if (lambda.Syntax is LambdaExpressionSyntax lambdaSyntax) 9786diagnosticLocation ??= (conversionOpt ?? conversionOperand).Syntax.GetLocation(); 10063Location operandLocation = conversionOperand.Syntax.GetLocation(); 10076if (!isLiftedConversion && CheckDisallowedNullAssignment(operandType, parameterAnnotations, conversionOperand.Syntax)) 10151conversionOpt.Syntax.SpanStart != convertedNode.Syntax.SpanStart) 10350ReportNullabilityMismatchWithTargetDelegate(group.Syntax.Location, delegateType, delegateInvokeMethod, method, node.IsExtensionMethod); 10422ReportNullabilityMismatchWithTargetDelegate(arg.Syntax.Location, delegateType, delegateInvokeMethod, argInvokeMethod, invokedAsExtensionMethod: false); 10480var syntax = group.Syntax; 10486if (method.GetMemberArityIncludingExtension() != 0 && HasImplicitTypeArguments(group.Syntax)) 10662CheckDisallowedNullAssignment(rightState, leftAnnotations, right.Syntax); 10875placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 10885CheckMethodConstraints(invocation.Syntax, deconstructMethod); 11000CheckDisallowedNullAssignment(valueType, leftAnnotations, right.Syntax); 11101return fields.SelectAsArray((f, e) => (BoundExpression)new BoundFieldAccess(e.Syntax, e, f, constantValueOpt: null), expr); 11190incrementOperator = ReInferUnaryOperator(node.Syntax, incrementOperator, node.Operand, GetNullableUnderlyingTypeIfNecessary(isLifted, operandType)); 11412CheckDisallowedNullAssignment(resultTypeWithState, leftArgumentAnnotations, node.Syntax); 11450argument.Syntax, argumentType, parameterType, 11898ReportDiagnostic(ErrorCode.WRN_NullReferenceReceiver, expr.Syntax.GetLocation()); 11952var variableLocation = node.Syntax switch 11956_ => throw ExceptionUtilities.UnexpectedValue(node.Syntax) 11987var foreachSyntax = (ForEachStatementSyntax)node.Syntax; 12149method = ReInferUnaryOperator(node.Syntax, method, operand, operandType); 12203[new BoundExpressionWithNullability(operand.Syntax, operand, operandType.ToTypeWithAnnotations(compilation).NullableAnnotation, operandType.Type)], 12365MethodSymbol reInferredMethod = ReInferBinaryOperator(binary.Syntax, logicalOperator, leftOperand, rightOperand, leftUnderlyingType, rightUnderlyingType); 12381var updatedTrueFalseOperator = ReInferUnaryOperator(leftOperand.Syntax, trueFalseOperator, binary.Left, leftType); 12796if (!ReportPossibleNullReceiverIfNeeded(resultTypeSymbol, resultType.State, checkNullableValueType, receiverOpt.Syntax, out reportedDiagnostic)) 12973ReportDiagnostic(ErrorCode.WRN_ThrowPossibleNull, expr.Syntax);

71RoslynDebug.Assert(!_analyzedNullabilityMap.ContainsKey(expression), $"Found unexpected {expression} `{expression.Syntax}` in the map."); 75RoslynDebug.Assert(_analyzedNullabilityMap.ContainsKey(expression), $"Did not find {expression} `{expression.Syntax}` in the map.");

111int nodePosition = node.Syntax.SpanStart; 116Debug.Fail($"Did not find a snapshot for {node} `{node.Syntax}.`"); 118RoslynDebug.Assert(_walkerSharedStates.Length > _incrementalSnapshots[position].snapshot.SharedStateIndex, $"Did not find shared state for {node} `{node.Syntax}`."); 125var debugText = expr?.Syntax.ToFullString() ?? originalSymbol.ToDisplayString(); 217_incrementalSnapshots[node.Syntax.SpanStart] = new Snapshot(currentState.CreateSnapshot(), _currentWalkerSlot);

300var labelStateMap = LearnFromDecisionDag(node.Syntax, node.ReachabilityDecisionDag, node.Expression, expressionState, stateWhenNotNullOpt: null); 452var output = new BoundDagTemp(e.Syntax, parameterType.Type, e, i); 461var output = new BoundDagTemp(e.Syntax, e.Type, e); 490var output = new BoundDagTemp(e.Syntax, type.Type, e); 535? ReInferAndVisitExtensionPropertyAccess(e, e.Property, new BoundExpressionWithNullability(e.Syntax, expression, NullableAnnotation.NotAnnotated, inputType)).Member 538var output = new BoundDagTemp(e.Syntax, type.Type, e); 563var output = new BoundDagTemp(e.Syntax, type.Type, e); 575var output = new BoundDagTemp(e.Syntax, type.Type, e); 842var output = new BoundDagTemp(e.Syntax, type.Type, e, index: index); 894var labelStateMap = LearnFromDecisionDag(node.Syntax, node.ReachabilityDecisionDag, node.Expression, expressionState, stateWhenNotNullOpt: null); 909((SwitchExpressionSyntax)node.Syntax).SwitchKeyword.GetLocation(), 1062var labelStateMap = LearnFromDecisionDag(node.Syntax, node.ReachabilityDecisionDag, node.Expression, expressionState, hasStateWhenNotNull ? conditionalStateWhenNotNull : null);

186var receiverSyntax = receiver.Syntax; 259if (!IsInside && node.Syntax != null && node.Syntax.Span.Contains(RegionSpan)) 269if (!IsInside && node.Syntax != null && node.Syntax.Span.Contains(RegionSpan))

45firstInRegion.Syntax.SpanStart > lastInRegion.Syntax.Span.End;

310var result = new BoundFieldEqualsValue(this.Syntax, field, locals, value, this.HasErrors); 340var result = new BoundPropertyEqualsValue(this.Syntax, property, locals, value, this.HasErrors); 370var result = new BoundParameterEqualsValue(this.Syntax, parameter, locals, value, this.HasErrors); 398var result = new BoundGlobalStatementInitializer(this.Syntax, statement, this.HasErrors); 471var result = new BoundValuePlaceholder(this.Syntax, type, this.HasErrors); 499var result = new BoundCapturedReceiverPlaceholder(this.Syntax, receiver, type, this.HasErrors); 540var result = new BoundDeconstructValuePlaceholder(this.Syntax, variableSymbol, isDiscardExpression, type, this.HasErrors); 575var result = new BoundTupleOperandPlaceholder(this.Syntax, type, this.HasErrors); 604var result = new BoundAwaitableValuePlaceholder(this.Syntax, type, this.HasErrors); 639var result = new BoundDisposableValuePlaceholder(this.Syntax, type, this.HasErrors); 677var result = new BoundObjectOrCollectionValuePlaceholder(this.Syntax, isNewInstance, type, this.HasErrors); 712var result = new BoundImplicitIndexerValuePlaceholder(this.Syntax, type, this.HasErrors); 750var result = new BoundImplicitIndexerReceiverPlaceholder(this.Syntax, isEquivalentToThisReference, type, this.HasErrors); 785var result = new BoundListPatternReceiverPlaceholder(this.Syntax, type, this.HasErrors); 820var result = new BoundListPatternIndexPlaceholder(this.Syntax, type, this.HasErrors); 855var result = new BoundSlicePatternReceiverPlaceholder(this.Syntax, type, this.HasErrors); 890var result = new BoundSlicePatternRangePlaceholder(this.Syntax, type, this.HasErrors); 921var result = new BoundDup(this.Syntax, refKind, type, this.HasErrors); 949var result = new BoundPassByCopy(this.Syntax, expression, type, this.HasErrors); 986var result = new BoundBadExpression(this.Syntax, resultKind, symbols, childBoundNodes, type, this.HasErrors); 1014var result = new BoundBadStatement(this.Syntax, childBoundNodes, this.HasErrors); 1042var result = new BoundExtractedFinallyBlock(this.Syntax, finallyBlock, this.HasErrors); 1077var result = new BoundTypeExpression(this.Syntax, aliasOpt, boundContainingTypeOpt, boundDimensionsOpt, typeWithAnnotations, type, this.HasErrors); 1126var result = new BoundTypeOrValueExpression(this.Syntax, binder, valueSymbol, type, this.HasErrors); 1167var result = new BoundNamespaceExpression(this.Syntax, namespaceSymbol, aliasOpt, this.HasErrors); 1209var result = new BoundUnaryOperator(this.Syntax, operatorKind, operand, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1257var result = new BoundIncrementOperator(this.Syntax, operatorKind, operand, methodOpt, constrainedToTypeOpt, operandPlaceholder, operandConversion, resultPlaceholder, resultConversion, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1289var result = new BoundAddressOfOperator(this.Syntax, operand, isManaged, type, this.HasErrors); 1318var result = new BoundUnconvertedAddressOfOperator(this.Syntax, operand, this.HasErrors); 1361var result = new BoundFunctionPointerLoad(this.Syntax, targetMethod, constrainedToTypeOpt, type, this.HasErrors); 1393var result = new BoundPointerIndirectionOperator(this.Syntax, operand, refersToLocation, type, this.HasErrors); 1430var result = new BoundPointerElementAccess(this.Syntax, expression, index, @checked, refersToLocation, type, this.HasErrors); 1467var result = new BoundFunctionPointerInvocation(this.Syntax, invokedExpression, arguments, argumentRefKindsOpt, resultKind, type, this.HasErrors); 1499var result = new BoundRefTypeOperator(this.Syntax, operand, getTypeFromHandle, type, this.HasErrors); 1529var result = new BoundMakeRefOperator(this.Syntax, operand, type, this.HasErrors); 1561var result = new BoundRefValueOperator(this.Syntax, nullableAnnotation, operand, type, this.HasErrors); 1593var result = new BoundFromEndIndexExpression(this.Syntax, operand, methodOpt, type, this.HasErrors); 1626var result = new BoundRangeExpression(this.Syntax, leftOperandOpt, rightOperandOpt, methodOpt, type, this.HasErrors); 1683var result = new BoundBinaryOperator(this.Syntax, operatorKind, data, resultKind, left, right, type, this.HasErrors); 1721var result = new BoundTupleBinaryOperator(this.Syntax, left, right, operatorKind, operators, type, this.HasErrors); 1774var result = new BoundUserDefinedConditionalLogicalOperator(this.Syntax, operatorKind, logicalOperator, trueOperator, falseOperator, trueFalseOperandPlaceholder, trueFalseOperandConversion, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, left, right, type, this.HasErrors); 1821var result = new BoundCompoundAssignmentOperator(this.Syntax, @operator, left, right, leftPlaceholder, leftConversion, finalPlaceholder, finalConversion, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1855var result = new BoundAssignmentOperator(this.Syntax, left, right, isRef, type, this.HasErrors); 1890var result = new BoundDeconstructionAssignmentOperator(this.Syntax, left, right, isUsed, type, this.HasErrors); 1931var result = new BoundNullCoalescingOperator(this.Syntax, leftOperand, rightOperand, leftPlaceholder, leftConversion, operatorResultKind, @checked, type, this.HasErrors); 1962var result = new BoundNullCoalescingAssignmentOperator(this.Syntax, leftOperand, rightOperand, type, this.HasErrors); 2001var result = new BoundUnconvertedConditionalOperator(this.Syntax, condition, consequence, alternative, constantValueOpt, noCommonTypeError, this.HasErrors); 2045var result = new BoundConditionalOperator(this.Syntax, isRef, condition, consequence, alternative, constantValueOpt, naturalTypeOpt, wasTargetTyped, type, this.HasErrors); 2078var result = new BoundArrayAccess(this.Syntax, expression, indices, type, this.HasErrors); 2107var result = new BoundRefArrayAccess(this.Syntax, arrayAccess, this.HasErrors); 2137var result = new BoundArrayLength(this.Syntax, expression, type, this.HasErrors); 2178var result = new BoundAwaitableInfo(this.Syntax, awaitableInstancePlaceholder, isDynamic, getAwaiter, isCompleted, getResult, runtimeAsyncAwaitCall, runtimeAsyncAwaitCallPlaceholder, this.HasErrors); 2213var result = new BoundAwaitExpression(this.Syntax, expression, awaitableInfo, debugInfo, type, this.HasErrors); 2266var result = new BoundTypeOfOperator(this.Syntax, sourceType, getTypeFromHandle, type, this.HasErrors); 2298var result = new BoundBlockInstrumentation(this.Syntax, locals, prologue, epilogue, this.HasErrors); 2342var result = new BoundMethodDefIndex(this.Syntax, method, type, this.HasErrors); 2385var result = new BoundLocalId(this.Syntax, local, hoistedField, type, this.HasErrors); 2428var result = new BoundParameterId(this.Syntax, parameter, hoistedField, type, this.HasErrors); 2463var result = new BoundStateMachineInstanceId(this.Syntax, type, this.HasErrors); 2498var result = new BoundMaximumMethodDefIndex(this.Syntax, type, this.HasErrors); 2536var result = new BoundInstrumentationPayloadRoot(this.Syntax, analysisKind, type, this.HasErrors); 2571var result = new BoundThrowIfModuleCancellationRequested(this.Syntax, type, this.HasErrors); 2606var result = new ModuleCancellationTokenExpression(this.Syntax, type, this.HasErrors); 2641var result = new BoundModuleVersionId(this.Syntax, type, this.HasErrors); 2676var result = new BoundModuleVersionIdString(this.Syntax, type, this.HasErrors); 2716var result = new BoundSourceDocumentIndex(this.Syntax, document, type, this.HasErrors); 2759var result = new BoundMethodInfo(this.Syntax, method, getMethodFromHandle, type, this.HasErrors); 2802var result = new BoundFieldInfo(this.Syntax, field, getFieldFromHandle, type, this.HasErrors); 2856var result = new BoundDefaultExpression(this.Syntax, targetType, constantValueOpt, type, this.HasErrors); 2891var result = new BoundIsOperator(this.Syntax, operand, targetType, conversionKind, type, this.HasErrors); 2928var result = new BoundAsOperator(this.Syntax, operand, targetType, operandPlaceholder, operandConversion, type, this.HasErrors); 2960var result = new BoundSizeOfOperator(this.Syntax, sourceType, constantValueOpt, type, this.HasErrors); 3008var result = new BoundConversion(this.Syntax, operand, conversion, isBaseConversion, @checked, explicitCastInCode, constantValueOpt, conversionGroupOpt, inConversionGroupFlags, type, this.HasErrors); 3041var result = new BoundReadOnlySpanFromArray(this.Syntax, operand, conversionMethod, type, this.HasErrors); 3076var result = new BoundArgList(this.Syntax, type, this.HasErrors); 3107var result = new BoundArgListOperator(this.Syntax, arguments, argumentRefKindsOpt, type, this.HasErrors); 3146var result = new BoundFixedLocalCollectionInitializer(this.Syntax, elementPointerType, elementPointerPlaceholder, elementPointerConversion, expression, getPinnableOpt, type, this.HasErrors); 3185var result = new BoundSequencePoint(this.Syntax, statementOpt, this.HasErrors); 3212var result = new BoundSequencePointWithSpan(this.Syntax, statementOpt, span, this.HasErrors); 3249var result = new BoundSavePreviousSequencePoint(this.Syntax, identifier, this.HasErrors); 3286var result = new BoundRestorePreviousSequencePoint(this.Syntax, identifier, this.HasErrors); 3317var result = new BoundStepThroughSequencePoint(this.Syntax, span, this.HasErrors); 3353var result = new BoundBlock(this.Syntax, locals, localFunctions, hasUnsafeModifier, instrumentation, statements, this.HasErrors); 3382var result = new BoundScope(this.Syntax, locals, statements, this.HasErrors); 3413var result = new BoundStateMachineScope(this.Syntax, fields, statement, this.HasErrors); 3449var result = new BoundLocalDeclaration(this.Syntax, localSymbol, declaredTypeOpt, initializerOpt, argumentsOpt, inferredType, this.HasErrors); 3489var result = new BoundMultipleLocalDeclarations(this.Syntax, localDeclarations, this.HasErrors); 3519var result = new BoundUsingLocalDeclarations(this.Syntax, patternDisposeInfoOpt, awaitOpt, localDeclarations, this.HasErrors); 3551var result = new BoundLocalFunctionStatement(this.Syntax, symbol, blockBody, expressionBody, this.HasErrors); 3582var result = new BoundNoOpStatement(this.Syntax, flavor, this.HasErrors); 3615var result = new BoundReturnStatement(this.Syntax, refKind, expressionOpt, @checked, this.HasErrors); 3643var result = new BoundYieldReturnStatement(this.Syntax, expression, this.HasErrors); 3685var result = new BoundThrowStatement(this.Syntax, expressionOpt, this.HasErrors); 3713var result = new BoundExpressionStatement(this.Syntax, expression, this.HasErrors); 3750var result = new BoundBreakStatement(this.Syntax, label, this.HasErrors); 3787var result = new BoundContinueStatement(this.Syntax, label, this.HasErrors); 3832var result = new BoundSwitchStatement(this.Syntax, expression, innerLocals, innerLocalFunctions, switchSections, reachabilityDecisionDag, defaultLabel, breakLabel, this.HasErrors); 3868var result = new BoundSwitchDispatch(this.Syntax, expression, cases, defaultLabel, lengthBasedStringSwitchDataOpt, this.HasErrors); 3901var result = new BoundIfStatement(this.Syntax, condition, consequence, alternativeOpt, this.HasErrors); 3981var result = new BoundDoStatement(this.Syntax, locals, condition, body, breakLabel, continueLabel, this.HasErrors); 4011var result = new BoundWhileStatement(this.Syntax, locals, condition, body, breakLabel, continueLabel, this.HasErrors); 4053var result = new BoundForStatement(this.Syntax, outerLocals, initializer, innerLocals, condition, increment, body, breakLabel, continueLabel, this.HasErrors); 4102var result = new BoundForEachStatement(this.Syntax, enumeratorInfoOpt, elementPlaceholder, elementConversion, iterationVariableType, iterationVariables, iterationErrorExpressionOpt, expression, deconstructionOpt, body, breakLabel, continueLabel, this.HasErrors); 4133var result = new BoundForEachDeconstructStep(this.Syntax, deconstructionAssignment, targetPlaceholder, this.HasErrors); 4172var result = new BoundUsingStatement(this.Syntax, locals, declarationsOpt, expressionOpt, body, awaitOpt, patternDisposeInfoOpt, this.HasErrors); 4206var result = new BoundFixedStatement(this.Syntax, locals, declarations, body, this.HasErrors); 4237var result = new BoundLockStatement(this.Syntax, argument, body, this.HasErrors); 4274var result = new BoundTryStatement(this.Syntax, tryBlock, catchBlocks, finallyBlockOpt, finallyLabelOpt, preferFaultHandler, this.HasErrors); 4315var result = new BoundCatchBlock(this.Syntax, locals, exceptionSourceOpt, exceptionTypeOpt, exceptionFilterPrologueOpt, exceptionFilterOpt, body, isSynthesizedAsyncCatchAll, this.HasErrors); 4346var result = new BoundLiteral(this.Syntax, constantValueOpt, type, this.HasErrors); 4386var result = new BoundUtf8String(this.Syntax, value, type, this.HasErrors); 4421var result = new BoundThisReference(this.Syntax, type, this.HasErrors); 4456var result = new BoundPreviousSubmissionReference(this.Syntax, type, this.HasErrors); 4491var result = new BoundHostObjectMemberReference(this.Syntax, type, this.HasErrors); 4520var result = new BoundBaseReference(this.Syntax, type, this.HasErrors); 4569var result = new BoundLocal(this.Syntax, localSymbol, declarationKind, constantValueOpt, isNullableUnknown, type, this.HasErrors); 4614var result = new BoundPseudoVariable(this.Syntax, localSymbol, emitExpressions, type, this.HasErrors); 4647var result = new BoundRangeVariable(this.Syntax, rangeVariableSymbol, value, type, this.HasErrors); 4687var result = new BoundParameter(this.Syntax, parameterSymbol, type, this.HasErrors); 4724var result = new BoundLabelStatement(this.Syntax, label, this.HasErrors); 4756var result = new BoundGotoStatement(this.Syntax, label, caseExpressionOpt, labelExpressionOpt, this.HasErrors); 4787var result = new BoundLabeledStatement(this.Syntax, label, body, this.HasErrors); 4824var result = new BoundLabel(this.Syntax, label, type, this.HasErrors); 4861var result = new BoundStatementList(this.Syntax, statements, this.HasErrors); 4894var result = new BoundConditionalGoto(this.Syntax, condition, jumpIfTrue, label, this.HasErrors); 4957var result = new BoundSwitchExpressionArm(this.Syntax, locals, pattern, whenClause, value, label, this.HasErrors); 4985var result = new BoundUnconvertedSwitchExpression(this.Syntax, expression, switchArms, reachabilityDecisionDag, defaultLabel, reportedNotExhaustive, type, this.HasErrors); 5019var result = new BoundConvertedSwitchExpression(this.Syntax, naturalTypeOpt, wasTargetTyped, expression, switchArms, reachabilityDecisionDag, defaultLabel, reportedNotExhaustive, type, this.HasErrors); 5047var result = new BoundDecisionDag(this.Syntax, rootNode, this.HasErrors); 5092var result = new BoundEvaluationDecisionDagNode(this.Syntax, evaluation, next, this.HasErrors); 5126var result = new BoundTestDecisionDagNode(this.Syntax, test, whenTrue, whenFalse, this.HasErrors); 5161var result = new BoundWhenDecisionDagNode(this.Syntax, bindings, whenExpression, whenTrue, whenFalse, this.HasErrors); 5198var result = new BoundLeafDecisionDagNode(this.Syntax, label, this.HasErrors); 5244var result = new BoundDagTemp(this.Syntax, type, source, index, this.HasErrors); 5273var result = new BoundDagTypeTest(this.Syntax, type, input, this.HasErrors); 5301var result = new BoundDagNonNullTest(this.Syntax, isExplicitTest, input, this.HasErrors); 5327var result = new BoundDagExplicitNullTest(this.Syntax, input, this.HasErrors); 5356var result = new BoundDagValueTest(this.Syntax, value, input, this.HasErrors); 5387var result = new BoundDagRelationalTest(this.Syntax, operatorKind, value, input, this.HasErrors); 5428var result = new BoundDagDeconstructEvaluation(this.Syntax, deconstructMethod, input, this.HasErrors); 5457var result = new BoundDagTypeEvaluation(this.Syntax, type, input, this.HasErrors); 5486var result = new BoundDagFieldEvaluation(this.Syntax, field, input, this.HasErrors); 5517var result = new BoundDagPropertyEvaluation(this.Syntax, property, isLengthOrCount, input, this.HasErrors); 5548var result = new BoundDagIndexEvaluation(this.Syntax, property, index, input, this.HasErrors); 5595var result = new BoundDagIndexerEvaluation(this.Syntax, indexerType, lengthTemp, index, indexerAccess, receiverPlaceholder, argumentPlaceholder, input, this.HasErrors); 5644var result = new BoundDagSliceEvaluation(this.Syntax, sliceType, lengthTemp, startIndex, endIndex, indexerAccess, receiverPlaceholder, argumentPlaceholder, input, this.HasErrors); 5673var result = new BoundDagAssignmentEvaluation(this.Syntax, target, input, this.HasErrors); 5705var result = new BoundSwitchSection(this.Syntax, locals, switchLabels, statements, this.HasErrors); 5738var result = new BoundSwitchLabel(this.Syntax, label, pattern, whenClause, this.HasErrors); 5780var result = new BoundSequencePointExpression(this.Syntax, expression, type, this.HasErrors); 5816var result = new BoundSequence(this.Syntax, locals, sideEffects, value, type, this.HasErrors); 5852var result = new BoundSpillSequence(this.Syntax, locals, sideEffects, value, type, this.HasErrors); 5891var result = new BoundDynamicMemberAccess(this.Syntax, receiver, typeArgumentsOpt, name, invoked, indexed, type, this.HasErrors); 5944var result = new BoundDynamicInvocation(this.Syntax, argumentNamesOpt, argumentRefKindsOpt, applicableMethods, expression, arguments, type, this.HasErrors); 5977var result = new BoundConditionalAccess(this.Syntax, receiver, accessExpression, type, this.HasErrors); 6018var result = new BoundLoweredConditionalAccess(this.Syntax, receiver, hasValueMethodOpt, whenNotNull, whenNullOpt, id, forceCopyOfNullableValueType, type, this.HasErrors); 6056var result = new BoundConditionalReceiver(this.Syntax, id, type, this.HasErrors); 6089var result = new BoundComplexConditionalReceiver(this.Syntax, valueTypeReceiver, referenceTypeReceiver, type, this.HasErrors); 6130var result = new BoundMethodGroup(this.Syntax, typeArgumentsOpt, name, methods, lookupSymbolOpt, lookupError, flags, functionType, receiverOpt, resultKind, this.HasErrors); 6158var result = new BoundPropertyGroup(this.Syntax, properties, receiverOpt, resultKind, this.HasErrors); 6217var result = new BoundCall(this.Syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning, method, arguments, argumentNamesOpt, argumentRefKindsOpt, isDelegateCall, expanded, invokedAsExtensionMethod, argsToParamsOpt, defaultArguments, resultKind, originalMethodsOpt, type, this.HasErrors); 6256var result = new BoundEventAssignmentOperator(this.Syntax, @event, isAddition, isDynamic, receiverOpt, argument, type, this.HasErrors); 6301var result = new BoundAttribute(this.Syntax, constructor, constructorArguments, constructorArgumentNamesOpt, constructorArgumentsToParamsOpt, constructorExpanded, constructorDefaultArguments, namedArguments, resultKind, type, this.HasErrors); 6339var result = new BoundUnconvertedObjectCreationExpression(this.Syntax, arguments, argumentNamesOpt, argumentRefKindsOpt, initializerOpt, binder, this.HasErrors); 6411var result = new BoundObjectCreationExpression(this.Syntax, constructor, constructorsGroup, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, constantValueOpt, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 6452var result = new BoundUnconvertedCollectionExpression(this.Syntax, elements, this.HasErrors); 6497var result = new BoundCollectionExpression(this.Syntax, collectionTypeKind, placeholder, collectionCreation, collectionBuilderMethod, collectionBuilderInvocationPlaceholder, collectionBuilderInvocationConversion, wasTargetTyped, unconvertedCollectionExpression, elements, type, this.HasErrors); 6525var result = new BoundCollectionExpressionSpreadExpressionPlaceholder(this.Syntax, type, this.HasErrors); 6565var result = new BoundCollectionExpressionSpreadElement(this.Syntax, expression, expressionPlaceholder, conversion, enumeratorInfoOpt, lengthOrCount, elementPlaceholder, iteratorBody, this.HasErrors); 6610var result = new BoundTupleLiteral(this.Syntax, arguments, argumentNamesOpt, inferredNamesOpt, type, this.HasErrors); 6640var result = new BoundConvertedTupleLiteral(this.Syntax, sourceTuple, wasTargetTyped, arguments, argumentNamesOpt, inferredNamesOpt, type, this.HasErrors); 6683var result = new BoundDynamicObjectCreationExpression(this.Syntax, name, arguments, argumentNamesOpt, argumentRefKindsOpt, initializerExpressionOpt, applicableMethods, wasTargetTyped, type, this.HasErrors); 6715var result = new BoundNoPiaObjectCreationExpression(this.Syntax, guidString, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 6762var result = new BoundObjectInitializerExpression(this.Syntax, placeholder, initializers, type, this.HasErrors); 6811var result = new BoundObjectInitializerMember(this.Syntax, memberSymbol, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, resultKind, accessorKind, receiverType, type, this.HasErrors); 6856var result = new BoundDynamicObjectInitializerMember(this.Syntax, memberName, receiverType, type, this.HasErrors); 6884var result = new BoundCollectionInitializerExpression(this.Syntax, placeholder, initializers, type, this.HasErrors); 6929var result = new BoundCollectionElementInitializer(this.Syntax, addMethod, arguments, implicitReceiverOpt, expanded, argsToParamsOpt, defaultArguments, invokedAsExtensionMethod, resultKind, type, this.HasErrors); 6961var result = new BoundDynamicCollectionElementInitializer(this.Syntax, applicableMethods, expression, arguments, type, this.HasErrors); 6996var result = new BoundImplicitReceiver(this.Syntax, type, this.HasErrors); 7032var result = new BoundAnonymousObjectCreationExpression(this.Syntax, constructor, arguments, declarations, type, this.HasErrors); 7072var result = new BoundAnonymousPropertyDeclaration(this.Syntax, property, type, this.HasErrors); 7102var result = new BoundNewT(this.Syntax, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 7138var result = new BoundDelegateCreationExpression(this.Syntax, argument, methodOpt, isExtensionMethod, wasTargetTyped, type, this.HasErrors); 7170var result = new BoundArrayCreation(this.Syntax, bounds, initializerOpt, type, this.HasErrors); 7201var result = new BoundArrayInitialization(this.Syntax, isInferred, initializers, this.HasErrors); 7247var result = new BoundStackAllocArrayCreation(this.Syntax, elementType, count, initializerOpt, type, this.HasErrors); 7276var result = new BoundConvertedStackAllocExpression(this.Syntax, elementType, count, initializerOpt, type, this.HasErrors); 7316var result = new BoundFieldAccess(this.Syntax, receiverOpt, fieldSymbol, constantValueOpt, resultKind, isByValue, isDeclaration, type, this.HasErrors); 7356var result = new BoundHoistedFieldAccess(this.Syntax, fieldSymbol, type, this.HasErrors); 7394var result = new BoundPropertyAccess(this.Syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning, propertySymbol, autoPropertyAccessorKind, resultKind, type, this.HasErrors); 7430var result = new BoundEventAccess(this.Syntax, receiverOpt, eventSymbol, isUsableAsField, resultKind, type, this.HasErrors); 7481var result = new BoundIndexerAccess(this.Syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, accessorKind, argsToParamsOpt, defaultArguments, originalIndexersOpt, type, this.HasErrors); 7530var result = new BoundImplicitIndexerAccess(this.Syntax, receiver, argument, lengthOrCountAccess, receiverPlaceholder, indexerOrSliceAccess, argumentPlaceholders, type, this.HasErrors); 7571var result = new BoundInlineArrayAccess(this.Syntax, expression, argument, isValue, getItemOrSliceHelper, type, this.HasErrors); 7611var result = new BoundDynamicIndexerAccess(this.Syntax, receiver, arguments, argumentNamesOpt, argumentRefKindsOpt, applicableIndexers, type, this.HasErrors); 7651var result = new BoundLambda(this.Syntax, unboundLambda, symbol, body, diagnostics, binder, type, this.HasErrors); 7695var result = new UnboundLambda(this.Syntax, data, functionType, withDependencies, this.HasErrors); 7736var result = new BoundQueryClause(this.Syntax, value, definedSymbol, operation, cast, binder, unoptimizedForm, type, this.HasErrors); 7762var result = new BoundTypeOrInstanceInitializers(this.Syntax, statements, this.HasErrors); 7799var result = new BoundNameOfOperator(this.Syntax, argument, constantValueOpt, type, this.HasErrors); 7841var result = new BoundUnconvertedInterpolatedString(this.Syntax, parts, constantValueOpt, type, this.HasErrors); 7869var result = new BoundInterpolatedString(this.Syntax, interpolationData, parts, constantValueOpt, type, this.HasErrors); 7897var result = new BoundInterpolatedStringHandlerPlaceholder(this.Syntax, type, this.HasErrors); 7935var result = new BoundInterpolatedStringArgumentPlaceholder(this.Syntax, argumentIndex, type, this.HasErrors); 7970var result = new BoundStringInsert(this.Syntax, value, alignment, format, isInterpolatedStringHandlerAppendCall, this.HasErrors); 8012var result = new BoundIsPatternExpression(this.Syntax, expression, pattern, isNegated, reachabilityDecisionDag, whenTrueLabel, whenFalseLabel, type, this.HasErrors); 8077var result = new BoundConstantPattern(this.Syntax, value, constantValue, inputType, narrowedType, this.HasErrors); 8117var result = new BoundDiscardPattern(this.Syntax, inputType, narrowedType, this.HasErrors); 8170var result = new BoundDeclarationPattern(this.Syntax, declaredType, isVar, variable, variableAccess, inputType, narrowedType, this.HasErrors); 8211var result = new BoundRecursivePattern(this.Syntax, declaredType, deconstructMethod, deconstruction, properties, isExplicitNotNullTest, variable, variableAccess, inputType, narrowedType, this.HasErrors); 8255var result = new BoundListPattern(this.Syntax, subpatterns, hasSlice, lengthAccess, indexerAccess, receiverPlaceholder, argumentPlaceholder, variable, variableAccess, inputType, narrowedType, this.HasErrors); 8294var result = new BoundSlicePattern(this.Syntax, pattern, indexerAccess, receiverPlaceholder, argumentPlaceholder, inputType, narrowedType, this.HasErrors); 8334var result = new BoundITuplePattern(this.Syntax, getLengthMethod, getItemMethod, subpatterns, inputType, narrowedType, this.HasErrors); 8376var result = new BoundPositionalSubpattern(this.Syntax, symbol, pattern, this.HasErrors); 8406var result = new BoundPropertySubpattern(this.Syntax, member, isLengthOrCount, pattern, this.HasErrors); 8438var result = new BoundPropertySubpatternMember(this.Syntax, receiver, symbol, type, this.HasErrors); 8474var result = new BoundTypePattern(this.Syntax, declaredType, isExplicitNotNullTest, inputType, narrowedType, this.HasErrors); 8513var result = new BoundBinaryPattern(this.Syntax, disjunction, left, right, inputType, narrowedType, this.HasErrors); 8547var result = new BoundNegatedPattern(this.Syntax, negated, inputType, narrowedType, this.HasErrors); 8586var result = new BoundRelationalPattern(this.Syntax, relation, value, constantValue, inputType, narrowedType, this.HasErrors); 8621var result = new BoundDiscardExpression(this.Syntax, nullableAnnotation, isInferred, type, this.HasErrors); 8649var result = new BoundThrowExpression(this.Syntax, expression, type, this.HasErrors); 8692var result = new OutVariablePendingInference(this.Syntax, variableSymbol, receiverOpt, this.HasErrors); 8718var result = new DeconstructionVariablePendingInference(this.Syntax, variableSymbol, receiverOpt, this.HasErrors); 8753var result = new OutDeconstructVarPendingInference(this.Syntax, variableSymbol, isDiscardExpression, this.HasErrors); 8789var result = new BoundNonConstructorMethodBody(this.Syntax, blockBody, expressionBody, this.HasErrors); 8819var result = new BoundConstructorMethodBody(this.Syntax, locals, initializer, blockBody, expressionBody, this.HasErrors); 8850var result = new BoundExpressionWithNullability(this.Syntax, expression, nullableAnnotation, type, this.HasErrors); 8885var result = new BoundWithExpression(this.Syntax, receiver, cloneMethod, initializerExpression, type, this.HasErrors);

129var factory = new SyntheticBoundNodeFactory(containingSymbol, statement.Syntax, compilationState, diagnostics); 174var tryStatementSyntax = node.Syntax; 608Debug.Assert(node.Syntax.IsKind(SyntaxKind.CatchClause)); 609var tryStatementSyntax = (TryStatementSyntax)node.Syntax.Parent; 826var newFrame = new AwaitFinallyFrame(_currentAwaitFinallyFrame, _analysis.Labels(statement), statement.Syntax);

277AddResumableState(_iteratorStateAllocator, node.Syntax, awaitId: default, out var stateNumber, out GeneratedLabelSymbol resumeLabel);

173var block = body.Syntax as BlockSyntax; 203body.Syntax, 377Debug.Assert(node.Syntax.IsKind(SyntaxKind.AwaitExpression) || node.WasCompilerGenerated); 379var awaiterTemp = F.SynthesizedLocal(getAwaiter.Type, syntax: node.Syntax, kind: SynthesizedLocalKind.Awaiter);

95return new BoundBadStatement(bodyWithAwaitLifted.Syntax, ImmutableArray.Create<BoundNode>(bodyWithAwaitLifted), hasErrors: true); 132return Binder.GetWellKnownTypeMember(F.Compilation, member, bag, body.Syntax.Location);

29var factory = new SyntheticBoundNodeFactory(method, node.Syntax, compilationState, diagnostics); 95_factory.Syntax = node.Syntax; 121node.Syntax.Location, 279if (TryReplaceWithProxy(node.LocalSymbol, node.Syntax, out BoundNode? replacement)) 290if (TryReplaceWithProxy(node.ParameterSymbol, node.Syntax, out BoundNode? replacement)) 307if (TryReplaceWithProxy(thisParameter, node.Syntax, out BoundNode? replacement))

110public override string ToString() => BoundNode.Syntax.GetText().ToString(); 463AddIfCaptured(node.Method.OriginalDefinition, node.Syntax); 475AddIfCaptured(method, node.Syntax); 483AddIfCaptured(node.ParameterSymbol, node.Syntax); 489AddIfCaptured(node.LocalSymbol, node.Syntax); 495AddIfCaptured(_topLevelMethod.ThisParameter, node.Syntax); 504AddIfCaptured(thisParam, node.Syntax); 582var function = new NestedFunction(functionSymbol, body.Syntax.GetReference());

306body = new BoundBlock(body.Syntax, _addedLocals.ToImmutableAndFree(), _addedStatements.ToImmutableAndFree()) { WasCompilerGenerated = true }; 372var syntax = scopeBoundNode.Syntax; 650result.Add(new BoundExpressionStatement(node.Syntax, (BoundExpression)(BoundNode)node)); 673SyntaxNode syntax = node.Syntax; 829return new BoundParameter(node.Syntax, replacementParameter, node.HasErrors); 849FramePointer(node.Syntax, (NamedTypeSymbol)node.Type)); 856: FramePointer(node.Syntax, _topLevelMethod.ContainingType); // technically, not the correct static type 1085node.Syntax, 1127syntax: node.Syntax, 1211return new BoundStatementList(node.Syntax, statements); 1250rewrittenExceptionSource.Syntax, 1263prologueBuilder.Add(new BoundExpressionStatement(p.Syntax, p) { WasCompilerGenerated = true }); 1270rewrittenFilterPrologue = new BoundStatementList(rewrittenFilter.Syntax, prologueBuilder.ToImmutableAndFree()); 1323return new BoundBlock(node.Syntax, newLocals.ToImmutableAndFree(), newStatements.ToImmutableAndFree(), node.HasErrors); 1347node.Syntax, 1355node.Syntax, 1374node.Syntax, 1405syntax: conversion.Syntax, 1440return new BoundNoOpStatement(node.Syntax, NoOpStatementFlavor.Default); 1655RemapLambdaOrLocalFunction(node.Syntax, node.Symbol, default(ImmutableArray<TypeWithAnnotations>), closureKind, ref referencedMethod, out receiver, out constructedFrame); 1666node.Syntax, 1684InLoopOrLambda(node.Syntax, lambdaScope.Syntax); 1689var F = new SyntheticBoundNodeFactory(_currentMethod, node.Syntax, CompilationState, Diagnostics);

117var r = new ExpressionLambdaRewriter(compilationState, typeMap, node.Syntax, recursionDepth, diagnostics); 121diagnostics.Add(ErrorCode.ERR_MissingPredefinedMember, node.Syntax.Location, r.ExpressionType, "Lambda"); 174_bound.Syntax = node.Syntax; 358return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 389return new BoundBadExpression(node.Syntax, 0, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 1141return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1148return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1180return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type);

61_diagnostics.Add(code, node.Syntax.Location, args); 278Binder.ReportDiagnosticsIfObsolete(_diagnostics, node.EventSymbol.AssociatedField, node.Syntax, hasBaseReceiver, _containingSymbol, _containingSymbol.ContainingType, BinderFlags.None); 292Binder.ReportDiagnosticsIfObsolete(_diagnostics, node.Event, ((AssignmentExpressionSyntax)node.Syntax).Left, hasBaseReceiver, _containingSymbol, _containingSymbol.ContainingType, BinderFlags.None); 635switch (node.Syntax.Kind()) 639var lambdaSyntax = (ParenthesizedLambdaExpressionSyntax)node.Syntax; 657var lambdaSyntax = (SimpleLambdaExpressionSyntax)node.Syntax;

38if (local.Syntax.Kind() == SyntaxKind.DeclarationExpression) 332_diagnostics.Add(ErrorCode.WRN_BadRefCompareLeft, node.Syntax.Location, t); 337_diagnostics.Add(ErrorCode.WRN_BadRefCompareRight, node.Syntax.Location, t);

68boundStatements.Add(new BoundReturnStatement(lastStatement.Syntax, RefKind.None, trailingExpression, @checked: false)); 84return (statement.Kind == BoundKind.ExpressionStatement) && ((ExpressionStatementSyntax)statement.Syntax).SemicolonToken.IsMissing ? 92SyntaxNode syntax = fieldInit.Syntax;

66methodBody.Syntax, 72methodBody.Syntax, 126_methodPayload = methodBodyFactory.SynthesizedLocal(_payloadType, kind: SynthesizedLocalKind.InstrumentationPayload, syntax: methodBody.Syntax); 128SyntaxNode syntax = MethodDeclarationIfAvailable(methodBody.Syntax); 279_methodBody.Syntax, 415returnStatement.ExpressionOpt.Syntax != null) 417Debug.Assert(returnStatement.ExpressionOpt.Syntax.Parent != null); 419SyntaxKind parentKind = returnStatement.ExpressionOpt.Syntax.Parent.Kind(); 440var whenClause = original.Syntax.FirstAncestorOrSelf<WhenClauseSyntax>(); 460if (!original.IsConstructorInitializer() || original.Syntax.Kind() != SyntaxKind.ConstructorDeclaration) 472SyntheticBoundNodeFactory statementFactory = new SyntheticBoundNodeFactory(_method, original.Syntax, _methodBodyFactory.CompilationState, _diagnostics); 530syntaxForSpan = ((BoundIfStatement)statement).Condition.Syntax; 533syntaxForSpan = ((BoundWhileStatement)statement).Condition.Syntax; 536syntaxForSpan = ((BoundForEachStatement)statement).Expression.Syntax; 539syntaxForSpan = ((BoundDoStatement)statement).Condition.Syntax; 544syntaxForSpan = ((BoundNode?)usingStatement.ExpressionOpt ?? usingStatement.DeclarationsOpt)!.Syntax; 548syntaxForSpan = ((BoundFixedStatement)statement).Declarations.Syntax; 551syntaxForSpan = ((BoundLockStatement)statement).Argument.Syntax; 554syntaxForSpan = ((BoundSwitchStatement)statement).Expression.Syntax; 557syntaxForSpan = statement.Syntax;

61switch (original.Syntax) 106throw ExceptionUtilities.UnexpectedValue(original.Syntax.Kind()); 109else if (original.Syntax is ParameterSyntax parameterSyntax) 121SyntaxNode syntax = original.Syntax; 172if (original.WasCompilerGenerated && original.Syntax.Kind() == SyntaxKind.Block) 175return new BoundSequencePointWithSpan(original.Syntax, rewritten, ((BlockSyntax)original.Syntax).CloseBraceToken.Span); 193if (original.Syntax is BlockSyntax blockSyntax && !original.WasCompilerGenerated) 195prologue = new BoundSequencePointWithSpan(original.Syntax, previousPrologue, blockSyntax.OpenBraceToken.Span); 199SyntaxNode? parent = original.Syntax.Parent; 202epilogue = new BoundSequencePointWithSpan(original.Syntax, previousEpilogue, blockSyntax.CloseBraceToken.Span); 215original.Syntax is RecordDeclarationSyntax { ParameterList.Parameters.Count: > 0 }) 231return AddConditionSequencePoint(base.InstrumentDoStatementCondition(original, rewrittenCondition, factory), original.Syntax, factory); 238return AddConditionSequencePoint(base.InstrumentWhileStatementCondition(original, rewrittenCondition, factory), original.Syntax, factory); 243var doSyntax = (DoStatementSyntax)original.Syntax; 253WhileStatementSyntax whileSyntax = (WhileStatementSyntax)original.Syntax; 271var forEachSyntax = (CommonForEachStatementSyntax)original.Syntax; 278var forEachSyntax = (ForEachVariableStatementSyntax)original.Syntax; 292var forEachSyntax = (CommonForEachStatementSyntax)original.Syntax; 314switch (original.Syntax.Kind()) 318var forEachSyntax = (ForEachStatementSyntax)original.Syntax; 324var forEachSyntax = (ForEachVariableStatementSyntax)original.Syntax; 329throw ExceptionUtilities.UnexpectedValue(original.Syntax.Kind()); 331return new BoundSequencePointWithSpan(original.Syntax, 339return BoundSequencePoint.Create(original.Condition?.Syntax, 345var syntax = (CommonForEachStatementSyntax)original.Syntax; 355return AddConditionSequencePoint(base.InstrumentForStatementCondition(original, rewrittenCondition, factory), original.Syntax, factory); 360var syntax = (IfStatementSyntax)original.Syntax; 374return AddConditionSequencePoint(base.InstrumentIfStatementCondition(original, rewrittenCondition, factory), original.Syntax, factory); 379var labeledSyntax = (LabeledStatementSyntax)original.Syntax; 388return AddSequencePoint(original.Syntax.Kind() == SyntaxKind.VariableDeclarator ? 389(VariableDeclaratorSyntax)original.Syntax : 390((LocalDeclarationStatementSyntax)original.Syntax).Declaration.Variables.First(), 396LockStatementSyntax lockSyntax = (LockStatementSyntax)original.Syntax; 406if (original.WasCompilerGenerated && original.ExpressionOpt == null && original.Syntax.Kind() == SyntaxKind.Block) 409return new BoundSequencePointWithSpan(original.Syntax, rewritten, ((BlockSyntax)original.Syntax).CloseBraceToken.Span); 412if (original.Syntax is ParameterSyntax parameterSyntax) 420return new BoundSequencePoint(original.Syntax, rewritten); 425SwitchStatementSyntax switchSyntax = (SwitchStatementSyntax)original.Syntax; 439WhenClauseSyntax? whenClause = original.Syntax.FirstAncestorOrSelf<WhenClauseSyntax>(); 450return AddSequencePoint((UsingStatementSyntax)original.Syntax, 480var filterClause = ((CatchClauseSyntax)original.Syntax).Filter; 490return AddConditionSequencePoint(base.InstrumentSwitchStatementExpression(original, rewrittenExpression, factory), original.Syntax, factory); 495return new BoundSequencePointExpression(original.Syntax, base.InstrumentSwitchExpressionArmExpression(original, rewrittenExpression, factory), rewrittenExpression.Type);

17return new BoundSequencePoint(node.Syntax, node); 191condition.Syntax,

50Debug.Assert(!original.WasCompilerGenerated || original.Syntax.Kind() == SyntaxKind.Block); 115Debug.Assert(original.Syntax.Kind() == SyntaxKind.DoStatement); 123Debug.Assert(original.Syntax.Kind() == SyntaxKind.WhileStatement); 131Debug.Assert(original.Syntax.Kind() == SyntaxKind.DoStatement); 138Debug.Assert(original.Syntax.Kind() == SyntaxKind.WhileStatement); 146Debug.Assert(original.Syntax is CommonForEachStatementSyntax); 152Debug.Assert(original.Syntax is CommonForEachStatementSyntax); 159Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForEachStatement); 166Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForEachVariableStatement); 173Debug.Assert(original.Syntax is CommonForEachStatementSyntax); 180Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForStatement); 187Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForStatement); 194Debug.Assert(original.Syntax.Kind() == SyntaxKind.IfStatement); 201Debug.Assert(original.Syntax.Kind() == SyntaxKind.IfStatement); 208Debug.Assert(original.Syntax.Kind() == SyntaxKind.LabeledStatement); 214Debug.Assert(original.Syntax.Kind() == SyntaxKind.VariableDeclarator || 215(original.Syntax.Kind() == SyntaxKind.LocalDeclarationStatement && 216((LocalDeclarationStatementSyntax)original.Syntax).Declaration.Variables.Count == 1)); 259Debug.Assert(original.Syntax.Kind() == SyntaxKind.LockStatement); 270Debug.Assert(original.Syntax.Kind() == SyntaxKind.SwitchStatement); 282Debug.Assert(original.Syntax.FirstAncestorOrSelf<WhenClauseSyntax>() != null); 289Debug.Assert(original.Syntax.Kind() == SyntaxKind.UsingStatement); 302Debug.Assert(original.Syntax.Kind() == SyntaxKind.CatchClause); 309Debug.Assert(original.Syntax.Kind() == SyntaxKind.SwitchStatement);

181var scope = new Scope(factory.SynthesizedLocal(contextType, methodBody.Syntax, kind: SynthesizedLocalKind.LocalStoreTracker)); 280_scope.Open(_factory.SynthesizedLocal(_contextType, original.Syntax, kind: SynthesizedLocalKind.LocalStoreTracker)); 398var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal, original.Syntax); 469var toStringMethod = GetSpecialMethodSymbol(SpecialMember.System_Object__ToString, value.Syntax); 532var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal: null, original.Syntax); 610var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal: null, invocation.Syntax);

156newBody = F.Instrument(F.SequencePoint(body.Syntax, HandleReturn(newBody)), instrumentation); 342AddResumableState(node.Syntax, awaitId: default, out StateMachineState stateNumber, out GeneratedLabelSymbol resumeLabel); 471var syntax = statement.Syntax;

142Binder.TryGetSpecialTypeMember(F.Compilation, member, body.Syntax, bag, out symbol); 148Binder.GetSpecialType(F.Compilation, type, body.Syntax, bag); 162Binder.Error(bag, ErrorCode.ERR_PropertyLacksGet, body.Syntax, symbol); 166bag.ReportUseSite(getter, body.Syntax.Location);

48_factory.Syntax = boundDelegateCreation.Syntax;

107var factory = new SyntheticBoundNodeFactory(method, statement.Syntax, compilationState, diagnostics, instrumentationState); 177return new BoundBadStatement(statement.Syntax, ImmutableArray.Create<BoundNode>(statement), hasErrors: true); 253var nameofIdentiferSyntax = (IdentifierNameSyntax)((InvocationExpressionSyntax)nameofOperator.Syntax).Expression; 266var result = MakeLiteral(node.Syntax, constantValue, type); 304visited.Syntax, 322var result = new BoundFieldAccess(node.Syntax, new BoundThisReference(node.Syntax, primaryCtor.ContainingType), field, ConstantValue.NotAvailable, LookupResultKind.Viable, node.Type); 347location = node.Syntax.Location; 582return BadExpression(node.Syntax, node.Type, ImmutableArray.Create(node)); 666tryGetResult = TryGetSpecialTypeMethod(node.Syntax, SpecialMember.System_Type__GetTypeFromHandle, out getTypeFromHandle); 670tryGetResult = TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Type__GetTypeFromHandle, out getTypeFromHandle); 675return new BoundTypeOfOperator(node.Syntax, sourceType, null, type, hasErrors: true); 692if (!TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Type__GetTypeFromHandle, out getTypeFromHandle)) 694return new BoundRefTypeOperator(node.Syntax, operand, null, type, hasErrors: true); 734statement.Syntax, 818return new BoundStatementList(node.Syntax, rewrittenStatements, node.HasErrors); 867var syntax = initializer.Syntax;

474_factory.Syntax = test.Syntax; 568return new ValueDispatchNode.LeafDispatchNode(node.Syntax, label); 573return new ValueDispatchNode.LeafDispatchNode(node.Syntax, label); 583return ValueDispatchNode.RelationalDispatch.CreateBalanced(testNode.Syntax, relational.Value, relational.OperatorKind, whenTrue: whenTrue, whenFalse: whenFalse); 604return PushEqualityTestsIntoTree(value.Syntax, otherwise, cases.ToImmutableAndFree(), fac); 609return new ValueDispatchNode.LeafDispatchNode(node.Syntax, label); 1071ArrayBuilder<BoundStatement> sectionBuilder = BuilderForSection(whenNode.Syntax); 1094var whenClauseSyntax = whenNodes[0].Syntax; 1097Debug.Assert(whenNodes.All(n => n.Syntax == whenClauseSyntax)); 1163ArrayBuilder<BoundStatement> sectionBuilder = BuilderForSection(whenClause.Syntax); 1171addConditionalGoto(whenClause.WhenExpression, whenClause.Syntax, trueLabel, sectionBuilder); 1208_factory.Syntax = node.Syntax;

143var outputTemp = new BoundDagTemp(f.Syntax, field.Type, f); 145BoundExpression access = _localRewriter.MakeFieldAccess(f.Syntax, input, field, null, LookupResultKind.Viable, field.Type); 153var outputTemp = new BoundDagTemp(p.Syntax, property.Type, p); 192var outputTemp = new BoundDagTemp(d.Syntax, parameter.Type, d, i - extensionExtra); 214var outputTemp = new BoundDagTemp(t.Syntax, type, t); 220_localRewriter._diagnostics.Add(t.Syntax, useSiteInfo); 226_localRewriter.TryGetNullableMethod(t.Syntax, inputType, SpecialMember.System_Nullable_T_GetValueOrDefault, out MethodSymbol getValueOrDefault)) 234evaluated = _localRewriter.MakeConversionNode(t.Syntax, input, conversion, type, @checked: false); 252var outputTemp = new BoundDagTemp(e.Syntax, type, e); 277var outputTemp = new BoundDagTemp(e.Syntax, e.IndexerType, e); 303var outputTemp = new BoundDagTemp(e.Syntax, e.SliceType, e); 335return new BoundRangeExpression(e.Syntax, makeUnloweredIndexArgument(e.StartIndex), end, 345_factory.Syntax = test.Syntax; 351return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullNotEqual : BinaryOperatorKind.NotEqual); 358return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullEqual : BinaryOperatorKind.Equal); 362return MakeValueTest(d.Syntax, input, d.Value); 367return MakeRelationalTest(d.Syntax, input, d.OperatorKind, d.Value); 487BoundExpression output = _tempAllocator.GetTemp(new BoundDagTemp(evaluation.Syntax, typeEvaluation1.Type, evaluation)); 503BoundExpression output = _tempAllocator.GetTemp(new BoundDagTemp(evaluation.Syntax, baseType, evaluation)); 506_localRewriter._diagnostics.Add(test.Syntax, useSiteInfo); 567loweredInput.Syntax.Kind() == SyntaxKind.TupleExpression && 632var originalInput = BoundDagTemp.ForOriginalInput(loweredInput.Syntax, loweredInput.Type); 639var fieldFetchEvaluation = new BoundDagFieldEvaluation(expr.Syntax, field, originalInput); 640var temp = new BoundDagTemp(expr.Syntax, expr.Type, fieldFetchEvaluation);

24syntax: node.Syntax,

22return MakeAsOperator(node, node.Syntax, rewrittenOperand, rewrittenTargetType, node.OperandPlaceholder, node.OperandConversion, rewrittenType);

49return VisitWindowsRuntimeEventFieldAssignmentOperator(node.Syntax, eventAccess, loweredRight); 84return MakeStaticAssignmentOperator(node.Syntax, loweredLeft, loweredRight, node.IsRef, used, AssignmentKind.SimpleAssignment); 130return RewriteWindowsRuntimeEventAssignmentOperator(eventAccess.Syntax, 160EmbedIfNeedTo(loweredReceiver, indexerAccess.ApplicableIndexers, indexerAccess.Syntax);

48var tempAccess = _factory.StoreToTemp(rewrittenAwait, out BoundAssignmentOperator tempAssignment, syntaxOpt: rewrittenAwait.Syntax, 51syntax: rewrittenAwait.Syntax,

71var syntax = node.Syntax; 120return LowerPartsToString(data, parts, node.Syntax, node.Type); 159loweredLeft = MakeBinaryOperator(original, original.Syntax, original.OperatorKind, loweredLeft, loweredRight, original.Type, original.LeftTruthOperatorMethod ?? original.BinaryOperatorMethod, original.ConstrainedToType, 209Debug.Assert(oldNode == null || (oldNode.Syntax == syntax)); 752_diagnostics.Add(loweredLeft.Syntax, useSiteInfo); 776_diagnostics.Add(loweredLeft.Syntax, useSiteInfo); 2154SyntaxNode rightSyntax = loweredRight.Syntax; 2233_factory.Syntax = loweredRight.Syntax;

58return new BoundBlock(node.Syntax, locals, node.LocalFunctions, node.HasUnsafeModifier, instrumentation, builder.ToImmutableAndFree(), node.HasErrors); 130? new BoundBlock(node.Syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty)

15BoundStatement result = new BoundGotoStatement(node.Syntax, node.Label, node.HasErrors);

51loweredReceiver = new BoundTypeExpression(node.Syntax, null, firstContainer); 58loweredReceiver = new BoundTypeExpression(node.Syntax, null, _factory.CurrentType); 67EmbedIfNeedTo(loweredReceiver, methodGroup.Methods, node.Syntax); 422var rewrittenCall = MakeCall(node, node.Syntax, rewrittenReceiver, method, rewrittenArguments, argRefKindsOpt, node.ResultKind, temps.ToImmutableAndFree()); 1023new BoundComplexConditionalReceiver(receiverTemp.Syntax, 1195optimized = CreateArrayEmptyCallIfAvailable(possibleParamsArray.Syntax, ((ArrayTypeSymbol)possibleParamsArray.Type!).ElementType); 1659value.Syntax, 1726argument.Syntax,

37_factory.Syntax = node.Syntax; 131new BoundExpressionStatement(iteratorBody.Syntax, iteratorBody)); 153if (!TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Linq_Enumerable__ToList, out MethodSymbol? toListGeneric, isOptional: true)) 321node.Syntax, 416var syntax = iteratorBody.Syntax; 433node.Syntax, 459var syntax = node.Syntax; 556node.Syntax, 793var syntax = node.Syntax; 872var expressionSyntax = rewrittenValue.Syntax; 1112sideEffects.Add(new BoundAssignmentOperator(rewrittenSpreadOperand.Syntax, indexTemp, _factory.Binary(BinaryOperatorKind.Addition, indexTemp.Type, indexTemp, spreadLength), isRef: false, indexTemp.Type)); 1233var expressionSyntax = rewrittenValue.Syntax; 1320node.Syntax, 1380var statements = builder.SelectAsArray(expr => (BoundStatement)new BoundExpressionStatement(expr.Syntax, expr)); 1385new BoundBlock(iteratorBody.Syntax, locals: ImmutableArray<LocalSymbol>.Empty, statements); 1464var iterationVariable = _factory.SynthesizedLocal(enumeratorInfo.ElementType, node.Syntax);

42SyntaxNode syntax = node.Syntax; 79return MakeInstanceCompoundAssignmentOperatorResult(node.Syntax, node.Left, node.Right, node.Operator.Method, node.Operator.Kind.IsChecked(), AssignmentKind.CompoundAssignment); 158rewrittenAssignment = new BoundSequence(node.Syntax, eventTemps.ToImmutableAndFree(), sequence.ToImmutableAndFree(), condition, condition.Type!); 169node.Syntax, 181SyntaxNode syntax = node.Syntax; 208operand = VisitCompoundAssignmentStringConcatenation(opLHS, right, node.Operator.Kind, node.Syntax); 365return new BoundDynamicMemberAccess(memberAccess.Syntax, receiverTemp, memberAccess.TypeArgumentsOpt, memberAccess.Name, memberAccess.Invoked, memberAccess.Indexed, memberAccess.Type); 442SyntaxNode syntax = indexerAccess.Syntax; 669indexerAccess.Syntax, 775return MakeFieldAccess(fieldAccess.Syntax, receiverOpt, fieldAccess.FieldSymbol, fieldAccess.ConstantValueOpt, fieldAccess.ResultKind, fieldAccess.Type, fieldAccess); 866return MakeEventAccess(eventAccess.Syntax, receiverOpt, eventAccess.EventSymbol, eventAccess.ConstantValueOpt, eventAccess.ResultKind, eventAccess.Type); 899rewrittenReceiver.Syntax,

85loweredReceiver.Syntax, 151node.Syntax, 154UnsafeGetNullableMethod(node.Syntax, loweredReceiver.Type, SpecialMember.System_Nullable_T_get_HasValue) : 180result = RewriteConditionalOperator(node.Syntax, 209newtarget = MakeOptimizedGetValueOrDefault(node.Syntax, newtarget);

33node.Syntax,

15BoundStatement result = new BoundGotoStatement(node.Syntax, node.Label, node.HasErrors);

34InterpolationHandlerResult interpolationResult = RewriteToInterpolatedStringHandlerPattern(data, parts, node.Operand.Syntax); 53return ConvertToNullable(node.Syntax, node.Type, objectCreation); 63return ConvertToNullable(node.Syntax, node.Type, rewrittenCollection); 79var result = MakeConversionNode(node, node.Syntax, rewrittenOperand, node.Conversion, node.Checked, node.ExplicitCastInCode, node.ConstantValueOpt, rewrittenType); 100_factory.Syntax = node.Syntax; 106BadExpression(node.Syntax, byteArray, ImmutableArray<BoundExpression>.Empty) : 107MakeUnderlyingArrayForUtf8Span(node.Syntax, byteArray, bytes, out length); 109if (!TryGetWellKnownTypeMember<MethodSymbol>(node.Syntax, WellKnownMember.System_ReadOnlySpan_T__ctor_Array_Start_Length, out MethodSymbol? ctor)) 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)); 133node.Syntax.Location, 306Debug.Assert(oldNodeOpt == null || oldNodeOpt.Syntax == syntax); 555return new BoundFunctionPointerLoad(oldNodeOpt.Syntax, symbolOpt, 569_factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax; 577EnsureParamCollectionAttributeExists(rewrittenOperand.Syntax, rewrittenType); 815return MakeConversionNode(rewrittenOperand.Syntax, rewrittenOperand, conversion, rewrittenType, @checked); 829diagnostics.Add(rewrittenOperand.Syntax, useSiteInfo); 840rewrittenOperand.Syntax.Location, 1030syntax: expression.Syntax, 1333seq.Syntax, 1337conditional.Syntax, 1401MethodSymbol ctor = UnsafeGetNullableMethod(call.Syntax, resultType, SpecialMember.System_Nullable_T__ctor); 1402return new BoundObjectCreationExpression(call.Syntax, ctor, call);

254effects.assignments.Add(MakeAssignmentOperator(resultPart.Syntax, leftTarget, resultPart, 266compilation: _compilation, shouldCheckConstraints: false, includeNullability: false, errorPositions: default, syntax: (CSharpSyntaxNode)right.Syntax, diagnostics: _diagnostics); 269right.Syntax, sourceTuple: null, wasTargetTyped: false, arguments: builder!.ToImmutableAndFree(), argumentNamesOpt: default, inferredNamesOpt: default, tupleType); 364var fieldAccess = MakeTupleFieldAccessAndReportUseSiteDiagnostics(tuple, expression.Syntax, fields[i]); 392var localBound = new BoundLocal(target.Syntax, localSymbol, constantValueOpt: null, type: outputPlaceholder.Type) 452assignmentTargets.Add(new Binder.DeconstructionVariable(variable, variable.Syntax)); 458assignmentTargets.Add(new Binder.DeconstructionVariable(GetAssignmentTargetsAndSideEffects(tuple, temps, effects), tuple.Syntax)); 465assignmentTargets.Add(new Binder.DeconstructionVariable(temp, variable.Syntax));

25return new BoundDelegateCreationExpression(node.Syntax, loweredReceiver, methodOpt: null, isExtensionMethod: false, node.WasTargetTyped, type: node.Type); 34_factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax;

24var syntax = node.Syntax;

37_diagnostics.Add(errorInfo, node.Syntax.Location); 51return RewriteWindowsRuntimeEventAssignmentOperator(node.Syntax, node.Event, kind, rewrittenReceiverOpt, rewrittenArgument); 59return MakeCall(node.Syntax, rewrittenReceiverOpt, method, rewrittenArguments); 216return MakeEventAccess(node.Syntax, rewrittenReceiver, node.EventSymbol, node.ConstantValueOpt, node.ResultKind, node.Type); 299_factory.Syntax = node.Syntax; 337module.EmbeddedTypesManagerOpt.EmbedEventIfNeedTo(node.Event.GetCciAdapter(), node.Syntax, _diagnostics.DiagnosticBag, isUsedForComAwareEventBinding: true); 345return new BoundBadExpression(node.Syntax, LookupResultKind.NotCreatable, ImmutableArray.Create<Symbol?>(node.Event),

18return RewriteExpressionStatement(node) ?? BoundStatementList.Synthesized(node.Syntax);

14return MakeFieldAccess(node.Syntax, rewrittenReceiver, node.FieldSymbol, node.ConstantValueOpt, node.ResultKind, node.Type, node);

83SyntaxNode? node = boundFixed.Syntax.Parent; 255VariableDeclaratorSyntax? declarator = fixedInitializer.Syntax.FirstAncestorOrSelf<VariableDeclaratorSyntax>(); 311var initializerSyntax = initializerExpr.Syntax; 316VariableDeclaratorSyntax? declarator = fixedInitializer.Syntax.FirstAncestorOrSelf<VariableDeclaratorSyntax>(); 448VariableDeclaratorSyntax? declarator = fixedInitializer.Syntax.FirstAncestorOrSelf<VariableDeclaratorSyntax>(); 478if (TryGetWellKnownTypeMember(fixedInitializer.Syntax, WellKnownMember.System_Runtime_CompilerServices_RuntimeHelpers__get_OffsetToStringData, out offsetMethod)) 484helperCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 539if (TryGetSpecialTypeMethod(fixedInitializer.Syntax, SpecialMember.System_Array__get_Length, out lengthMethod)) 545lengthCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(factory.Local(pinnedTemp)), ErrorTypeSymbol.UnknownResultType);

61else if (node.EnumeratorInfoOpt?.MoveNextAwaitableInfo is null && CanRewriteForEachAsFor(node.Syntax, nodeExpressionType, out var indexerGet, out var lengthGetter)) 152var forEachSyntax = (CSharpSyntaxNode)node.Syntax; 608var forEachSyntax = (CSharpSyntaxNode)node.Syntax; 621arrayVarDecl = new BoundStatementList(arrayVarDecl.Syntax, ImmutableArray.Create(collectionVarInitializationPreamble, arrayVarDecl)).MakeCompilerGenerated(); 821iterationVarDecl = new BoundExpressionStatement(assignment.Syntax, loweredAssignment); 898var forEachSyntax = (CSharpSyntaxNode)node.Syntax; 1047var forEachSyntax = (CSharpSyntaxNode)node.Syntax; 1278CommonForEachStatementSyntax forEachSyntax = (CommonForEachStatementSyntax)original.Syntax;

73SyntaxNode syntax = original.Syntax; 137branchBack = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel); 215SyntaxNode syntax = node.Syntax; 241BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, node.BreakLabel);

60rewrittenInvocation = new BoundSequence(rewrittenInvocation.Syntax, temps.ToImmutableAndFree(), sideEffects: ImmutableArray<BoundExpression>.Empty, rewrittenInvocation, node.Type);

17var syntax = node.Syntax;

56builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, afterif)); 78builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, alt)); 81var syntax = (IfStatementSyntax)node.Syntax; 102var syntax = (IfStatementSyntax)node.Syntax; 116return new BoundStatementList(node.Syntax, builder.ToImmutableAndFree(), node.HasErrors); 137builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, afterif));

18BoundExpression fromEnd = MakeLiteral(node.Syntax, ConstantValue.Create(true), booleanType); 24operand = new BoundDefaultExpression(operand.Syntax, operand.Type!.GetNullableUnderlyingType()); 31return new BoundObjectCreationExpression(node.Syntax, node.MethodOpt, operand, fromEnd); 39BoundExpression condition = MakeOptimizedHasValue(operand.Syntax, operand); 42BoundExpression boundOperandGetValueOrDefault = MakeOptimizedGetValueOrDefault(operand.Syntax, operand); 43BoundExpression indexCreation = new BoundObjectCreationExpression(node.Syntax, node.MethodOpt, boundOperandGetValueOrDefault, fromEnd); 46BoundExpression consequence = ConvertToNullable(node.Syntax, node.Type, indexCreation); 49BoundExpression alternative = new BoundDefaultExpression(node.Syntax, node.Type); 53syntax: node.Syntax, 62syntax: node.Syntax,

58EmbedIfNeedTo(loweredReceiver, node.ApplicableIndexers, node.Syntax); 88node.Syntax, 367createSpan = _factory.ModuleBuilderOpt.EnsureInlineArrayAsReadOnlySpanExists(node.Syntax, spanType, intType, _diagnostics.DiagnosticBag); 371createSpan = _factory.ModuleBuilderOpt.EnsureInlineArrayAsSpanExists(node.Syntax, spanType, intType, _diagnostics.DiagnosticBag); 393elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayFirstElementRefExists(node.Syntax, _diagnostics.DiagnosticBag); 398elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayFirstElementRefReadOnlyExists(node.Syntax, _diagnostics.DiagnosticBag); 412elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayElementRefExists(node.Syntax, intType, _diagnostics.DiagnosticBag); 417elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayElementRefReadOnlyExists(node.Syntax, intType, _diagnostics.DiagnosticBag);

22return MakeIsOperator(node, node.Syntax, rewrittenOperand, rewrittenTargetType, node.ConversionKind, rewrittenType); 40return RewriteConstantIsOperator(receiver.Syntax, receiver, ConstantValue.False, rewrittenType);

41var isPatternRewriter = new IsPatternExpressionGeneralLocalRewriter(node.Syntax, this); 111_factory.Syntax = node.Syntax; 120LocalSymbol resultTemp = _factory.SynthesizedLocal(node.Type, node.Syntax, kind: SynthesizedLocalKind.LoweringTemp); 159: base(node.Syntax, localRewriter, generateInstrumentation: false) 193_factory.Syntax = test.Syntax;

24BoundStatement labelStatement = new BoundLabelStatement(node.Syntax, node.Label); 28var labeledSyntax = node.Syntax as LabeledStatementSyntax; 42return BoundStatementList.Synthesized(node.Syntax, labelStatement, rewrittenBody);

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

16return RewriteLocalDeclaration(node, node.Syntax, node.LocalSymbol, VisitExpression(node.InitializerOpt), node.HasErrors); 76(originalOpt.Syntax.Kind() == SyntaxKind.VariableDeclarator || 77(originalOpt.Syntax.Kind() == SyntaxKind.LocalDeclarationStatement && 78((LocalDeclarationStatementSyntax)originalOpt.Syntax).Declaration.Variables.Count == 1)))

24LockStatementSyntax lockSyntax = (LockStatementSyntax)node.Syntax; 38rewrittenArgument.Syntax, 45if (LockBinder.TryFindLockTypeInfo(argumentType, _diagnostics, rewrittenArgument.Syntax) is not { } lockTypeInfo) 56rewrittenArgument.Syntax, 67var expressionStatement = new BoundExpressionStatement(rewrittenArgument.Syntax, tempAssignment); 70rewrittenArgument.Syntax, 71rewrittenArgument.Syntax, 91rewrittenArgument.Syntax, 145MakeLiteral(rewrittenArgument.Syntax, ConstantValue.False, boolType),

45return BoundStatementList.Synthesized(node.Syntax, node.HasErrors, inits.ToImmutableAndFree());

17SyntaxNode syntax = node.Syntax; 58var leftPlaceholder = new BoundValuePlaceholder(lhsRead.Syntax, lhsRead.Type); 84if (!TryGetNullableMethod(leftOperand.Syntax, 92if (!TryGetNullableMethod(leftOperand.Syntax, 116var tmp = _factory.StoreToTemp(BoundCall.Synthesized(leftOperand.Syntax, lhsRead, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault), 123var tmpAssignment = MakeAssignmentOperator(node.Syntax, tmp, loweredRight, used: true, isChecked: false, AssignmentKind.SimpleAssignment); 131node.Syntax, 139var lhsReadHasValue = BoundCall.Synthesized(leftOperand.Syntax, lhsRead, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, hasValue);

19return MakeNullCoalescingOperator(node.Syntax, rewrittenLeft, rewrittenRight, node.LeftPlaceholder, node.LeftConversion, node.OperatorResultKind, rewrittenResultType); 140TryGetNullableMethod(rewrittenLeft.Syntax, rewrittenLeft.Type, SpecialMember.System_Nullable_T_GetValueOrDefault, out MethodSymbol? getValueOrDefault, isOptional: true)) 142return BoundCall.Synthesized(rewrittenLeft.Syntax, rewrittenLeft, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault); 147TryGetNullableMethod(rewrittenLeft.Syntax, rewrittenLeft.Type, SpecialMember.System_Nullable_T_GetValueOrDefaultDefaultValue, out MethodSymbol? getValueOrDefaultDefaultValue, isOptional: true)) 149return BoundCall.Synthesized(rewrittenLeft.Syntax, rewrittenLeft, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefaultDefaultValue, rewrittenRight); 257MethodSymbol getValueOrDefault = UnsafeGetNullableMethod(rewrittenLeft.Syntax, rewrittenLeftType, SpecialMember.System_Nullable_T_GetValueOrDefault); 258rewrittenLeft = BoundCall.Synthesized(rewrittenLeft.Syntax, rewrittenLeft, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault);

21var constructorInvocation = _dynamicFactory.MakeDynamicConstructorInvocation(node.Syntax, node.Type, loweredArguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt).ToExpression(); 28return MakeExpressionWithInitializer(node.Syntax, constructorInvocation, node.InitializerExpressionOpt, node.Type); 99rewrittenObjectCreation = new BoundDefaultExpression(rewrittenObjectCreation.Syntax, rewrittenObjectCreation.Type!); 105node.Syntax, 128return MakeExpressionWithInitializer(node.Syntax, rewrittenObjectCreation, node.InitializerExpressionOpt, node.Type); 173return new BoundSequence(withExpr.Syntax, temps.ToImmutableAndFree(), sideEffects.ToImmutableAndFree(), value, type); 199withExpr.Syntax, 319var rewrittenNewT = MakeNewT(node.Syntax, (TypeParameterSymbol)node.Type); 325return MakeExpressionWithInitializer(node.Syntax, rewrittenNewT, node.InitializerExpressionOpt, rewrittenNewT.Type!); 382_factory.Syntax = node.Syntax; 394newGuid = new BoundBadExpression(node.Syntax, LookupResultKind.NotCreatable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 412callGetTypeFromCLSID = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 428rewrittenObjectCreation = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, node.Type); 438return MakeExpressionWithInitializer(node.Syntax, rewrittenObjectCreation, node.InitializerExpressionOpt, node.Type);

163EmbedIfNeedTo(rewrittenReceiver, initializer.ApplicableMethods, initializer.Syntax); 190var syntax = initializer.Syntax; 401result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, isRef: assignment.IsRef, used: false, AssignmentKind.SimpleAssignment)); 473result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, used: false, AssignmentKind.SimpleAssignment)); 506result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, used: false, AssignmentKind.SimpleAssignment)); 540result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, isRef: false, used: false, AssignmentKind.SimpleAssignment)); 712return MakeFieldAccess(rewrittenLeft.Syntax, rewrittenReceiver, fieldSymbol, null, rewrittenLeft.ResultKind, fieldSymbol.Type); 720rewrittenLeft.Syntax, 735rewrittenLeft.Syntax, 745return MakeEventAccess(rewrittenLeft.Syntax, rewrittenReceiver, eventSymbol, null, rewrittenLeft.ResultKind, eventSymbol.Type);

45SyntaxNode? section = d.Syntax.Parent; 65: base(node.Syntax, localRewriter, node.SwitchSections.SelectAsArray(section => section.Syntax), 73_factory.Syntax = node.Syntax; 132_factory.Syntax = section.Syntax; 134sectionBuilder.AddRange(switchSections[section.Syntax]); 159result.Add(new BoundScope(section.Syntax, section.Locals, statements)); 169_factory.Syntax = node.Syntax;

26return new BoundAddressOfOperator(receiver.Syntax, fieldAccess, isManaged: true, fieldAccess.Type); 38node.Syntax, 72node.Syntax, 74node.Syntax,

21var syntax = node.Syntax;

23return MakePropertyAccess(node.Syntax, rewrittenReceiverOpt, node.PropertySymbol, node.ResultKind, node.Type, isLeftOfAssignment, node);

46return ConvertToNullable(node.Syntax, node.Type, rangeCreation); 60operand = new BoundDefaultExpression(operand.Syntax, operand.Type.GetNullableUnderlyingType()); 95if (!TryGetNullableMethod(node.Syntax, node.Type, SpecialMember.System_Nullable_T__ctor, out MethodSymbol nullableCtor)) 97return BadExpression(node.Syntax, node.Type, node); 101BoundExpression consequence = new BoundObjectCreationExpression(node.Syntax, nullableCtor, rangeExpr); 104BoundExpression alternative = new BoundDefaultExpression(node.Syntax, node.Type); 110syntax: node.Syntax, 119syntax: node.Syntax, 135BoundExpression operandHasValue = MakeOptimizedHasValue(tempOperand.Syntax, tempOperand); 144condition = MakeBinaryOperator(node.Syntax, BinaryOperatorKind.BoolAnd, condition, operandHasValue, boolType, method: null, constrainedToTypeOpt: null); 147return MakeOptimizedGetValueOrDefault(tempOperand.Syntax, tempOperand);

29(node.Syntax.Kind() == SyntaxKind.Block && _factory.CurrentFunction?.IsAsync == false))))

48return new BoundConvertedStackAllocExpression(stackAllocNode.Syntax, elementType, stackSize, initializerOpt, type); 58stackAllocNode.Syntax, elementType, stackSize, initializerOpt, _compilation.CreatePointerTypeSymbol(elementType)); 61if (TryGetWellKnownTypeMember(stackAllocNode.Syntax, WellKnownMember.System_Span_T__ctor_Pointer, out MethodSymbol? spanConstructor)) 68syntax: stackAllocNode.Syntax, 81var tempAccess = _factory.StoreToTemp(constructorCall, out BoundAssignmentOperator tempAssignment, syntaxOpt: stackAllocNode.Syntax); 85syntax: stackAllocNode.Syntax,

60return CreateStringConcat(originalOperator.Syntax, arguments); 531arg.Syntax, 544arg.Syntax, 554args[i] = BoundCall.Synthesized(arg.Syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, stringImplicitConversionToReadOnlySpan, arg); 607var method = UnsafeGetSpecialTypeMethod(current.Syntax, member); 610currentResult = new BoundBinaryOperator(current.Syntax, current.OperatorKind, constantValueOpt: null, method, constrainedToTypeOpt: null, default(LookupResultKind), currentResult, right, current.Type); 623var syntax = expr.Syntax;

149return LowerPartsToString(data, node.Parts, node.Syntax, node.Type); 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 };

30: base(node.Syntax, localRewriter, node.SwitchArms.SelectAsArray(arm => arm.Syntax), 48_factory.Syntax = node.Syntax; 73var syntax = (SwitchExpressionSyntax)node.Syntax; 79result.Add(new BoundStepThroughSequencePoint(node.Syntax, span: spanForSwitchBody)); 89LocalSymbol resultTemp = _factory.SynthesizedLocal(node.Type, node.Syntax, kind: SynthesizedLocalKind.LoweringTemp); 93_factory.Syntax = arm.Syntax; 95sectionBuilder.AddRange(switchSections[arm.Syntax]); 116result.Add(new BoundScope(arm.Syntax, arm.Locals, statements)); 120_factory.Syntax = node.Syntax; 125result.Add(new BoundRestorePreviousSequencePoint(node.Syntax, restorePointForSwitchBody)); 149result.Add(new BoundRestorePreviousSequencePoint(node.Syntax, restorePointForEnclosingStatement));

71syntax: expr.Syntax, 85tuple.Syntax, sourceTuple: null, wasTargetTyped: true, newArguments, ImmutableArray<string?>.Empty, 107var syntax = boundConversion.Syntax; 165tuple.Syntax, sourceTuple: null, wasTargetTyped: false, newArguments, ImmutableArray<string?>.Empty, 209return new BoundLiteral(expr.Syntax, ConstantValue.Null, expr.Type); 217syntax: expr.Syntax, operand: deferredOperand, 264return new BoundLiteral(left.Syntax, ConstantValue.Create(nullnull.Kind == BinaryOperatorKind.Equal), boolType); 347_factory.Conditional(leftHasValue, innerSequence, MakeBooleanConstant(right.Syntax, boolValue), boolType), 348MakeBooleanConstant(right.Syntax, !boolValue), 364hasValue = MakeBooleanConstant(expr.Syntax, true); 374hasValue = MakeBooleanConstant(expr.Syntax, false); 376value = new BoundDefaultExpression(expr.Syntax, expr.Type.StrippedType()); 383hasValue = MakeBooleanConstant(expr.Syntax, true); 416return _factory.MakeNullableHasValue(expr.Syntax, expr); 460syntax: operand.Syntax, 472BoundExpression valueOrDefaultCall = MakeOptimizedGetValueOrDefault(expr.Syntax, expr); 480expr.Syntax, expr, conversion, enclosing.Checked, enclosing.ExplicitCastInCode, 535return MakeTupleFieldAccessAndReportUseSiteDiagnostics(tuple, tuple.Syntax, tuple.Type.TupleElements[i]); 563return _factory.Not(MakeUnaryOperator(UnaryOperatorKind.DynamicFalse, left.Syntax, method: null, constrainedToTypeOpt: null, dynamicResult, boolType)); 567return MakeUnaryOperator(UnaryOperatorKind.DynamicTrue, left.Syntax, method: null, constrainedToTypeOpt: null, dynamicResult, boolType); 574return new BoundLiteral(left.Syntax, ConstantValue.Create(operatorKind == BinaryOperatorKind.Equal), boolType); 589result = MakeUnaryOperator(boolOperator.Kind, binary.Syntax, boolOperator.Method, boolOperator.ConstrainedToTypeOpt, convertedBinary, boolType); 615oldNodeOpt: conv, syntax: conv.Syntax, rewrittenOperand: LowerConversions(conv.Operand),

40return MakeTupleCreationExpression(node.Syntax, (NamedTypeSymbol)node.Type, rewrittenArguments);

60return MakeUnaryOperator(node, node.OperatorKind, node.Syntax, node.MethodOpt, node.ConstrainedToTypeOpt, loweredOperand, node.Type); 162return MakeConversionNode(newNode.Syntax, newNode, Conversion.ExplicitEnumeration, type, @checked: false); 410SyntaxNode syntax = node.Syntax; 453return MakeInstanceCompoundAssignmentOperatorResult(node.Syntax, node.Operand, rightOpt: null, node.MethodOpt, node.OperatorKind.IsChecked(), AssignmentKind.IncrementDecrement); 581SyntaxNode syntax = node.Syntax; 797SyntaxNode syntax = node.Syntax; 834BoundExpression condition = _factory.MakeNullableHasValue(node.Syntax, boundTemp); 907syntax: node.Syntax, 914MethodSymbol ctor = UnsafeGetNullableMethod(node.Syntax, binaryOperandType, SpecialMember.System_Nullable_T__ctor); 915boundOne = new BoundObjectCreationExpression(node.Syntax, ctor, boundOne); 933return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null, constrainedToTypeOpt: null); 948binOp = MakeDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand); 952binOp = MakeLiftedDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand); 956binOp = MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperandType, method: null, constrainedToTypeOpt: null); 1025return MakePropertyGetAccess(transformedExpression.Syntax, propertyAccess.ReceiverOpt, propertyAccess.PropertySymbol, propertyAccess); 1033return MakePropertyGetAccess(transformedExpression.Syntax, indexerAccess.ReceiverOpt, indexerAccess.Indexer, indexerAccess.Arguments, indexerAccess.ArgumentRefKindsOpt);

42: BoundBlock.SynthesizedNoLocals(node.Syntax, rewrittenBody); 51SyntaxToken awaitKeyword = node.Syntax.Kind() == SyntaxKind.UsingStatement ? ((UsingStatementSyntax)node.Syntax).AwaitKeyword : default; 52return MakeDeclarationUsingStatement(node.Syntax, 91LocalDeclarationStatementSyntax syntax = (LocalDeclarationStatementSyntax)usingDeclarations.Syntax; 151SyntaxNode expressionSyntax = rewrittenExpression.Syntax; 152UsingStatementSyntax usingSyntax = (UsingStatementSyntax)node.Syntax; 215SyntaxNode declarationSyntax = localDeclaration.Syntax;

65SyntaxNode syntax = loop.Syntax; 67BoundStatement ifConditionGotoStart = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel); 136SyntaxNode syntax = loop.Syntax; 138BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, breakLabel);

21(!node.WasCompilerGenerated || (node.Syntax.Kind() == SyntaxKind.Block && _factory.CurrentFunction?.IsAsync == false)))

55var bad = new BoundBadExpression(children[0].Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, children, resultType);

80_factory.Syntax = loweredOperand.Syntax; 122_factory.Syntax = loweredOperand.Syntax; 160_factory.Syntax = loweredLeft.Syntax; 204_factory.Syntax = loweredReceiver.Syntax; 267_factory.Syntax = loweredReceiver.Syntax; 303_factory.Syntax = loweredReceiver.Syntax; 365_factory.Syntax = loweredReceiver.Syntax; 402_factory.Syntax = loweredReceiver.Syntax; 442_factory.Syntax = loweredReceiver.Syntax; 503_factory.Syntax = loweredReceiver.Syntax;

113rewrittenMethodSymbol = GetMethodWrapperForBaseNonVirtualCall(rewrittenMethodSymbol, node.Syntax); 200if (TryReplaceWithProxy(node.ParameterSymbol, node.Syntax, out BoundNode? replacement)) 216if (TryReplaceWithProxy(node.LocalSymbol, node.Syntax, out BoundNode? replacement)) 302SyntheticBoundNodeFactory factory = new SyntheticBoundNodeFactory(this.CurrentMethod, rewrittenLeft.Syntax, this.CompilationState, this.Diagnostics); 310node.Syntax, 346method = GetMethodWrapperForBaseNonVirtualCall(method, originalArgument.Syntax);

84var result = new BoundSpillSequenceBuilder(this.Syntax, value); 162AddStatement(new BoundExpressionStatement(expression.Syntax, expression) { WasCompilerGenerated = true }); 236var spiller = new SpillSequenceSpiller(method, body.Syntax, compilationState, tempSubstitution, receiverSubstitution, diagnostics); 296var result = new BoundBlock(statement.Syntax, builder.GetLocals(), builder.GetStatements()) { WasCompilerGenerated = true }; 309if (builder.Syntax != null) 310_F.Syntax = builder.Syntax; 627builder = new BoundSpillSequenceBuilder(lastSpill < newList.Length ? (newList[lastSpill] as BoundSpillSequenceBuilder)?.Syntax : null); 730exceptionFilterPrologueOpt = new BoundStatementList(node.Syntax, builder.GetStatements()); 762var builder = new BoundSpillSequenceBuilder(node.Syntax); 765_F.Syntax = node.Syntax; 800builder = new BoundSpillSequenceBuilder(indicesBuilder.Syntax); 828var boundsBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 881var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1004var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1042var receiverBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1067_F.Syntax = node.Syntax; 1071receiverBuilder.AddStatement(_F.ExpressionStatement(new BoundComplexConditionalReceiver(node.Syntax, cache, _F.Sequence(new[] { _F.AssignmentExpression(cache, receiver) }, cache), receiverType) { WasCompilerGenerated = true })); 1107var invokedExpressionBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1133if (conditionBuilder == null) conditionBuilder = new BoundSpillSequenceBuilder((consequenceBuilder ?? alternativeBuilder).Syntax); 1134if (consequenceBuilder == null) consequenceBuilder = new BoundSpillSequenceBuilder(alternativeBuilder.Syntax); 1135if (alternativeBuilder == null) alternativeBuilder = new BoundSpillSequenceBuilder(consequenceBuilder.Syntax); 1259var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1294if (receiverBuilder == null) receiverBuilder = new BoundSpillSequenceBuilder((whenNotNullBuilder ?? whenNullBuilder).Syntax); 1295if (whenNotNullBuilder == null) whenNotNullBuilder = new BoundSpillSequenceBuilder(whenNullBuilder.Syntax); 1296if (whenNullBuilder == null) whenNullBuilder = new BoundSpillSequenceBuilder(whenNotNullBuilder.Syntax); 1444var expressionBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1477builder = new BoundSpillSequenceBuilder(valueBuilder.Syntax);

75walker.CaptureVariable(method.ThisParameter, node.Syntax); 239CaptureRefInitializer(variableInitializer, local.SynthesizedKind != SynthesizedLocalKind.UserDefined ? variableInitializer.Syntax : syntax); 310CaptureVariable(node.ParameterSymbol, node.Syntax); 319CaptureVariable(thisSymbol, node.Syntax); 327CaptureVariable(topLevelMethod.ThisParameter, node.Syntax); 333CaptureVariable(topLevelMethod.ThisParameter, node.Syntax); 421Capture(_topLevelMethod.ThisParameter, node.Syntax); 427Capture(_topLevelMethod.ThisParameter, node.Syntax); 433Capture(node.LocalSymbol, node.Syntax); 439Capture(node.ParameterSymbol, node.Syntax);

518F.Syntax = node.Syntax; 572translated = new BoundStatementList(node.Syntax, statements);

62this.F = new SyntheticBoundNodeFactory(method, body.Syntax, compilationState, diagnostics); 64Debug.Assert(F.Syntax == body.Syntax);

519innerInstrumentation.Syntax, 1248return new BoundThrowExpression(thrown.Syntax, thrown, type) { WasCompilerGenerated = true }; 1637return new BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.BoolLogicalNegation, expression, null, null, constrainedToTypeOpt: null, LookupResultKind.Viable, expression.Type); 1689var syntax = argument.Syntax; 1737return new BoundLocal(node.Syntax, temp, constantValueOpt: null, type: node.Type) { WasCompilerGenerated = true };

325return new NoneOperation(children, _semanticModel, boundNode.Syntax, type: type, constantValue, isImplicit: isImplicit); 357boundNode.Syntax, 369boundNode.Syntax, 411builder.Add((IVariableDeclaratorOperation)CreateVariableDeclaratorInternal(decl, decl.Syntax)); 422SyntaxNode syntax = boundDeconstructValuePlaceholder.Syntax; 434SyntaxNode syntax = boundDeconstructionAssignmentOperator.Syntax; 443SyntaxNode syntax = boundCall.Syntax; 475SyntaxNode syntax = boundFunctionPointerInvocation.Syntax; 494boundUnconvertedAddressOf.Syntax, 504var invalidOperation = OperationFactory.CreateInvalidOperation(_semanticModel, boundAttribute.Syntax, GetIOperationChildren(boundAttribute), isImplicit: true); 505return new AttributeOperation(invalidOperation, _semanticModel, boundAttribute.Syntax, isAttributeImplicit); 512initializer = new ObjectOrCollectionInitializerOperation(namedArguments, _semanticModel, boundAttribute.Syntax, boundAttribute.GetPublicTypeSymbol(), isImplicit: true); 516var objectCreationOperation = new ObjectCreationOperation(boundAttribute.Constructor.GetPublicSymbol(), initializer, DeriveArguments(boundAttribute), _semanticModel, boundAttribute.Syntax, boundAttribute.GetPublicTypeSymbol(), boundAttribute.ConstantValueOpt, isImplicit: true); 517return new AttributeOperation(objectCreationOperation, _semanticModel, boundAttribute.Syntax, isAttributeImplicit); 556SyntaxNode syntax = boundLocal.Syntax; 576SyntaxNode syntax = boundFieldAccess.Syntax; 604CreateImplicitReceiver(boundObjectInitializerMember.Syntax, boundObjectInitializerMember.ReceiverType); 617SyntaxNode syntax = boundPropertyAccess.Syntax; 627SyntaxNode syntax = boundIndexerAccess.Syntax; 647SyntaxNode syntax = boundEventAccess.Syntax; 658SyntaxNode syntax = boundEventAssignmentOperator.Syntax; 668SyntaxNode syntax = boundParameter.Syntax; 676SyntaxNode syntax = boundLiteral.Syntax; 685SyntaxNode syntax = boundNode.Syntax; 693SyntaxNode syntax = boundAnonymousObjectCreationExpression.Syntax; 704SyntaxNode syntax = boundObjectCreationExpression.Syntax; 741SyntaxNode syntax = boundWithExpression.Syntax; 753SyntaxNode syntax = boundDynamicObjectCreationExpression.Syntax; 765implicitReceiver.Syntax, type: null, isImplicit: true); 769methodGroup.Syntax, methodGroup.GetPublicTypeSymbol(), methodGroup.WasCompilerGenerated); 782SyntaxNode syntax = boundDynamicInvocation.Syntax; 796return CreateImplicitReceiver(boundObjectInitializerMember.Syntax, boundObjectInitializerMember.ReceiverType); 825SyntaxNode syntax = boundDynamicIndexerAccess.Syntax; 834SyntaxNode syntax = boundObjectInitializerExpression.Syntax; 843SyntaxNode syntax = boundCollectionInitializerExpression.Syntax; 852SyntaxNode syntax = boundObjectInitializerMember.Syntax; 907CreateImplicitReceiver(boundObjectInitializerMember.Syntax, boundObjectInitializerMember.ReceiverType); 912IOperation instanceReceiver = CreateImplicitReceiver(boundDynamicObjectInitializerMember.Syntax, boundDynamicObjectInitializerMember.ReceiverType); 916SyntaxNode syntax = boundDynamicObjectInitializerMember.Syntax; 928SyntaxNode syntax = boundCollectionElementInitializer.Syntax; 946boundDynamicMemberAccess.Syntax, boundDynamicMemberAccess.GetPublicTypeSymbol(), boundDynamicMemberAccess.WasCompilerGenerated); 978SyntaxNode syntax = boundCollectionElementInitializer.Syntax; 998SyntaxNode syntax = boundLambda.Syntax; 1010SyntaxNode syntax = boundLocalFunctionStatement.Syntax; 1030SyntaxNode syntax = boundConversion.Syntax; 1058SyntaxNode syntax = boundConversion.Syntax; 1080if (boundOperand.Syntax == boundConversion.Syntax) 1101if (nestedConversion.Syntax == nestedOperand.Syntax && nestedConversion.ExplicitCastInCode && 1142SyntaxNode syntax = boundAsOperator.Syntax; 1154SyntaxNode syntax = boundDelegateCreationExpression.Syntax; 1165SyntaxNode bindingSyntax = boundMethodGroup.Syntax; 1176SyntaxNode syntax = boundIsOperator.Syntax; 1187SyntaxNode syntax = boundSizeOfOperator.Syntax; 1198SyntaxNode syntax = boundTypeOfOperator.Syntax; 1208SyntaxNode syntax = boundArrayCreation.Syntax; 1211(boundArrayCreation.InitializerOpt?.Syntax == syntax && !boundArrayCreation.InitializerOpt.WasCompilerGenerated); 1218SyntaxNode syntax = boundArrayInitialization.Syntax; 1225SyntaxNode syntax = expr.Syntax; 1271SyntaxNode syntax = element.Syntax; 1286SyntaxNode syntax = boundDefaultLiteral.Syntax; 1294SyntaxNode syntax = boundDefaultExpression.Syntax; 1304SyntaxNode syntax = boundBaseReference.Syntax; 1313SyntaxNode syntax = boundThisReference.Syntax; 1337SyntaxNode syntax = boundAssignmentOperator.Syntax; 1349SyntaxNode syntax = boundAssignmentOperator.Syntax; 1366SyntaxNode syntax = boundCompoundAssignmentOperator.Syntax; 1393SyntaxNode syntax = boundIncrementOperator.Syntax; 1403SyntaxNode syntax = boundBadExpression.Syntax; 1408bool isImplicit = boundBadExpression.WasCompilerGenerated || boundBadExpression.ChildBoundNodes.Any(static (e, boundBadExpression) => e?.Syntax == boundBadExpression.Syntax, boundBadExpression); 1416SyntaxNode syntax = boundNewT.Syntax; 1425SyntaxNode syntax = creation.Syntax; 1436SyntaxNode syntax = boundUnaryOperator.Syntax; 1490SyntaxNode syntax = boundBinaryOperator.Syntax; 1513SyntaxNode syntax = boundBinaryOperator.Syntax; 1557SyntaxNode syntax = boundTupleBinaryOperator.Syntax; 1569SyntaxNode syntax = boundConditionalOperator.Syntax; 1580SyntaxNode syntax = boundNullCoalescingOperator.Syntax; 1599SyntaxNode syntax = boundNode.Syntax; 1609SyntaxNode syntax = boundAwaitExpression.Syntax; 1619SyntaxNode syntax = boundArrayAccess.Syntax; 1630SyntaxNode syntax = boundIndexerAccess.Syntax; 1652SyntaxNode syntax = boundInlineArrayAccess.Syntax; 1662SyntaxNode syntax = boundNameOfOperator.Syntax; 1672SyntaxNode syntax = boundThrowExpression.Syntax; 1681SyntaxNode syntax = boundAddressOfOperator.Syntax; 1690SyntaxNode syntax = boundImplicitReceiver.Syntax; 1700SyntaxNode syntax = boundConditionalAccess.Syntax; 1709SyntaxNode syntax = boundConditionalReceiver.Syntax; 1719SyntaxNode syntax = boundFieldEqualsValue.Syntax; 1728SyntaxNode syntax = boundPropertyEqualsValue.Syntax; 1737SyntaxNode syntax = boundParameterEqualsValue.Syntax; 1746SyntaxNode syntax = boundBlock.Syntax; 1755SyntaxNode syntax = boundContinueStatement.Syntax; 1764SyntaxNode syntax = boundBreakStatement.Syntax; 1772SyntaxNode syntax = boundYieldBreakStatement.Syntax; 1781SyntaxNode syntax = boundGotoStatement.Syntax; 1788SyntaxNode syntax = boundNoOpStatement.Syntax; 1822SyntaxNode syntax = boundIfStatement.Syntax; 1844SyntaxNode syntax = boundWhileStatement.Syntax; 1858SyntaxNode syntax = boundDoStatement.Syntax; 1873SyntaxNode syntax = boundForStatement.Syntax; 1959var declaratorSyntax = boundForEachStatement.IterationVariableType.Syntax; 1980SyntaxNode syntax = boundForEachStatement.Syntax; 1991SyntaxNode syntax = boundTryStatement.Syntax; 2005SyntaxNode syntax = boundCatchBlock.Syntax; 2015SyntaxNode syntax = boundFixedStatement.Syntax; 2033SyntaxNode syntax = boundUsingStatement.Syntax; 2041SyntaxNode syntax = boundThrowStatement.Syntax; 2050SyntaxNode syntax = boundReturnStatement.Syntax; 2058SyntaxNode syntax = boundYieldReturnStatement.Syntax; 2068legacyMode ? null : new SynthesizedLocal((_semanticModel.GetEnclosingSymbol(boundLockStatement.Syntax.SpanStart) as IMethodSymbol).GetSymbol(), 2071syntaxOpt: boundLockStatement.Argument.Syntax).GetPublicSymbol(); 2074SyntaxNode syntax = boundLockStatement.Syntax; 2082SyntaxNode syntax = boundBadStatement.Syntax; 2085bool isImplicit = boundBadStatement.WasCompilerGenerated || boundBadStatement.ChildBoundNodes.Any(static (e, boundBadStatement) => e?.Syntax == boundBadStatement.Syntax, boundBadStatement); 2092var node = boundLocalDeclaration.Syntax; 2146SyntaxNode declarationGroupSyntax = boundMultipleLocalDeclarations.Syntax; 2183SyntaxNode syntax = boundLabelStatement.Syntax; 2192SyntaxNode syntax = boundLabeledStatement.Syntax; 2202bool isImplicit = boundExpressionStatement.WasCompilerGenerated || boundExpressionStatement.Syntax == boundExpressionStatement.Expression.Syntax; 2203SyntaxNode syntax = boundExpressionStatement.Syntax; 2210Debug.Assert(boundExpressionStatement.Syntax == sequence.Value.Syntax); 2219SyntaxNode syntax = boundTupleExpression.Syntax; 2255SyntaxNode syntax = boundInterpolatedString.Syntax; 2352builder.Add(new InterpolatedStringTextOperation(valueOperation, _semanticModel, part.Syntax, isImplicit)); 2360Debug.Assert(valueOperation.Syntax != part.Syntax); 2362builder.Add(new InterpolationOperation(valueOperation, alignmentOperation, formatOperation, _semanticModel, part.Syntax, isImplicit)); 2395SyntaxNode syntax = boundStringInsert.Syntax; 2403SyntaxNode syntax = boundNode.Syntax; 2422conversion.Syntax, 2433return new InterpolatedStringAdditionOperation(left, right, _semanticModel, current.Syntax, current.WasCompilerGenerated); 2455return new InterpolatedStringAppendOperation(@this.Create(part), operationKind, @this._semanticModel, part.Syntax, isImplicit: true); 2461interpolatedString.Syntax, 2474SyntaxNode syntax = placeholder.Syntax; 2501placeholder.Syntax, 2509SyntaxNode syntax = boundConstantPattern.Syntax; 2520SyntaxNode syntax = boundRelationalPattern.Syntax; 2539SyntaxNode syntax = boundDeclarationPattern.Syntax; 2562boundRecursivePattern.Syntax, 2581boundITuplePattern.Syntax, 2592syntax: boundTypePattern.Syntax, 2605boundNode.Syntax, 2619boundNode.Syntax, 2630boundNegatedPattern.Syntax, 2670boundBinaryPattern.Syntax, 2681SyntaxNode syntax = boundSwitchStatement.Syntax; 2692return new SwitchCaseOperation(clauses, body, locals, condition: null, _semanticModel, boundSwitchSection.Syntax, isImplicit: boundSwitchSection.WasCompilerGenerated); 2716boundSwitchExpression.Syntax, 2732boundSwitchExpressionArm.Syntax, 2738SyntaxNode syntax = boundSwitchLabel.Syntax; 2742if (boundSwitchLabel.Syntax.Kind() == SyntaxKind.DefaultSwitchLabel) 2766SyntaxNode syntax = boundIsPatternExpression.Syntax; 2774if (boundQueryClause.Syntax.Kind() != SyntaxKind.QueryExpression) 2781SyntaxNode syntax = boundQueryClause.Syntax; 2798boundNode.Syntax, 2813boundIndex.Syntax, 2828boundRange.Syntax, 2839boundNode.Syntax, 2847SyntaxNode subpatternSyntax = subpattern.Syntax; 2860var nameSyntax = member.Syntax; 2867nameSyntax = member.Syntax; 2925SyntaxNode syntax = placeholder.Syntax;

40(SyntaxNode syntax, bool isImplicit) = expression.Syntax is { Parent: ArgumentSyntax or AttributeArgumentSyntax } ? (expression.Syntax.Parent, expression.WasCompilerGenerated) : (value.Syntax, true); 70initializerSyntax = boundLocalDeclaration.InitializerOpt.Syntax; 95return boundLocal == null ? null : new VariableDeclaratorOperation(boundLocal.LocalSymbol.GetPublicSymbol(), initializer: null, ignoredArguments: ImmutableArray<IOperation>.Empty, semanticModel: _semanticModel, syntax: boundLocal.Syntax, isImplicit: false); 126SyntaxNode syntax = boundEventAssignmentOperator.Syntax; 458anonymousProperty.Syntax,

158Binder.CheckFeatureAvailability(node.Syntax, MessageID.IDS_FeatureConstantInterpolatedStrings, diagnostics);

53base(unboundLambda.Syntax.GetReference()) 61_syntax = unboundLambda.Syntax;

959diagnostics.Add(defaultExpression.Syntax, useSiteInfo);

275VerifyParamDefaultValueMatchesAttributeIfAny(_lazyDefaultSyntaxValue, parameterEqualsValue.Value.Syntax, diagnostics); 284parameterEqualsValue.Value.Syntax.Location);

429Binder.CheckRequiredMembersInObjectInitializer(ctor, ImmutableArray<BoundExpression>.CastUp(boundAttribute.NamedArguments), boundAttribute.Syntax, diagnostics); 430attributeBinder.ReportDiagnosticsIfObsolete(diagnostics, ctor, boundAttribute.Syntax, hasBaseReceiver: false); 432NullableWalker.AnalyzeIfNeeded(attributeBinder, boundAttribute, boundAttribute.Syntax, diagnostics.DiagnosticBag);

228NullableWalker.AnalyzeIfNeeded(binder, boundGetAccessor, boundGetAccessor.Syntax, diagnostics, symbolAndGetterNullResilienceData: (getAccessor, new NullableWalker.GetterNullResilienceData(_property.BackingField, assumedNullableAnnotation)));

299diagnostics.Add(ErrorCode.WRN_TupleLiteralNameMismatch, literal.Arguments[i].Syntax.Parent!.Location, sourceName, destination);

1458Select(node => node.Syntax.ToFullString().Trim() + " --> " + ExtractValue(node.ConstantValueOpt));

278var initValueSyntax = boundFieldInit.Value.Syntax; 279Assert.Same(initValueSyntax.Parent, boundInit.Syntax);

5242var text = node.Syntax.ToString();