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,

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

472BindDefaultArguments(indexerAccess.Syntax, parameters, argumentsBuilder, refKindsBuilderOpt, namesBuilder, ref argsToParams, out defaultArguments, indexerAccess.Expanded, enableCallerInfo: true, diagnostics); 526Debug.Assert(expr.Syntax.Kind() != SyntaxKind.Argument || valueKind == BindValueKind.RefOrOut); 620diagnostics.Add(expr.Syntax, useSiteInfo); 654expr.Syntax, 662if (!hasResolutionErrors && CheckValueKind(expr.Syntax, expr, valueKind, checkingReceiver: false, diagnostics: diagnostics) || 878return CheckMethodReturnValueKind(call.Method, call.Syntax, node, valueKind, checkingReceiver, diagnostics); 882expr.Syntax, 896return CheckMethodReturnValueKind(sliceAccess.Method, sliceAccess.Syntax, node, valueKind, checkingReceiver, diagnostics); 921return CheckMethodReturnValueKind(getItemOrSliceHelper, elementAccess.Syntax, node, valueKind, checkingReceiver, diagnostics); 941(CheckValueKind(conditional.Consequence.Syntax, conditional.Consequence, valueKind, checkingReceiver: false, diagnostics: diagnostics) & 942CheckValueKind(conditional.Alternative.Syntax, conditional.Alternative, valueKind, checkingReceiver: false, diagnostics: diagnostics))) 1020Error(diagnostics, ErrorCode.ERR_BadSKknown, expr.Syntax, ((BoundNamespaceExpression)expr).NamespaceSymbol, MessageID.IDS_SK_NAMESPACE.Localize(), MessageID.IDS_SK_VARIABLE.Localize()); 1023Error(diagnostics, ErrorCode.ERR_BadSKunknown, expr.Syntax, expr.Type, MessageID.IDS_SK_TYPE.Localize()); 1058diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, local.Syntax.Location, localSymbol); 1108Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnLocal2 : ErrorCode.ERR_RefReturnLocal2, local.Syntax, localSymbol); 1119Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnNonreturnableLocal2 : ErrorCode.ERR_RefReturnNonreturnableLocal2, local.Syntax, localSymbol); 1192diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, parameter.Syntax.Location, parameterSymbol.Name); 1318(checkingReceiver: true, isRefScoped: true, inUnsafeRegion: false, _) => (ErrorCode.ERR_RefReturnScopedParameter2, parameter.Syntax), 1319(checkingReceiver: true, isRefScoped: true, inUnsafeRegion: true, _) => (ErrorCode.WRN_RefReturnScopedParameter2, parameter.Syntax), 1320(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: false, { IsReturnOnly: true }) => (ErrorCode.ERR_RefReturnOnlyParameter2, parameter.Syntax), 1321(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: true, { IsReturnOnly: true }) => (ErrorCode.WRN_RefReturnOnlyParameter2, parameter.Syntax), 1322(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: false, _) => (ErrorCode.ERR_RefReturnParameter2, parameter.Syntax), 1323(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: true, _) => (ErrorCode.WRN_RefReturnParameter2, parameter.Syntax), 1735Error(diagnostics, ErrorCode.ERR_ReturnNotLValue, expr.Syntax, propertySymbol); 2270CheckRefEscape(argument.Syntax, argument, escapeFrom, escapeTo, false, diagnostics) : 2271CheckValEscape(argument.Syntax, argument, escapeFrom, escapeTo, false, diagnostics); 2292return CheckValEscape(receiver.Syntax, receiver, escapeFrom, escapeTo, false, diagnostics); 2343CheckRefEscape(argument.Syntax, argument, escapeFrom, escapeTo, false, diagnostics) : 2344CheckValEscape(argument.Syntax, argument, escapeFrom, escapeTo, false, diagnostics); 2397receiver = new BoundCapturedReceiverPlaceholder(receiver.Syntax, receiver, _localScopeDepth, receiver.Type).MakeCompilerGenerated(); 2949if (!hasMixingError && !CheckValEscape(argument.Syntax, argument, localScopeDepth, escapeTo, false, diagnostics)) 3016? CheckRefEscape(fromArg.Syntax, fromArg, localScopeDepth, toArgEscape, checkingReceiver: false, diagnostics) 3017: CheckValEscape(fromArg.Syntax, fromArg, localScopeDepth, toArgEscape, checkingReceiver: false, diagnostics); 3409CheckRefEscape(expr.Syntax, expr, _localScopeDepth, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3413CheckValEscape(expr.Syntax, expr, _localScopeDepth, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3828return CheckRefEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 3829CheckRefEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3860call.Syntax, 3886indexerAccess.Syntax, 3917indexerAccess.Syntax, 3943call.Syntax, 3979elementAccess.Syntax, 4004functionPointerInvocation.Syntax, 4029propertyAccess.Syntax, 4933Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, node, expr.Syntax); 4950return CheckValEscape(underlyingReceiver.Syntax, underlyingReceiver, escapeFrom, escapeTo, checkingReceiver, diagnostics); 4965CheckValEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 4966CheckValEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4973var consValid = CheckValEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4982return CheckValEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4987return CheckValEscape(coalescingOp.LeftOperand.Syntax, coalescingOp.LeftOperand, escapeFrom, escapeTo, checkingReceiver, diagnostics) && 4988CheckValEscape(coalescingOp.RightOperand.Syntax, coalescingOp.RightOperand, escapeFrom, escapeTo, checkingReceiver, diagnostics); 5009call.Syntax, 5029ptrInvocation.Syntax, 5049indexerAccess.Syntax, 5075indexerAccess.Syntax, 5097call.Syntax, 5124elementAccess.Syntax, 5144propertyAccess.Syntax, 5164objectCreation.Syntax, 5183initializerExpr.Syntax, 5204initializerExpr.Syntax, 5221escape = escape && CheckValEscape(initializerExpr.Syntax, initializerExpr, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5231unary.Syntax, 5278conversion.Syntax, 5299conversion.Syntax, 5338increment.Syntax, 5364compound.Syntax, 5380return CheckValEscape(compound.Left.Syntax, compound.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5384return CheckValEscape(compound.Left.Syntax, compound.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 5385CheckValEscape(compound.Right.Syntax, compound.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5398binary.Syntax, 5413return CheckValEscape(binary.Left.Syntax, binary.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 5414CheckValEscape(binary.Right.Syntax, binary.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5419if (range.LeftOperandOpt is { } left && !CheckValEscape(left.Syntax, left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 5424return !(range.RightOperandOpt is { } right && !CheckValEscape(right.Syntax, right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)); 5430uo.Syntax, 5446return CheckValEscape(clauseValue.Syntax, clauseValue, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5450return CheckValEscape(variableValue.Syntax, variableValue, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 5470return CheckValEscape(accessedExpression.Syntax, accessedExpression, escapeFrom, escapeTo, checkingReceiver, diagnostics); 5474return CheckValEscape(operandExpression.Syntax, operandExpression, escapeFrom, escapeTo, checkingReceiver, diagnostics); 5489if (!CheckValEscape(result.Syntax, result, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 5735if (!CheckValEscape(element.Syntax, element, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 5752Error(diagnostics, _inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, initExpr.Syntax, expr.Syntax); 5766if (!CheckValEscape(expression.Syntax, expression, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 5791CheckValEscape(expression.Syntax, data.Construction, escapeFrom, escapeTo, checkingReceiver: false, diagnostics); 5802if (!CheckValEscape(argument.Syntax, argument, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))

288Debug.Assert(boundAttribute.Syntax.Kind() == SyntaxKind.Attribute); 296return new SourceAttributeData(Compilation, (AttributeSyntax)boundAttribute.Syntax, attributeType, attributeConstructor, hasErrors); 300ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)boundAttribute.Syntax).Name, diagnostics, ref hasErrors); 321(AttributeSyntax)boundAttribute.Syntax, 331diagnostics.Add(boundAttribute.Syntax, useSiteInfo); 335(AttributeSyntax)boundAttribute.Syntax, 891Binder.Error(diagnostics, ErrorCode.ERR_BadAttributeArgument, node.Syntax); 962Binder.Error(diagnostics, ErrorCode.ERR_AttrArgWithTypeVars, node.Syntax, typeOfArgument.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)); 1046Binder.Error(diagnostics, ErrorCode.ERR_BadAttributeArgument, node.Syntax);

31var placeholder = new BoundAwaitableValuePlaceholder(expression.Syntax, expression.Type); 120var syntax = expression.Syntax;

28diagnostics.Add(source.Syntax, useSiteInfo); 29return CreateConversion(source.Syntax, source, conversion, isCast: false, conversionGroupOpt: null, destination: destination, diagnostics: diagnostics); 38return CreateConversion(source.Syntax, source, conversion, isCast: false, conversionGroupOpt: null, destination: destination, diagnostics: diagnostics); 77var placeholder2 = new BoundValuePlaceholder(source.Syntax, source.Type); 272source = new BoundDefaultExpression(source.Syntax, targetType: null, constantValue, type: destination) 284diagnostics.Add(ErrorCode.WRN_ConvertingLock, source.Syntax); 327new BoundValuePlaceholder(source.Syntax, source.Type.GetNullableUnderlyingType()), 356new BoundValuePlaceholder(source.Syntax, source.Type.GetNullableUnderlyingType()), 384new BoundValuePlaceholder(source.Syntax, sourceTypes[i].Type), 713var stringFactory = GetWellKnownType(WellKnownType.System_Runtime_CompilerServices_FormattableStringFactory, diagnostics, unconvertedSource.Syntax); 718unconvertedSource.Syntax, 746BoundExpression expr = bindObjectCreationExpression(node.Syntax, node.InitializerOpt, node.Binder, destination.StrippedType(), arguments, diagnostics); 754Debug.Assert(expr is not BoundBadExpression { ChildBoundNodes: var children } || !children.Any((child, node) => child.Syntax == node.Syntax, node)); 817_ = GetSpecialTypeMember(SpecialMember.System_Nullable_T__ctor, diagnostics, syntax: node.Syntax); 828var syntax = node.Syntax; 914(SpreadElementSyntax)spreadElement.Syntax, 920element.Syntax, 960element.Syntax, 992var expressionSyntax = element.Expression.Syntax; 1734var syntax = node.Syntax; 1770if (!TryGetCollectionIterationType(node.Syntax, targetType, out elementTypeWithAnnotations)) 1777node.Syntax, 1795if (!HasCollectionExpressionApplicableConstructor(node.Syntax, targetType, constructor: out _, isExpanded: out _, diagnostics)) 1801!HasCollectionExpressionApplicableAddMethod(node.Syntax, targetType, addMethods: out _, diagnostics)) 1815Error(diagnostics, ErrorCode.ERR_NoImplicitConv, spreadElement.Expression.Syntax, spreadElement.Expression.Display, elementType); 1823GenerateImplicitConversionError(diagnostics, this.Compilation, spreadElement.Expression.Syntax, elementConversion, enumeratorInfo.ElementType, elementType); 1833GenerateImplicitConversionError(diagnostics, element.Syntax, elementConversion, (BoundExpression)element, elementType); 1843Error(diagnostics, ErrorCode.ERR_CollectionExpressionTargetTypeNotConstructible, node.Syntax, targetType); 1956? CreateConversion(source.Consequence.Syntax, source.Consequence, underlyingConversions[0], isCast: false, conversionGroupOpt: null, destination, diagnostics) 1960? CreateConversion(source.Alternative.Syntax, source.Alternative, underlyingConversions[1], isCast: false, conversionGroupOpt: null, destination, diagnostics) 1969source.Syntax.Location, 1976return new BoundConditionalOperator(source.Syntax, isRef: false, condition, trueExpr, falseExpr, constantValue, source.Type, wasTargetTyped: targetTyped, destination, hasErrors) 1996? CreateConversion(oldValue.Syntax, oldValue, underlyingConversions[i], isCast: false, conversionGroupOpt: null, destination, diagnostics) 1999new BoundSwitchExpressionArm(oldCase.Syntax, oldCase.Locals, oldCase.Pattern, oldCase.WhenClause, newValue, oldCase.Label, oldCase.HasErrors); 2006source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.ReachabilityDecisionDag, 2073syntax: source.Syntax, 2477var tupleSyntax = (TupleExpressionSyntax)sourceTuple.Syntax; 2506convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, destType.Type, diagnostics)); 2510sourceTuple.Syntax, 2522sourceTuple.Syntax, 3103return this.MethodGroupConversionHasErrors(boundMethodGroup.Syntax, conversion, boundMethodGroup.ReceiverOpt, conversion.IsExtensionMethod, isAddressOf: false, delegateType, diagnostics);

132new BoundConversion(boundRHS.Syntax, boundRHS, Conversion.Deconstruction, @checked: false, explicitCastInCode: false, conversionGroupOpt: null, 145boundRHS.Syntax, 162boundRHS.Syntax, 228Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, boundRHS.Syntax); 324diagnostics.Add(single.Syntax, useSiteInfo); 329GenerateImplicitConversionError(diagnostics, Compilation, single.Syntax, nestedConversion, tupleOrDeconstructedTypes[i], single.Type); 408variables[i] = new DeconstructionVariable(errorLocal, errorLocal.Syntax); 414Error(diagnostics, ErrorCode.ERR_TypeInferenceFailedForImplicitlyTypedDeconstructionVariable, pending.Syntax, "_"); 415variables[i] = new DeconstructionVariable(pending.FailInference(this, diagnostics), pending.Syntax); 496Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, element.Syntax); 514Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, element.Syntax); 519locationsBuilder.Add(element.Syntax.Location); 602return InferTupleElementName(expression.Syntax); 621var receiverSyntax = (CSharpSyntaxNode)receiver.Syntax;

222expr.Syntax, 298var exprSyntax = (SwitchExpressionSyntax)expr.Syntax; 329diagnostics.Add(op.NoCommonTypeError, op.Syntax.Location, trueArg, falseArg); 343sourceTuple.Syntax, 358diagnostics.Add(ErrorCode.ERR_DefaultLiteralNoTargetType, defaultExpr.Syntax.GetLocation()); 362defaultExpr.Syntax, 381diagnostics.Add(ErrorCode.ERR_ImplicitObjectCreationNoTargetType, expr.Syntax.GetLocation(), expr.Display); 401diagnostics.Add(ErrorCode.ERR_CollectionExpressionNoTargetType, expr.Syntax.GetLocation()); 418var syntax = expr.Syntax; 2776GenerateAnonymousFunctionConversionError(diagnostics, operand.Syntax, (UnboundLambda)operand, targetType); 2866GenerateImplicitConversionError(diagnostics, operand.Syntax, conversion, operand, targetType); 2913GenerateExplicitConversionErrors(diagnostics, argument.Syntax, elementConversion, argument, targetElementType); 3509coercedArgument = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, parameterTypeWithAnnotations.Type, diagnostics); 3530coercedArgument = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, parameterTypeWithAnnotations.Type, diagnostics); 3654ReportUnsafeIfNotAllowed(argument.Syntax, diagnostics); 3689unconvertedString.Syntax, 3703diagnostics.Add(ErrorCode.ERR_InterpolatedStringHandlerArgumentAttributeMalformed, unconvertedString.Syntax.Location, correspondingParameter, handlerType); 3705unconvertedString.Syntax, 3720unconvertedString.Syntax, 3804unconvertedString.Syntax.Location, 3823arguments[argumentIndex].Syntax.Location, 3843placeholderSyntax = receiver.Syntax; 3846placeholderSyntax = unconvertedString.Syntax; 3850placeholderSyntax = arguments[argumentIndex].Syntax; 3878interpolatedString.Syntax, 3904var available = CheckFeatureAvailability(argument.Syntax, MessageID.IDS_FeatureRefReadonlyParameters, diagnostics); 3922argument.Syntax, 3928if (!this.CheckValueKind(argument.Syntax, argument, BindValueKind.RefersToLocation, checkingReceiver: false, BindingDiagnosticBag.Discarded)) 3934argument.Syntax, 3940if (this.CheckValueKind(argument.Syntax, argument, BindValueKind.Assignable, checkingReceiver: false, BindingDiagnosticBag.Discarded)) 3945argument.Syntax, 3953argument.Syntax, 4448Error(diagnostics, ErrorCode.ERR_ConstantExpected, size.Syntax); 4685Error(diagnostics, ErrorCode.ERR_ConstantExpected, sizeOpt.Syntax); 5153return (parameter, boundParameter.Syntax); 5313lengthOrCount = new BoundLiteral(expression.Syntax, ConstantValue.Create(length), @this.GetSpecialType(SpecialType.System_Int32, diagnostics, expression.Syntax)) { WasCompilerGenerated = true }; 5360var argSyntax = analyzedArguments.Arguments[0].Syntax; 5362var end = analyzedArguments.Arguments[analyzedArguments.Arguments.Count - 1].Syntax.Span.End; 5403GenerateImplicitConversionError(diagnostics, unboundLambda.Syntax, conversion, unboundLambda, type); 5416CheckParameterModifierMismatchMethodConversion(unboundLambda.Syntax, boundLambda.Symbol, type, invokedAsExtensionMethod: false, diagnostics); 5443diagnostics.Add(ErrorCode.ERR_MethodNameExpected, argument.Syntax.Location); 5467Conversion conv = Conversions.MethodGroupConversion(argument.Syntax, methodGroup, type, ref useSiteInfo); 5472argument.Syntax, default, WellKnownMemberNames.DelegateInvokeName, ImmutableArray.Create(sourceDelegate.DelegateInvokeMethod), 5488if (!this.MethodGroupConversionHasErrors(argument.Syntax, conv, argument, conv.IsExtensionMethod, isAddressOf: false, type, diagnostics)) 5504diagnostics.Add(ErrorCode.ERR_MethodNameExpected, argument.Syntax.Location); 5580var result = MakeBadExpressionForObjectCreation(node.Syntax, CreateErrorType(), arguments, node.InitializerOpt, typeSyntax: node.Syntax, diagnostics); 5751typeSyntax: boundLeft.Syntax, 5972diagnostics.Add(ErrorCode.ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers, argument.Syntax.Location); 5983MessageID.IDS_FeatureImplicitIndexerInitializer.CheckFeatureAvailability(diagnostics, implicitIndexer.Syntax); 6018if (!CheckValueKind(boundMember.Syntax, boundMember, valueKind, checkingReceiver: false, diagnostics: diagnostics)) 6116var memberInitializerSyntax = boundMemberInitializer.Syntax; 6205diagnostics.Add(ErrorCode.ERR_RequiredMembersMustBeAssignedValue, initializerExpression.Syntax.Location, requiredMember); 6358var boundElementInitializer = BindInitializerExpressionOrValue(elementInitializer, initializerType, BindValueKind.RValue, implicitReceiver.Syntax, diagnostics); 6843CheckRequiredMembersInObjectInitializer(creation.Constructor, creation.InitializerExpressionOpt?.Initializers ?? default, creation.Syntax, diagnostics); 7898CheckFeatureAvailability(boundLeft.Syntax, MessageID.IDS_FeatureStaticAbstractMembersInInterfaces, diagnostics); 7903Error(diagnostics, ErrorCode.ERR_LookupInTypeVariable, boundLeft.Syntax, leftType); 7966diagnostics.Add(expr.Syntax, useSiteInfo); 9523if (expr.Syntax.Parent is ConditionalAccessExpressionSyntax conditional && 9524conditional.Expression == expr.Syntax) 9526location = expr.Syntax.SyntaxTree.GetLocation(TextSpan.FromBounds(expr.Syntax.SpanStart, conditional.OperatorToken.Span.End)); 9530location = expr.Syntax.GetLocation(); 9545checkInlineArrayBounds(convertedIndex.Syntax, constIndex, length, excludeEnd: true, diagnostics); 9626location = hatExpression.Syntax; 9632location = operand.Syntax; 9640location = index.Syntax; 9746Error(diagnostics, ErrorCode.WRN_NegativeArrayIndex, index.Syntax); 9760var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(expr.Syntax, isEquivalentToThisReference: expr.IsEquivalentToThisReference, expr.Type) { WasCompilerGenerated = true }; 9761var argumentPlaceholders = ImmutableArray.Create(new BoundImplicitIndexerValuePlaceholder(convertedArguments[0].Syntax, int32) { WasCompilerGenerated = true }); 9792var node = index.Syntax; 9900BoundExpression result = CreateConversion(expr.Syntax, expr, conversion, isCast: false, conversionGroupOpt: null, destination: targetType, diagnostics); // UNDONE: was cast? 9941Error(diagnostics, ErrorCode.ERR_VoidError, expr.Syntax); 9959Error(diagnostics, ErrorCode.ERR_BadArgExtraRef, analyzedArguments.Argument(i).Syntax, i + 1, refKind.ToArgumentDisplayString()); 10039var syntax = propertyGroup.Syntax; 10305var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(receiver.Syntax, isEquivalentToThisReference: receiver.IsEquivalentToThisReference, receiver.Type) { WasCompilerGenerated = true }; 10641node, node.Syntax, node.Name, analyzedArguments, ref useSiteInfo, 10844return GetMethodGroupOrLambdaDelegateType(node.Syntax, method, hasParams: useParams); 10901PopulateExtensionMethodsFromSingleBinder(scope, methodGroup, node.Syntax, receiver, node.Name, node.TypeArgumentsOpt, BindingDiagnosticBag.Discarded); 11339if (access.Syntax is AssignmentExpressionSyntax assignment) 11442diagnostics.Add(new CSDiagnostic(diagnosticInfo, access.Syntax.Location)); 11443receiver = BadExpression(receiver.Syntax, receiver); 11485if (receiver?.Syntax != GetConditionalReceiverSyntax(conditionalAccessNode)) 11500receiver = 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);

291Error(diagnostics, ErrorCode.ERR_CantUseVoidInArglist, argument.Syntax); 306Error(diagnostics, ErrorCode.ERR_CantUseInOrOutInArglist, argument.Syntax); 519Error(diagnostics, ErrorCode.ERR_NamedArgumentSpecificationBeforeFixedArgumentInDynamicInvocation, arguments.Arguments[i].Syntax); 559Error(diagnostics, ErrorCode.ERR_CannotDynamicInvokeOnExpression, receiver.Syntax, receiver.Type); 569Error(diagnostics, ErrorCode.ERR_InDynamicMethodArg, arguments[argIndex].Syntax); 590Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArgLambda, arg.Syntax); 596Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArgMemgrp, arg.Syntax); 604Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, "__arglist"); 613Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, arg.Type); 887argumentSyntax = arg.Syntax; 1070Error(diagnostics, ErrorCode.ERR_NoImplicitConv, call.ReceiverOpt.Syntax, distinguisher.First, distinguisher.Second); 1076Error(diagnostics, ErrorCode.ERR_NoImplicitConv, call.ReceiverOpt.Syntax, distinguisher.First, distinguisher.Second); 1090Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, dynInvoke.Expression.Syntax, dynInvoke.Expression.Type); 1279CheckFeatureAvailability(receiverArgument.Syntax, MessageID.IDS_FeatureRefExtensionMethods, diagnostics); 1285CheckFeatureAvailability(receiverArgument.Syntax, MessageID.IDS_FeatureRefExtensionMethods, diagnostics); 1402var result = !CheckValueKind(receiver.Syntax, receiver, valueKind, checkingReceiver: true, BindingDiagnosticBag.Discarded); 1705defaultValue = new BoundLiteral(syntax, ConstantValue.Create(argument.Syntax.ToString()), Compilation.GetSpecialType(SpecialType.System_String)) { WasCompilerGenerated = true }; 1756defaultValue.Syntax, 1850Error(diagnostics, ErrorCode.WRN_ImplicitCopyInReadOnlyMember, receiver.Syntax, method, ThisParameterSymbol.SymbolName); 2328diagnostics.Add(ErrorCode.ERR_NameofExtensionMember, boundArgument.Syntax); 2359diagnostics.Add(methodGroup.Syntax, useSiteInfo); 2363diagnostics.Add(ErrorCode.ERR_NameofExtensionMethod, methodGroup.Syntax.Location); 2475boundExpression.Syntax,

68var placeholder = new BoundValuePlaceholder(right.Syntax, left.HasDynamicType() ? left.Type : right.Type).MakeCompilerGenerated(); 309var leftPlaceholder = new BoundValuePlaceholder(left.Syntax, leftType).MakeCompilerGenerated(); 495leftPlaceholder = new BoundValuePlaceholder(left.Syntax, leftType).MakeCompilerGenerated(); 1239left = BindSimpleBinaryOperator((BinaryExpressionSyntax)current.Syntax, diagnostics, left ?? current.Left, right, leaveUnconvertedIfInterpolatedString: false); 1275GenerateImplicitConversionError(diagnostics, right.Syntax, conversion, right, left.Type); 1484var operandPlaceholder = new BoundValuePlaceholder(resultLeft.Syntax, resultLeft.Type).MakeCompilerGenerated(); 1491resultLeft.Syntax, 1499diagnostics.Add(operandConversion.Syntax, useSiteInfo); 1563var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated(); 1564CreateConversion(left.Syntax, operandPlaceholder, implicitConversion, isCast: false, conversionGroupOpt: null, booleanType, diagnostics); 1571diagnostics.Add(left.Syntax, useSiteInfo); 1577diagnostics.Add(left.Syntax, useSiteInfo); 1601var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated(); 1607CreateConversion(left.Syntax, operandPlaceholder, implicitConversion, isCast: false, conversionGroupOpt: null, parameterType, diagnostics); 1610diagnostics.Add(left.Syntax, useSiteInfo); 2697Error(diagnostics, ErrorCode.ERR_ConstantStringTooLong, right.Syntax); 3268var operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operandType).MakeCompilerGenerated(); 3451operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operandType).MakeCompilerGenerated(); 3875Error(diagnostics, ErrorCode.ERR_IllegalSuppression, expr.Syntax); 3881Error(diagnostics, ErrorCode.ERR_DuplicateNullSuppression, expr.Syntax); 4026bool receiverIsLValue = CheckValueKind(receiver.Syntax, receiver, BindValueKind.AddressOf, checkingReceiver: false, diagnostics: BindingDiagnosticBag.Discarded); 4145Error(diagnostics, ErrorCode.ERR_IllegalSuppression, expr.Syntax); 4215var resultOperand = CreateConversion(operand.Syntax, operand, best.Conversion, isCast: false, conversionGroupOpt: null, signature.OperandType, diagnostics); 4511if (node.Operand != operand.Syntax || operand.Syntax.Kind() != SyntaxKind.NumericLiteralExpression) 4516var literal = (LiteralExpressionSyntax)operand.Syntax; 5210operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 5220operand = new BoundDefaultExpression(operand.Syntax, targetType: null, constantValueOpt: ConstantValue.Null, 5257operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 5475var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 5497var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType0).MakeCompilerGenerated(); 5516var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 5566var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType0).MakeCompilerGenerated(); 5580var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 5778diagnostics.Add(ErrorCode.ERR_RefConditionalDifferentTypes, falseExpr.Syntax.Location, trueType); 5814CheckValEscape(falseExpr.Syntax, falseExpr, currentScope, whenTrueEscape, checkingReceiver: false, diagnostics: diagnostics); 5816CheckValEscape(trueExpr.Syntax, trueExpr, currentScope, whenFalseEscape, checkingReceiver: false, diagnostics: diagnostics);

35expression = BadExpression(expression.Syntax, expression); 60this.Compilation, pattern.Syntax, expression, innerPattern, whenTrueLabel: whenTrueLabel, whenFalseLabel: whenFalseLabel, diagnostics); 614diagnostics.Add(ErrorCode.ERR_ValueCantBeNull, expression.Syntax.Location, inputType); 624diagnostics.Add(ErrorCode.ERR_PatternWrongType, expression.Syntax.Location, inputType, expression.Display); 636expression.Syntax.Location, inputType, expression.Display, new CSharpRequiredLanguageVersion(requiredVersion)); 674diagnostics.Add(ErrorCode.ERR_PatternSpanCharCannotBeStringNull, convertedExpression.Syntax.Location, inputType);

736yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), CreateErrorType()); 742yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), yExpression.Type); 803field2Value = new BoundBadExpression(field2Value.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(field2Value), field2Value.Type, true); 818new AnonymousTypeField(fieldName, fieldValue.Syntax.Location, TypeWithAnnotations.Create(TypeOrError(fieldValue)), RefKind.None, ScopedKind.None); 951diagnostics.Add(ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax.Location, ((BoundNamespaceExpression)ultimateReceiver).NamespaceSymbol, MessageID.IDS_SK_NAMESPACE.Localize()); 959receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType()); 966Error(diagnostics, ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax, ultimateReceiver.Type, MessageID.IDS_SK_TYVAR.Localize()); 981receiver = 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); 1233SyntaxNode initializerSyntax = initializerOpt.Syntax; 1300CheckFeatureAvailability(initializerOpt.Syntax, MessageID.IDS_FeatureExtensibleFixedStatement, diagnostics); 1329var result = PerformPatternMethodLookup(initializer, methodName, initializer.Syntax, additionalDiagnostics, out var patternMethodSymbol, out bool isExpanded); 1342additionalDiagnostics.Add(ErrorCode.WRN_PatternBadSignature, initializer.Syntax.Location, initializer.Type, "fixed", patternMethodSymbol); 1363SyntaxNode initializerSyntax = initializer.Syntax; 1467diagnostics.Add(ErrorCode.ERR_VoidAssignment, op1.Syntax.Location); 1576Error(diagnostics, errorCode, node, getName(op1), op2.Syntax); 1598Error(diagnostics, errorCode, node, getName(op1), op2.Syntax); 1690var syntax = expr.Syntax; 1738SyntaxNode syntax = expr.Syntax; 1959diagnostics.Add(expression.Syntax, useSiteInfo); 1965Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, expression.Syntax, targetType); 1988expression.Syntax, 1994GenerateImplicitConversionError(diagnostics, expression.Syntax, conversion, expression, targetType); 2002return CreateConversion(expression.Syntax, expression, conversion, isCast: false, conversionGroupOpt: null, targetType, diagnostics); 2424Error(diagnostics, ErrorCode.ERR_InvalidAddrOp, ((BoundAddressOfOperator)operand).Operand.Syntax); 2443GenerateImplicitConversionError(diagnostics, expr.Syntax, conversion, expr, targetType); 2543GenerateImplicitConversionError(diagnostics, argument.Syntax, elementConversion, argument, targetElementType); 2689diagnostics.Add(expr.Syntax, useSiteInfo); 2704Error(diagnostics, ErrorCode.WRN_IncorrectBooleanAssg, assignment.Syntax); 2710syntax: expr.Syntax, 3180Error(diagnostics, ErrorCode.ERR_RefReturnMustHaveIdentityConversion, argument.Syntax, returnType); 3197Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType, argument.Type); 3201GenerateImplicitConversionError(diagnostics, argument.Syntax, conversion, argument, returnType); 3204ReportCantConvertLambdaReturn(argument.Syntax, diagnostics); 3211return CreateConversion(argument.Syntax, argument, conversion, isCast: false, conversionGroupOpt: null, returnType, diagnostics); 3466var syntax = expressionSyntax ?? expression.Syntax;

1490diagnostics.Add(receiver.Syntax, useSiteInfo); 1497Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, receiver.Syntax, parameter.Name, parameter.Type, parameter); 1507receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Ambiguous, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(receiver), receiver.Type, hasErrors: true).MakeCompilerGenerated(); 1517receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, childBoundNodes: [receiver], receiver.Type, hasErrors: true).MakeCompilerGenerated();

65tuple.Syntax, tuple, wasTargetTyped: false, builder.ToImmutableAndFree(), tuple.ArgumentNamesOpt, tuple.InferredNamesOpt, tuple.Type, tuple.HasErrors); 318Location location = ((BoundTupleExpression)(useRight ? right : left)).Arguments[i].Syntax.Parent.Location; 333return new BoundDefaultExpression(expr.Syntax, targetType); 385.SelectAsArray((t, s) => (BoundExpression)new BoundTupleOperandPlaceholder(s, t.Type), expr.Syntax); 407ImmutableArray<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)); 324var syntax = pattern.Syntax; 402input = MakeConvertToType(input, declaration.Syntax, type!, isExplicitTest: false, tests); 426output = MakeConvertToType(input: input, syntax: typePattern.Syntax, type: type, isExplicitTest: typePattern.IsExplicitNotNullTest, tests: tests); 490return new Tests.One(new BoundDagExplicitNullTest(constant.Syntax, input)); 495return new Tests.One(new BoundDagValueTest(constant.Syntax, constant.ConstantValue, input)); 501output = input = constant.Value.Type is { } type ? MakeConvertToType(input, constant.Syntax, type, isExplicitTest: false, tests) : input; 510tests.Add(new Tests.One(new BoundDagValueTest(constant.Syntax, constant.ConstantValue, input))); 525output = input = MakeConvertToType(input, recursive.Syntax, inputType, isExplicitTest: recursive.IsExplicitNotNullTest, tests); 533var evaluation = new BoundDagDeconstructEvaluation(recursive.Syntax, method, OriginalInput(input, method)); 540SyntaxNode syntax = pattern.Syntax; 561SyntaxNode syntax = pattern.Syntax; 574tests.Add(new Tests.One(new BoundDagTypeTest(recursive.Syntax, ErrorType(), input, hasErrors: true))); 588tests.Add(new Tests.One(new BoundDagTypeTest(recursive.Syntax, ErrorType(), input, hasErrors: true))); 614input = MakeConvertToType(input, member.Syntax, member.Receiver.Type.StrippedType(), isExplicitTest: false, tests); 621evaluation = new BoundDagPropertyEvaluation(member.Syntax, property, isLengthOrCount, OriginalInput(input, property)); 624evaluation = new BoundDagFieldEvaluation(member.Syntax, field, OriginalInput(input, field)); 631input = new BoundDagTemp(member.Syntax, member.Type, evaluation); 688output = @this.MakeConvertToType(input: input, syntax: bin.Syntax, type: bin.NarrowedType, isExplicitTest: false, tests: builder); 712output = MakeConvertToType(input, rel.Syntax, type, isExplicitTest: false, tests); 721tests.Add(new Tests.One(new BoundDagRelationalTest(rel.Syntax, rel.Relation, rel.ConstantValue, output, rel.HasErrors))); 756var boundDecisionDag = new BoundDecisionDag(rootDecisionDagNode.Syntax, rootDecisionDagNode); 958state.SelectedTest = new BoundDagNonNullTest(t.Syntax, isExplicitTest: true, t.Input, t.HasErrors); 1048state.Dag = uniqifyDagNode(new BoundEvaluationDecisionDagNode(e.Syntax, e, next)); 1057state.Dag = uniqifyDagNode(new BoundTestDecisionDagNode(d.Syntax, d, whenTrue, whenFalse)); 1470Debug.Assert(s1LengthTemp.Syntax is ListPatternSyntax); 1471Debug.Assert(s2LengthTemp.Syntax is ListPatternSyntax); 1475s1LengthTemp.Syntax != s2LengthTemp.Syntax) 1726builder.Append($" WHEN[{cd.WhenClause.Syntax}]"); 2146SyntaxNode syntax = test.Syntax; 2218if (e.Syntax.IsKind(SyntaxKind.ListPattern)) 2241new One(new BoundDagValueTest(t.Syntax, safeAdd(t.Value, offset), lengthTemp)); 2245new One(new BoundDagRelationalTest(t.Syntax, t.OperatorKind, safeAdd(t.Value, offset), lengthTemp));

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); 487Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, collectionExpr.Syntax, iterationVariableType.Type); 646collectionExpr.Syntax, 661collectionExpr.Syntax, 703inferredType = TypeWithAnnotations.Create(GetSpecialType(SpecialType.System_Char, diagnostics, collectionExpr.Syntax)); 721SyntaxNode exprSyntax = collectionExpr.Syntax; 836if (CheckValueKind(collectionExpr.Syntax, collectionExpr, BindValueKind.RefersToLocation | BindValueKind.Assignable, checkingReceiver: false, BindingDiagnosticBag.Discarded)) 844if (!CheckValueKind(collectionExpr.Syntax, collectionExpr, BindValueKind.RefersToLocation, checkingReceiver: false, BindingDiagnosticBag.Discarded)) 850NamedTypeSymbol spanType = GetWellKnownType(wellKnownSpan, diagnostics, collectionExpr.Syntax); 862diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type); 868BoundExpression span = new BoundValuePlaceholder(collectionExpr.Syntax, spanType).MakeCompilerGenerated(); 890CheckFeatureAvailability(collectionExpr.Syntax, MessageID.IDS_FeatureInlineArrays, diagnostics); 896_ = GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_Unsafe__AsRef_T, diagnostics, syntax: collectionExpr.Syntax); 899_ = GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_Unsafe__Add_T, diagnostics, syntax: collectionExpr.Syntax); 900_ = GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_Unsafe__As_T, diagnostics, syntax: collectionExpr.Syntax); 902CheckInlineArrayTypeIsSupported(collectionExpr.Syntax, collectionExpr.Type, elementField.Type, diagnostics); 910diagnostics.Add(ErrorCode.ERR_InlineArrayForEachNotSupported, collectionExpr.Syntax.GetLocation(), collectionExpr.Type); 1143collectionExpr.Syntax, 1208diagnostics.Add(ErrorCode.ERR_NullNotValid, collectionExpr.Syntax.Location); 1257CheckFeatureAvailability(expr.Syntax, MessageID.IDS_FeatureDisposalPattern, diagnostics); 1276Error(diagnostics, ErrorCode.ERR_BadAllowByRefLikeEnumerator, expr.Syntax, enumeratorType); 1575collectionExpr.Syntax, 1588collectionExpr.Syntax, 1597collectionExpr.Syntax,

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

344var typedTemp = new BoundDagTemp(te.Syntax, te.Type, te); 359var typedTemp = new BoundDagTemp(te.Syntax, te.Type, te); 403var lengthTemp = new BoundDagTemp(lengthOrCount.Syntax, lengthOrCount.Property.Type, lengthOrCount); 431var indexerTemp = new BoundDagTemp(e.Syntax, e.IndexerType, e); 450var sliceTemp = new BoundDagTemp(slice.Syntax, slice.SliceType, slice); 479var elementTemp = new BoundDagTemp(e.Syntax, e.Field.Type, e); 547var elementTemp = new BoundDagTemp(e.Syntax, method.Parameters[j + extensionExtra].Type, e, j); 566var subInput = new BoundDagTemp(e.Syntax, e.Field.Type, e); 573var subInput = new BoundDagTemp(e.Syntax, e.Property.Type, e);

286RoslynDebug.Assert(added, $"Expression {expr} `{expr.Syntax}` visited more than once."); 299RoslynDebug.Assert(_visited.Contains(expr), $"Expected {expr} `{expr.Syntax}` to be visited."); 543ValidateAssignment(node.Syntax, node.Left, node.Right, node.IsRef, _diagnostics); 557node.Syntax, 571node.Syntax, 586ValidateAssignment(node.Syntax, node.Left, node, isRef: false, _diagnostics); 694ValidateRefConditionalOperator(node.Syntax, node.Consequence, node.Alternative, _diagnostics); 724node.Syntax, 825node.Syntax, 881Error(_diagnostics, ErrorCode.ERR_CallArgMixing, argument.Syntax, constructor, parameter.Name); 907node.Syntax, 930node.Syntax, 980VisitDeconstructionArguments(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)

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

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

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

71diagnostics.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;

637public 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; } } 72public MessageID MessageID { get { return Syntax.Kind() == SyntaxKind.AnonymousMethodExpression ? MessageID.IDS_AnonMethod : MessageID.IDS_Lambda; } } 80SyntaxNode IBoundLambdaOrFunction.Syntax { get { return Syntax; } } 429var lambda = new UnboundLambda(Syntax, data, FunctionType, WithDependencies, nullableState, HasErrors); 442var lambda = new UnboundLambda(Syntax, data, FunctionType, WithDependencies, _nullableState, HasErrors); 595Binder.RecordLambdaBinding(UnboundLambda.Syntax); 614this.Binder.GenerateAnonymousFunctionConversionError(diagnostics, _unboundLambda.Syntax, _unboundLambda, targetType); 738var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder)); 786_unboundLambda.Syntax, 833lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder), inExpressionTree ? BinderFlags.InExpressionTree : BinderFlags.None); 896var result = new BoundLambda(_unboundLambda.Syntax, _unboundLambda, block, diagnostics.ToReadOnlyAndFree(), lambdaBodyBinder, delegateType, inferredReturnType: default) 992_unboundLambda.Syntax, 1021var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder)); 1242_unboundLambda.Syntax, 1510public override MessageID MessageID { get { return this.UnboundLambda.Syntax.Kind() == SyntaxKind.AnonymousMethodExpression ? MessageID.IDS_AnonMethod : MessageID.IDS_Lambda; } } 1516return UnboundLambda.Syntax.AnonymousFunctionBody(); 1523var 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;

193result = AllocateTemp(_method.ReturnType, _boundBody.Syntax, slotConstraints); 368SyntaxNode syntax = node.Syntax; 443Debug.Assert(node.Syntax is { }); 447EmitStepThroughSequencePoint(node.Syntax, span); 452EmitStepThroughSequencePoint(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); 232EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 243EmitSymbolToken(conversion.Type, conversion.Syntax); 251EmitStaticCast(conversion.Type, conversion.Syntax); 264EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 275EmitSymbolToken(conversion.Type, conversion.Syntax); 280EmitSymbolToken(conversion.Type, conversion.Syntax); 337EmitSymbolToken(receiver.Type, receiver.Syntax); 345EmitBox(receiver.Type, receiver.Syntax); 368EmitSymbolToken(method, node.Syntax, null); 373var ctor = DelegateConstructor(node.Syntax, delegateType); 374if ((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); 771EmitLoadIndirect(expression.Type, expression.Syntax); 792EmitLoadIndirect(expression.Type, expression.Syntax); 814EmitLoadIndirect(thisType, thisRef.Syntax); 834var syntax = node.Syntax; 880DefineLocal(local, sequence.Syntax); 914var seqLocal = DefineLocal(local, sequence.Syntax); 1094EmitSymbolToken(elementType, arrayAccess.Syntax); 1101_builder.EmitArrayElementLoad(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Expression.Syntax); 1146EmitLoadIndirect(field.Type, fieldAccess.Syntax); 1165EmitSymbolToken(field, fieldAccess.Syntax); 1192EmitSymbolToken(field, fieldAccess.Syntax); 1238EmitSymbolToken(receiver.Type, receiver.Syntax); 1252EmitSymbolToken(field, fieldAccess.Syntax); 1414EmitLoadIndirect(local.LocalSymbol.Type, local.Syntax); 1427EmitLoadIndirect(parameterType, parameter.Syntax); 1650EmitSymbolToken(method.ContainingType, call.Syntax); 1674EmitSymbolToken(receiver.Type, receiver.Syntax); 1679EmitSymbolToken(method, call.Syntax, 1682EmitCallCleanup(call.Syntax, useKind, method); 1773EmitBox(parentCallReceiverType, nested.Syntax); 1792tempOpt = this.AllocateTemp(parentCallReceiverType, nested.Syntax); 1926EmitBox(receiverType, receiver.Syntax); 2008EmitSymbolToken(receiver.Type, receiver.Syntax); 2013EmitSymbolToken(actualMethodTargetedByTheCall, call.Syntax, 2016EmitCallCleanup(call.Syntax, useKind, method); 2051EmitDefaultValue(receiverType, true, receiver.Syntax); 2052EmitBox(receiverType, receiver.Syntax); 2059EmitLoadIndirect(receiverType, receiver.Syntax); 2060tempOpt = AllocateTemp(receiverType, receiver.Syntax); 2381EmitSymbolToken(arrayType.ElementType, expression.Syntax); 2385_builder.EmitArrayCreation(_module.Translate(arrayType), expression.Syntax); 2426EmitInitObj(expression.Type, used, expression.Syntax); 2455EmitSymbolToken(constructor, expression.Syntax, 2678EmitSymbolToken(target.Type, target.Syntax); 2712EmitSymbolToken(constructor, objCreation.Syntax, 3051assignmentOperator.Left.Syntax, 3079EmitIndirectStore(local.LocalSymbol.Type, local.Syntax); 3098EmitArrayElementStore(arrayType, expression.Syntax); 3111EmitIndirectStore(expression.Type, expression.Syntax); 3116EmitIndirectStore(expression.Type, expression.Syntax); 3122EmitIndirectStore(expression.Type, expression.Syntax); 3134EmitIndirectStore(expression.Type, expression.Syntax); 3139EmitIndirectStore(expression.Type, expression.Syntax); 3156EmitIndirectStore(nested.Type, expression.Syntax); 3183EmitLoadIndirect(assignment.Type, assignment.Syntax); 3192EmitSymbolToken(thisRef.Type, thisRef.Syntax); 3286EmitIndirectStore(field.Type, fieldAccess.Syntax); 3291EmitSymbolToken(field, fieldAccess.Syntax); 3301EmitIndirectStore(parameter.ParameterSymbol.Type, parameter.Syntax); 3389EmitBox(operand.Type, operand.Syntax); 3392EmitSymbolToken(isOp.TargetType.Type, isOp.Syntax); 3418EmitBox(operandType, operand.Syntax); 3421EmitSymbolToken(targetType, asOp.Syntax); 3426EmitSymbolToken(targetType, asOp.Syntax); 3472EmitDefaultValue(expression.Type, used, expression.Syntax); 3512EmitSymbolToken(getTypeMethod, boundTypeOf.Syntax, null); 3519EmitSymbolToken(type, boundTypeOfOperator.SourceType.Syntax); 3527EmitSymbolToken(type, boundSizeOfOperator.SourceType.Syntax); 3545EmitSymbolToken(symbol, node.Syntax, null, encodeAsRawDefinitionToken: true); 3558EmitHoistedVariableId(node.HoistedField, node.Syntax); 3572EmitHoistedVariableId(node.HoistedField, node.Syntax); 3607_module.GetModuleVersionId(_module.Translate(node.Type, node.Syntax, _diagnostics.DiagnosticBag), node.Syntax, _diagnostics.DiagnosticBag), 3608node.Syntax); 3661_builder.EmitToken(_module.GetInstrumentationPayloadRoot(node.AnalysisKind, _module.Translate(node.Type, node.Syntax, _diagnostics.DiagnosticBag), node.Syntax, _diagnostics.DiagnosticBag), node.Syntax); 3674EmitSymbolToken(node.Method, node.Syntax, null); 3687EmitSymbolToken(node.Method.ContainingType, node.Syntax); 3691EmitSymbolToken(getMethod, node.Syntax, null); 3695EmitSymbolToken(node.Type, node.Syntax); 3702EmitSymbolToken(node.Field, node.Syntax); 3714EmitSymbolToken(node.Field.ContainingType, node.Syntax); 3718EmitSymbolToken(getField, node.Syntax, null); 3722EmitSymbolToken(node.Type, node.Syntax); 3789EmitStaticCast(expr.Type, expr.Syntax); 3794EmitStaticCast(expr.Type, expr.Syntax); 3813EmitStaticCast(expr.Type, expr.Syntax); 3818EmitStaticCast(expr.Type, expr.Syntax); 3850EmitStaticCast(expr.Type, expr.Syntax); 3855EmitStaticCast(expr.Type, expr.Syntax); 3863EmitBox(expr.Type, expr.LeftOperand.Syntax); 3880EmitStaticCast(expr.Type, expr.Syntax); 4024temp = AllocateTemp(ptrInvocation.InvokedExpression.Type, ptrInvocation.Syntax); 4039EmitSignatureToken(ptrInvocation.FunctionPointer, ptrInvocation.Syntax); 4040EmitCallCleanup(ptrInvocation.Syntax, useKind, method); 4111EmitSymbolToken(load.ConstrainedToTypeOpt, load.Syntax); 4115EmitSymbolToken(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); 753DefineLocal(local, !declaringReferences.IsEmpty ? (CSharpSyntaxNode)declaringReferences[0].GetSyntax() : block.Syntax); 858(boundReturnStatement.Syntax.IsKind(SyntaxKind.Block) || _method?.IsImplicitConstructor == true) && 915_module.Translate(expressionOpt.Type, boundReturnStatement.Syntax, _diagnostics.DiagnosticBag); 1049_module.Translate(catchBlock.ExceptionTypeOpt, catchBlock.Syntax, _diagnostics.DiagnosticBag) : 1050_module.GetSpecialType(SpecialType.System_Object, catchBlock.Syntax, _diagnostics.DiagnosticBag); 1064var syntax = catchBlock.Syntax as CatchClauseSyntax; 1096var exceptionType = _module.Translate(catchBlock.ExceptionTypeOpt, catchBlock.Syntax, _diagnostics.DiagnosticBag); 1099_builder.EmitToken(exceptionType, catchBlock.Syntax); 1117var localSyntax = !declaringReferences.IsEmpty ? (CSharpSyntaxNode)declaringReferences[0].GetSyntax() : catchBlock.Syntax; 1131EmitSymbolToken(exceptionSourceOpt.Type, exceptionSourceOpt.Syntax); 1169var temp = AllocateTemp(exceptionSource.Type, exceptionSource.Syntax); 1301temp = AllocateTemp(expression.Type, expression.Syntax); 1315this.EmitStringSwitchJumpTable(switchCaseLabels, fallThroughLabel, key, expression.Syntax, expression.Type); 1319this.EmitLengthBasedStringSwitchJumpTable(lengthBasedSwitchStringJumpTableOpt, fallThroughLabel, key, expression.Syntax, expression.Type); 1324_builder.EmitIntegerSwitchJumpTable(switchCaseLabels, fallThroughLabel, key, expression.Type.EnumUnderlyingTypeOrSelf().PrimitiveTypeCode, expression.Syntax);

1657PushEvalStack(new BoundDefaultExpression(node.Syntax, node.Operand.Type), ExprContext.Value); 2133return new BoundDup(node.Syntax, node.LocalSymbol.RefKind, node.Type); 2195return new BoundRefArrayAccess(arrayAccess.Syntax, arrayAccess);

2050boundNodeForSyntacticParent.Syntax.Kind() == SyntaxKind.ObjectCreationExpression && 2051((ObjectCreationExpressionSyntax)boundNodeForSyntacticParent.Syntax).Type == boundExpr.Syntax)) // Do not return any type information for a ObjectCreationExpressionSyntax.Type node. 2219var binder = this.GetEnclosingBinder(boundExpr.Syntax.Span.Start); 3382if (expr.Syntax.Kind() is SyntaxKind.ObjectCreationExpression or SyntaxKind.ImplicitObjectCreationExpression) 3409boundNodeForSyntacticParent.Syntax.Kind() == SyntaxKind.ObjectCreationExpression && 3410((ObjectCreationExpressionSyntax)boundNodeForSyntacticParent.Syntax).Type == boundType.Syntax && 3693Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 3985SyntaxNode parentSyntax = boundNodeForSyntacticParent.Syntax; 3987parentSyntax == boundNode.Syntax.Parent && 3988parentSyntax.Kind() == SyntaxKind.Attribute && ((AttributeSyntax)parentSyntax).Name == boundNode.Syntax) 4035Debug.Assert(binderOpt != null || IsInTree(lowestBoundNode.Syntax)); 4039Debug.Assert(lowestBoundNode.Syntax != null); 4044Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(lowestBoundNode.Syntax)); 4095Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4104Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 4252Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4265Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 4277InvocationExpressionSyntax invocation = call.Syntax as InvocationExpressionSyntax; 4278if (invocation != null && invocation.Expression.SkipParens() == ((ExpressionSyntax)boundNode.Syntax).SkipParens() && (object)call.Method != null) 4404Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4426var elementAccess = indexer.Syntax as ElementAccessExpressionSyntax; 4427if (elementAccess != null && elementAccess.Expression == boundNode.Syntax && (object)indexer.Indexer != null)

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

1459alreadyInTree = _guardedBoundNodeMap.ContainsKey(bound.Syntax); 1467Debug.Assert(syntax != _root || _guardedBoundNodeMap.ContainsKey(bound.Syntax)); 1491alreadyInTree = _guardedBoundNodeMap.ContainsKey(bound.Syntax); 1503Debug.Assert(syntax != _root || _guardedBoundNodeMap.ContainsKey(bound.Syntax)); 1812return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, unbound.Syntax), 1813position, unbound.BindForErrorRecovery().Binder, unbound.Syntax); 1816return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, lambda.Body.Syntax), 1817position, lambda.Binder, lambda.Body.Syntax); 1825return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, queryClause.Syntax), 1826position, queryClause.Binder, queryClause.Syntax); 1841var span = expr.Syntax.FullSpan; 1860if (value.Syntax.FullSpan.Contains(position)) 1865if (expr.Syntax.FullSpan.Contains(position)) 1954_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; 530var syntax = block.Syntax;

1001body = BoundBlock.SynthesizedNoLocals(initializerStatements.Syntax, initializerStatements.Statements); 1034new BoundBlock(analyzedInitializers.Syntax, ImmutableArray<LocalSymbol>.Empty, analyzedInitializers.Statements), // The block is necessary to establish the right local scope for the analysis 1157var syntax = body.Syntax; 1584return new BoundBadStatement(body.Syntax, ImmutableArray.Create<BoundNode>(body), hasErrors: true); 1970body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer)); 1974body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer, body)); 2323if (!LambdaUtilities.TryGetLambdaBodies(node.Syntax, out var body1, out var body2)) 2458var constructorInitializer = new BoundExpressionStatement(initializerInvocation.Syntax, initializerInvocation) { WasCompilerGenerated = method.IsImplicitlyDeclared }; 2473compilationState.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); 1625VisitLocalFunctionUse(localFunc, node.Syntax, isCall: false); 1754VisitLocalFunctionUse(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(); 302var location = new SourceLocation(branch.Branch.Syntax.GetFirstToken()); 340var sourceLocation = node.Syntax.Location; 378var 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); 1521CheckAssigned(fieldAccess, node.Syntax); 1625LeaveParameter(param, node.Syntax, paramExpr.Syntax.Location); 2367if ((localSymbol as SourceLocalSymbol)?.IsVar == true && localSymbol.ForbiddenZone?.Contains(node.Syntax) == true) 2381CheckAssigned(localSymbol, node.Syntax); 2388Diagnostics.Add(ErrorCode.ERR_FixedLocalInLambda, new SourceLocation(node.Syntax), localSymbol); 2456LeaveParameters(node.Symbol.Parameters, node.Syntax, null); 2465LeaveParameters(node.Symbol.Parameters, pending.Branch.Syntax, null); 2484CheckAssigned(MethodThisParameter, node.Syntax); 2492CheckAssigned(node.ParameterSymbol, node.Syntax); 2563if (_unassignedVariableAddressOfSyntaxes?.Contains(node.Syntax as PrefixUnaryExpressionSyntax) == false) 2570_unsafeAddressTakenVariables.Add(variable, node.Syntax.Location); 2587CheckAssigned(arg, arg.Syntax); 2686CheckAssigned(MethodThisParameter, node.Syntax); 2713if (node.FieldSymbol.IsFixedSizeBuffer && node.Syntax != null && !SyntaxFacts.IsFixedStatementExpression(node.Syntax)) 2721_unsafeAddressTakenVariables.Add(receiver, node.Syntax.Location); 2728CheckAssigned(node, node.FieldSymbol, node.Syntax); 2749ReportUnassignedIfNotCapturedInLocalFunction(backingField, node.Syntax, unassignedSlot); 2768CheckAssigned(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 }; 117var F = new SyntheticBoundNodeFactory(method, body.Syntax, compilationState, diagnostics); 192SyntaxNode syntax = body.Syntax;

623enforceMemberNotNull(syntaxOpt: pendingReturn.Branch.Syntax, pendingReturn.State); 627EnforceParameterNotNullOnExit(returnStatement.Syntax, pendingReturn.State); 1064_ => syntaxOpt ?? (SyntaxNodeOrToken)methodMainNode.Syntax.GetLastToken() 1079enforceMemberNotNullWhen(returnStatement.Syntax, sense: value, pendingReturn.State); 1092enforceMemberNotNullWhenIfAffected(returnStatement.Syntax, sense: true, members: method.ContainingType.GetMembers(memberName), state: pendingReturn.StateWhenTrue, otherState: pendingReturn.StateWhenFalse); 1097enforceMemberNotNullWhenIfAffected(returnStatement.Syntax, sense: false, members: method.ContainingType.GetMembers(memberName), state: pendingReturn.StateWhenFalse, otherState: pendingReturn.StateWhenTrue); 1137Diagnostics.Add(ErrorCode.WRN_MemberNotNullWhen, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name, sense ? "true" : "false"); 1244EnforceParameterNotNullWhenOnExit(returnStatement.Syntax, parameters, sense: value, stateWhen: pendingReturn.State); 1258ReportParameterIfBadConditionalState(returnStatement.Syntax, parameter, sense: true, stateWhen: pendingReturn.StateWhenTrue); 1259ReportParameterIfBadConditionalState(returnStatement.Syntax, parameter, sense: false, stateWhen: pendingReturn.StateWhenFalse); 1266EnforceParameterNotNullWhenOnExit(returnStatement.Syntax, parameters, sense: value, stateWhen: pendingReturn.State); 1305location = syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(); 1391var location = syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(); 1414ReportDiagnostic(ErrorCode.WRN_ShouldNotReturn, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation()); 1468compilation.GetBinderFactory(node.SyntaxTree).GetBinder(node.Syntax); 1906var key = (object?)symbol ?? methodMainNode.Syntax; 1949RoslynDebug.Assert(AreCloseEnough(originalSymbol, updatedSymbol), $"Attempting to set {node.Syntax} from {originalSymbol.ToDisplayString()} to {updatedSymbol.ToDisplayString()}"); 2416location ??= value.Syntax.GetLocation(); 3015CheckDisallowedNullAssignment(resultType, parameterAnnotations, equalsValue.Value.Syntax); 3042EnforceDoesNotReturn(node.Syntax); 3072CheckDisallowedNullAssignment(returnState, ToInwardAnnotations(returnAnnotations), node.Syntax, boundValueOpt: expr); 3084EnforceDoesNotReturn(node.Syntax); 3101EnforceNotNullIfNotNull(node.Syntax, this.State, parameters, method.ReturnNotNullIfParameterNotNull, ResultType.State, outputParam: null); 3119ReportNullabilityMismatchInAssignment(expr.Syntax, lvalueResultType, destinationType); 3179if (local is SourceLocalSymbol { IsVar: true } && local.ForbiddenZone?.Contains(node.Syntax) == true) 3458enforceMemberNotNull(syntax: pendingReturn.Branch?.Syntax, pendingReturn.State); 3463EnforceParameterNotNullOnExit(returnStatement.Syntax, pendingReturn.State); 4023var foundIterationType = _binder.TryGetCollectionIterationType((ExpressionSyntax)node.Syntax, collectionType, out targetElementType); 4030_binder.TryGetCollectionIterationType(node.Syntax, collectionType, out targetElementType); 4448ReportDiagnostic(ErrorCode.WRN_NullReferenceInitializer, initializer.Syntax, symbol); 5314MethodSymbol reinferredMethod = ReInferBinaryOperator(binary.Syntax, method, leftOperand, rightOperand, leftUnderlyingType, rightUnderlyingType); 5403[new BoundExpressionWithNullability(leftOperand.Syntax, leftOperand, leftUnderlyingType.ToTypeWithAnnotations(compilation).NullableAnnotation, leftUnderlyingType.Type), 5404new BoundExpressionWithNullability(rightOperand.Syntax, rightOperand, rightUnderlyingType.ToTypeWithAnnotations(compilation).NullableAnnotation, rightUnderlyingType.Type)], 5472if (CheckDisallowedNullAssignment(resultType, parameterAnnotations, expr.Syntax, operand)) 6372ReportNullabilityMismatchInAssignment(node.Syntax, source, destination); 6433new BoundExpressionWithNullability(expr.Syntax, expr, type.NullableAnnotation, type.Type); 7112var syntax = node.Syntax; 7259var syntaxForConstraintCheck = node.Syntax switch 7263_ => node.Syntax 7828ReportNullabilityMismatchInArgument(argumentNoConversion.Syntax, argumentResultType, parameter, parameterType.Type, forOutput: false); 7848if (CheckDisallowedNullAssignment(stateAfterConversion, parameterAnnotations, argumentNoConversion.Syntax)) 7870CheckDisallowedNullAssignment(resultType, parameterAnnotations, argumentNoConversion.Syntax); 7970var parameterValue = new BoundParameter(argument.Syntax, parameter); 8010var parameterValue = new BoundParameter(argument.Syntax, parameter); 8013CheckDisallowedNullAssignment(parameterWithState, leftAnnotations, argument.Syntax); 8026ReportNullabilityMismatchInArgument(argument.Syntax, lValueType.Type, parameter, parameterType.Type, forOutput: true); 8438return new BoundUnconvertedCollectionExpression(collection.Syntax, elementsBuilder.ToImmutableAndFree()) { WasCompilerGenerated = true }; 8452return new BoundExpressionWithNullability(argument.Syntax, argument, NullableAnnotation.Oblivious, type: null); 8455return new BoundExpressionWithNullability(argument.Syntax, argument, argumentType.NullableAnnotation, argumentType.Type); 8579ReportNullabilityMismatchInAssignment(sourceExpression.Syntax, GetTypeAsDiagnosticArgument(sourceType), destinationType); 8934var locations = tupleOpt.TupleElements.SelectAsArray((element, location) => element.TryGetFirstLocation() ?? location, node.Syntax.Location); 8938tupleOpt.CheckConstraints(new ConstraintsHelper.CheckConstraintsArgs(compilation, _conversions, includeNullability: true, node.Syntax.Location, diagnostics: null), 8939typeSyntax: node.Syntax, locations, nullabilityDiagnosticsOpt: diagnostics); 9107diagnosticLocation: (conversionOpt ?? convertedNode).Syntax.GetLocation()); 9180if (lambda.Syntax is LambdaExpressionSyntax lambdaSyntax) 9620diagnosticLocation ??= (conversionOpt ?? conversionOperand).Syntax.GetLocation(); 9890Location operandLocation = conversionOperand.Syntax.GetLocation(); 9903if (!isLiftedConversion && CheckDisallowedNullAssignment(operandType, parameterAnnotations, conversionOperand.Syntax)) 9978conversionOpt.Syntax.SpanStart != convertedNode.Syntax.SpanStart) 10177ReportNullabilityMismatchWithTargetDelegate(group.Syntax.Location, delegateType, delegateInvokeMethod, method, node.IsExtensionMethod); 10249ReportNullabilityMismatchWithTargetDelegate(arg.Syntax.Location, delegateType, delegateInvokeMethod, argInvokeMethod, invokedAsExtensionMethod: false); 10307var syntax = group.Syntax; 10313if (method.GetMemberArityIncludingExtension() != 0 && HasImplicitTypeArguments(group.Syntax)) 10489CheckDisallowedNullAssignment(rightState, leftAnnotations, right.Syntax); 10704placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 10714CheckMethodConstraints(invocation.Syntax, deconstructMethod); 10829CheckDisallowedNullAssignment(valueType, leftAnnotations, right.Syntax); 10930return fields.SelectAsArray((f, e) => (BoundExpression)new BoundFieldAccess(e.Syntax, e, f, constantValueOpt: null), expr); 11016incrementOperator = ReInferUnaryOperator(node.Syntax, incrementOperator, node.Operand, GetNullableUnderlyingTypeIfNecessary(isLifted, operandType)); 11235CheckDisallowedNullAssignment(resultTypeWithState, leftArgumentAnnotations, node.Syntax); 11273argument.Syntax, argumentType, parameterType, 11709ReportDiagnostic(ErrorCode.WRN_NullReferenceReceiver, expr.Syntax.GetLocation()); 11763var variableLocation = node.Syntax switch 11767_ => throw ExceptionUtilities.UnexpectedValue(node.Syntax) 11798var foreachSyntax = (ForEachStatementSyntax)node.Syntax; 11953method = ReInferUnaryOperator(node.Syntax, method, operand, operandType); 12007[new BoundExpressionWithNullability(operand.Syntax, operand, operandType.ToTypeWithAnnotations(compilation).NullableAnnotation, operandType.Type)], 12169MethodSymbol reInferredMethod = ReInferBinaryOperator(binary.Syntax, logicalOperator, leftOperand, rightOperand, leftUnderlyingType, rightUnderlyingType); 12185var updatedTrueFalseOperator = ReInferUnaryOperator(leftOperand.Syntax, trueFalseOperator, binary.Left, leftType); 12600if (!ReportPossibleNullReceiverIfNeeded(resultTypeSymbol, resultType.State, checkNullableValueType, receiverOpt.Syntax, out reportedDiagnostic)) 12777ReportDiagnostic(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); 536var output = new BoundDagTemp(e.Syntax, type.Type, e); 561var output = new BoundDagTemp(e.Syntax, type.Type, e); 573var output = new BoundDagTemp(e.Syntax, type.Type, e); 840var output = new BoundDagTemp(e.Syntax, type.Type, e, index: index); 892var labelStateMap = LearnFromDecisionDag(node.Syntax, node.ReachabilityDecisionDag, node.Expression, expressionState, stateWhenNotNullOpt: null); 907((SwitchExpressionSyntax)node.Syntax).SwitchKeyword.GetLocation(), 1060var 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); 501var result = new BoundCapturedReceiverPlaceholder(this.Syntax, receiver, localScopeDepth, type, this.HasErrors); 542var result = new BoundDeconstructValuePlaceholder(this.Syntax, variableSymbol, isDiscardExpression, type, this.HasErrors); 577var result = new BoundTupleOperandPlaceholder(this.Syntax, type, this.HasErrors); 606var result = new BoundAwaitableValuePlaceholder(this.Syntax, type, this.HasErrors); 641var result = new BoundDisposableValuePlaceholder(this.Syntax, type, this.HasErrors); 679var result = new BoundObjectOrCollectionValuePlaceholder(this.Syntax, isNewInstance, type, this.HasErrors); 714var result = new BoundImplicitIndexerValuePlaceholder(this.Syntax, type, this.HasErrors); 752var result = new BoundImplicitIndexerReceiverPlaceholder(this.Syntax, isEquivalentToThisReference, type, this.HasErrors); 787var result = new BoundListPatternReceiverPlaceholder(this.Syntax, type, this.HasErrors); 822var result = new BoundListPatternIndexPlaceholder(this.Syntax, type, this.HasErrors); 857var result = new BoundSlicePatternReceiverPlaceholder(this.Syntax, type, this.HasErrors); 892var result = new BoundSlicePatternRangePlaceholder(this.Syntax, type, this.HasErrors); 923var result = new BoundDup(this.Syntax, refKind, type, this.HasErrors); 951var result = new BoundPassByCopy(this.Syntax, expression, type, this.HasErrors); 984var result = new BoundBadExpression(this.Syntax, resultKind, symbols, childBoundNodes, type, this.HasErrors); 1012var result = new BoundBadStatement(this.Syntax, childBoundNodes, this.HasErrors); 1040var result = new BoundExtractedFinallyBlock(this.Syntax, finallyBlock, this.HasErrors); 1075var result = new BoundTypeExpression(this.Syntax, aliasOpt, boundContainingTypeOpt, boundDimensionsOpt, typeWithAnnotations, type, this.HasErrors); 1113var result = new BoundTypeOrValueExpression(this.Syntax, data, type, this.HasErrors); 1154var result = new BoundNamespaceExpression(this.Syntax, namespaceSymbol, aliasOpt, this.HasErrors); 1196var result = new BoundUnaryOperator(this.Syntax, operatorKind, operand, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1244var result = new BoundIncrementOperator(this.Syntax, operatorKind, operand, methodOpt, constrainedToTypeOpt, operandPlaceholder, operandConversion, resultPlaceholder, resultConversion, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1276var result = new BoundAddressOfOperator(this.Syntax, operand, isManaged, type, this.HasErrors); 1305var result = new BoundUnconvertedAddressOfOperator(this.Syntax, operand, this.HasErrors); 1348var result = new BoundFunctionPointerLoad(this.Syntax, targetMethod, constrainedToTypeOpt, type, this.HasErrors); 1380var result = new BoundPointerIndirectionOperator(this.Syntax, operand, refersToLocation, type, this.HasErrors); 1417var result = new BoundPointerElementAccess(this.Syntax, expression, index, @checked, refersToLocation, type, this.HasErrors); 1454var result = new BoundFunctionPointerInvocation(this.Syntax, invokedExpression, arguments, argumentRefKindsOpt, resultKind, type, this.HasErrors); 1486var result = new BoundRefTypeOperator(this.Syntax, operand, getTypeFromHandle, type, this.HasErrors); 1516var result = new BoundMakeRefOperator(this.Syntax, operand, type, this.HasErrors); 1548var result = new BoundRefValueOperator(this.Syntax, nullableAnnotation, operand, type, this.HasErrors); 1580var result = new BoundFromEndIndexExpression(this.Syntax, operand, methodOpt, type, this.HasErrors); 1613var result = new BoundRangeExpression(this.Syntax, leftOperandOpt, rightOperandOpt, methodOpt, type, this.HasErrors); 1666var result = new BoundBinaryOperator(this.Syntax, operatorKind, data, resultKind, left, right, type, this.HasErrors); 1704var result = new BoundTupleBinaryOperator(this.Syntax, left, right, operatorKind, operators, type, this.HasErrors); 1757var result = new BoundUserDefinedConditionalLogicalOperator(this.Syntax, operatorKind, logicalOperator, trueOperator, falseOperator, trueFalseOperandPlaceholder, trueFalseOperandConversion, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, left, right, type, this.HasErrors); 1804var result = new BoundCompoundAssignmentOperator(this.Syntax, @operator, left, right, leftPlaceholder, leftConversion, finalPlaceholder, finalConversion, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1838var result = new BoundAssignmentOperator(this.Syntax, left, right, isRef, type, this.HasErrors); 1873var result = new BoundDeconstructionAssignmentOperator(this.Syntax, left, right, isUsed, type, this.HasErrors); 1914var result = new BoundNullCoalescingOperator(this.Syntax, leftOperand, rightOperand, leftPlaceholder, leftConversion, operatorResultKind, @checked, type, this.HasErrors); 1945var result = new BoundNullCoalescingAssignmentOperator(this.Syntax, leftOperand, rightOperand, type, this.HasErrors); 1984var result = new BoundUnconvertedConditionalOperator(this.Syntax, condition, consequence, alternative, constantValueOpt, noCommonTypeError, this.HasErrors); 2028var result = new BoundConditionalOperator(this.Syntax, isRef, condition, consequence, alternative, constantValueOpt, naturalTypeOpt, wasTargetTyped, type, this.HasErrors); 2061var result = new BoundArrayAccess(this.Syntax, expression, indices, type, this.HasErrors); 2090var result = new BoundRefArrayAccess(this.Syntax, arrayAccess, this.HasErrors); 2120var result = new BoundArrayLength(this.Syntax, expression, type, this.HasErrors); 2153var result = new BoundAwaitableInfo(this.Syntax, awaitableInstancePlaceholder, isDynamic, getAwaiter, isCompleted, getResult, this.HasErrors); 2188var result = new BoundAwaitExpression(this.Syntax, expression, awaitableInfo, debugInfo, type, this.HasErrors); 2241var result = new BoundTypeOfOperator(this.Syntax, sourceType, getTypeFromHandle, type, this.HasErrors); 2273var result = new BoundBlockInstrumentation(this.Syntax, locals, prologue, epilogue, this.HasErrors); 2317var result = new BoundMethodDefIndex(this.Syntax, method, type, this.HasErrors); 2360var result = new BoundLocalId(this.Syntax, local, hoistedField, type, this.HasErrors); 2403var result = new BoundParameterId(this.Syntax, parameter, hoistedField, type, this.HasErrors); 2438var result = new BoundStateMachineInstanceId(this.Syntax, type, this.HasErrors); 2473var result = new BoundMaximumMethodDefIndex(this.Syntax, type, this.HasErrors); 2511var result = new BoundInstrumentationPayloadRoot(this.Syntax, analysisKind, type, this.HasErrors); 2546var result = new BoundThrowIfModuleCancellationRequested(this.Syntax, type, this.HasErrors); 2581var result = new ModuleCancellationTokenExpression(this.Syntax, type, this.HasErrors); 2616var result = new BoundModuleVersionId(this.Syntax, type, this.HasErrors); 2651var result = new BoundModuleVersionIdString(this.Syntax, type, this.HasErrors); 2691var result = new BoundSourceDocumentIndex(this.Syntax, document, type, this.HasErrors); 2734var result = new BoundMethodInfo(this.Syntax, method, getMethodFromHandle, type, this.HasErrors); 2777var result = new BoundFieldInfo(this.Syntax, field, getFieldFromHandle, type, this.HasErrors); 2831var result = new BoundDefaultExpression(this.Syntax, targetType, constantValueOpt, type, this.HasErrors); 2866var result = new BoundIsOperator(this.Syntax, operand, targetType, conversionKind, type, this.HasErrors); 2903var result = new BoundAsOperator(this.Syntax, operand, targetType, operandPlaceholder, operandConversion, type, this.HasErrors); 2935var result = new BoundSizeOfOperator(this.Syntax, sourceType, constantValueOpt, type, this.HasErrors); 2977var result = new BoundConversion(this.Syntax, operand, conversion, isBaseConversion, @checked, explicitCastInCode, constantValueOpt, conversionGroupOpt, type, this.HasErrors); 3010var result = new BoundReadOnlySpanFromArray(this.Syntax, operand, conversionMethod, type, this.HasErrors); 3045var result = new BoundArgList(this.Syntax, type, this.HasErrors); 3076var result = new BoundArgListOperator(this.Syntax, arguments, argumentRefKindsOpt, type, this.HasErrors); 3115var result = new BoundFixedLocalCollectionInitializer(this.Syntax, elementPointerType, elementPointerPlaceholder, elementPointerConversion, expression, getPinnableOpt, type, this.HasErrors); 3154var result = new BoundSequencePoint(this.Syntax, statementOpt, this.HasErrors); 3181var result = new BoundSequencePointWithSpan(this.Syntax, statementOpt, span, this.HasErrors); 3218var result = new BoundSavePreviousSequencePoint(this.Syntax, identifier, this.HasErrors); 3255var result = new BoundRestorePreviousSequencePoint(this.Syntax, identifier, this.HasErrors); 3286var result = new BoundStepThroughSequencePoint(this.Syntax, span, this.HasErrors); 3322var result = new BoundBlock(this.Syntax, locals, localFunctions, hasUnsafeModifier, instrumentation, statements, this.HasErrors); 3351var result = new BoundScope(this.Syntax, locals, statements, this.HasErrors); 3382var result = new BoundStateMachineScope(this.Syntax, fields, statement, this.HasErrors); 3418var result = new BoundLocalDeclaration(this.Syntax, localSymbol, declaredTypeOpt, initializerOpt, argumentsOpt, inferredType, this.HasErrors); 3458var result = new BoundMultipleLocalDeclarations(this.Syntax, localDeclarations, this.HasErrors); 3488var result = new BoundUsingLocalDeclarations(this.Syntax, patternDisposeInfoOpt, awaitOpt, localDeclarations, this.HasErrors); 3520var result = new BoundLocalFunctionStatement(this.Syntax, symbol, blockBody, expressionBody, this.HasErrors); 3551var result = new BoundNoOpStatement(this.Syntax, flavor, this.HasErrors); 3580var result = new BoundReturnStatement(this.Syntax, refKind, expressionOpt, @checked, this.HasErrors); 3608var result = new BoundYieldReturnStatement(this.Syntax, expression, this.HasErrors); 3650var result = new BoundThrowStatement(this.Syntax, expressionOpt, this.HasErrors); 3678var result = new BoundExpressionStatement(this.Syntax, expression, this.HasErrors); 3715var result = new BoundBreakStatement(this.Syntax, label, this.HasErrors); 3752var result = new BoundContinueStatement(this.Syntax, label, this.HasErrors); 3797var result = new BoundSwitchStatement(this.Syntax, expression, innerLocals, innerLocalFunctions, switchSections, reachabilityDecisionDag, defaultLabel, breakLabel, this.HasErrors); 3833var result = new BoundSwitchDispatch(this.Syntax, expression, cases, defaultLabel, lengthBasedStringSwitchDataOpt, this.HasErrors); 3866var result = new BoundIfStatement(this.Syntax, condition, consequence, alternativeOpt, this.HasErrors); 3946var result = new BoundDoStatement(this.Syntax, locals, condition, body, breakLabel, continueLabel, this.HasErrors); 3976var result = new BoundWhileStatement(this.Syntax, locals, condition, body, breakLabel, continueLabel, this.HasErrors); 4018var result = new BoundForStatement(this.Syntax, outerLocals, initializer, innerLocals, condition, increment, body, breakLabel, continueLabel, this.HasErrors); 4069var result = new BoundForEachStatement(this.Syntax, enumeratorInfoOpt, elementPlaceholder, elementConversion, iterationVariableType, iterationVariables, iterationErrorExpressionOpt, expression, deconstructionOpt, awaitOpt, body, breakLabel, continueLabel, this.HasErrors); 4100var result = new BoundForEachDeconstructStep(this.Syntax, deconstructionAssignment, targetPlaceholder, this.HasErrors); 4139var result = new BoundUsingStatement(this.Syntax, locals, declarationsOpt, expressionOpt, body, awaitOpt, patternDisposeInfoOpt, this.HasErrors); 4173var result = new BoundFixedStatement(this.Syntax, locals, declarations, body, this.HasErrors); 4204var result = new BoundLockStatement(this.Syntax, argument, body, this.HasErrors); 4241var result = new BoundTryStatement(this.Syntax, tryBlock, catchBlocks, finallyBlockOpt, finallyLabelOpt, preferFaultHandler, this.HasErrors); 4282var result = new BoundCatchBlock(this.Syntax, locals, exceptionSourceOpt, exceptionTypeOpt, exceptionFilterPrologueOpt, exceptionFilterOpt, body, isSynthesizedAsyncCatchAll, this.HasErrors); 4313var result = new BoundLiteral(this.Syntax, constantValueOpt, type, this.HasErrors); 4353var result = new BoundUtf8String(this.Syntax, value, type, this.HasErrors); 4388var result = new BoundThisReference(this.Syntax, type, this.HasErrors); 4423var result = new BoundPreviousSubmissionReference(this.Syntax, type, this.HasErrors); 4458var result = new BoundHostObjectMemberReference(this.Syntax, type, this.HasErrors); 4487var result = new BoundBaseReference(this.Syntax, type, this.HasErrors); 4536var result = new BoundLocal(this.Syntax, localSymbol, declarationKind, constantValueOpt, isNullableUnknown, type, this.HasErrors); 4581var result = new BoundPseudoVariable(this.Syntax, localSymbol, emitExpressions, type, this.HasErrors); 4614var result = new BoundRangeVariable(this.Syntax, rangeVariableSymbol, value, type, this.HasErrors); 4654var result = new BoundParameter(this.Syntax, parameterSymbol, type, this.HasErrors); 4691var result = new BoundLabelStatement(this.Syntax, label, this.HasErrors); 4723var result = new BoundGotoStatement(this.Syntax, label, caseExpressionOpt, labelExpressionOpt, this.HasErrors); 4754var result = new BoundLabeledStatement(this.Syntax, label, body, this.HasErrors); 4791var result = new BoundLabel(this.Syntax, label, type, this.HasErrors); 4828var result = new BoundStatementList(this.Syntax, statements, this.HasErrors); 4861var result = new BoundConditionalGoto(this.Syntax, condition, jumpIfTrue, label, this.HasErrors); 4924var result = new BoundSwitchExpressionArm(this.Syntax, locals, pattern, whenClause, value, label, this.HasErrors); 4952var result = new BoundUnconvertedSwitchExpression(this.Syntax, expression, switchArms, reachabilityDecisionDag, defaultLabel, reportedNotExhaustive, type, this.HasErrors); 4986var result = new BoundConvertedSwitchExpression(this.Syntax, naturalTypeOpt, wasTargetTyped, expression, switchArms, reachabilityDecisionDag, defaultLabel, reportedNotExhaustive, type, this.HasErrors); 5014var result = new BoundDecisionDag(this.Syntax, rootNode, this.HasErrors); 5059var result = new BoundEvaluationDecisionDagNode(this.Syntax, evaluation, next, this.HasErrors); 5093var result = new BoundTestDecisionDagNode(this.Syntax, test, whenTrue, whenFalse, this.HasErrors); 5128var result = new BoundWhenDecisionDagNode(this.Syntax, bindings, whenExpression, whenTrue, whenFalse, this.HasErrors); 5165var result = new BoundLeafDecisionDagNode(this.Syntax, label, this.HasErrors); 5211var result = new BoundDagTemp(this.Syntax, type, source, index, this.HasErrors); 5240var result = new BoundDagTypeTest(this.Syntax, type, input, this.HasErrors); 5268var result = new BoundDagNonNullTest(this.Syntax, isExplicitTest, input, this.HasErrors); 5294var result = new BoundDagExplicitNullTest(this.Syntax, input, this.HasErrors); 5323var result = new BoundDagValueTest(this.Syntax, value, input, this.HasErrors); 5354var result = new BoundDagRelationalTest(this.Syntax, operatorKind, value, input, this.HasErrors); 5395var result = new BoundDagDeconstructEvaluation(this.Syntax, deconstructMethod, input, this.HasErrors); 5424var result = new BoundDagTypeEvaluation(this.Syntax, type, input, this.HasErrors); 5453var result = new BoundDagFieldEvaluation(this.Syntax, field, input, this.HasErrors); 5484var result = new BoundDagPropertyEvaluation(this.Syntax, property, isLengthOrCount, input, this.HasErrors); 5515var result = new BoundDagIndexEvaluation(this.Syntax, property, index, input, this.HasErrors); 5562var result = new BoundDagIndexerEvaluation(this.Syntax, indexerType, lengthTemp, index, indexerAccess, receiverPlaceholder, argumentPlaceholder, input, this.HasErrors); 5611var result = new BoundDagSliceEvaluation(this.Syntax, sliceType, lengthTemp, startIndex, endIndex, indexerAccess, receiverPlaceholder, argumentPlaceholder, input, this.HasErrors); 5640var result = new BoundDagAssignmentEvaluation(this.Syntax, target, input, this.HasErrors); 5672var result = new BoundSwitchSection(this.Syntax, locals, switchLabels, statements, this.HasErrors); 5705var result = new BoundSwitchLabel(this.Syntax, label, pattern, whenClause, this.HasErrors); 5747var result = new BoundSequencePointExpression(this.Syntax, expression, type, this.HasErrors); 5783var result = new BoundSequence(this.Syntax, locals, sideEffects, value, type, this.HasErrors); 5819var result = new BoundSpillSequence(this.Syntax, locals, sideEffects, value, type, this.HasErrors); 5858var result = new BoundDynamicMemberAccess(this.Syntax, receiver, typeArgumentsOpt, name, invoked, indexed, type, this.HasErrors); 5911var result = new BoundDynamicInvocation(this.Syntax, argumentNamesOpt, argumentRefKindsOpt, applicableMethods, expression, arguments, type, this.HasErrors); 5944var result = new BoundConditionalAccess(this.Syntax, receiver, accessExpression, type, this.HasErrors); 5985var result = new BoundLoweredConditionalAccess(this.Syntax, receiver, hasValueMethodOpt, whenNotNull, whenNullOpt, id, forceCopyOfNullableValueType, type, this.HasErrors); 6023var result = new BoundConditionalReceiver(this.Syntax, id, type, this.HasErrors); 6056var result = new BoundComplexConditionalReceiver(this.Syntax, valueTypeReceiver, referenceTypeReceiver, type, this.HasErrors); 6097var result = new BoundMethodGroup(this.Syntax, typeArgumentsOpt, name, methods, lookupSymbolOpt, lookupError, flags, functionType, receiverOpt, resultKind, this.HasErrors); 6125var result = new BoundPropertyGroup(this.Syntax, properties, receiverOpt, resultKind, this.HasErrors); 6180var result = new BoundCall(this.Syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning, method, arguments, argumentNamesOpt, argumentRefKindsOpt, isDelegateCall, expanded, invokedAsExtensionMethod, argsToParamsOpt, defaultArguments, resultKind, originalMethodsOpt, type, this.HasErrors); 6219var result = new BoundEventAssignmentOperator(this.Syntax, @event, isAddition, isDynamic, receiverOpt, argument, type, this.HasErrors); 6264var result = new BoundAttribute(this.Syntax, constructor, constructorArguments, constructorArgumentNamesOpt, constructorArgumentsToParamsOpt, constructorExpanded, constructorDefaultArguments, namedArguments, resultKind, type, this.HasErrors); 6302var result = new BoundUnconvertedObjectCreationExpression(this.Syntax, arguments, argumentNamesOpt, argumentRefKindsOpt, initializerOpt, binder, this.HasErrors); 6374var result = new BoundObjectCreationExpression(this.Syntax, constructor, constructorsGroup, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, constantValueOpt, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 6415var result = new BoundUnconvertedCollectionExpression(this.Syntax, elements, this.HasErrors); 6460var result = new BoundCollectionExpression(this.Syntax, collectionTypeKind, placeholder, collectionCreation, collectionBuilderMethod, collectionBuilderInvocationPlaceholder, collectionBuilderInvocationConversion, wasTargetTyped, unconvertedCollectionExpression, elements, type, this.HasErrors); 6488var result = new BoundCollectionExpressionSpreadExpressionPlaceholder(this.Syntax, type, this.HasErrors); 6528var result = new BoundCollectionExpressionSpreadElement(this.Syntax, expression, expressionPlaceholder, conversion, enumeratorInfoOpt, lengthOrCount, elementPlaceholder, iteratorBody, this.HasErrors); 6573var result = new BoundTupleLiteral(this.Syntax, arguments, argumentNamesOpt, inferredNamesOpt, type, this.HasErrors); 6603var result = new BoundConvertedTupleLiteral(this.Syntax, sourceTuple, wasTargetTyped, arguments, argumentNamesOpt, inferredNamesOpt, type, this.HasErrors); 6646var result = new BoundDynamicObjectCreationExpression(this.Syntax, name, arguments, argumentNamesOpt, argumentRefKindsOpt, initializerExpressionOpt, applicableMethods, wasTargetTyped, type, this.HasErrors); 6678var result = new BoundNoPiaObjectCreationExpression(this.Syntax, guidString, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 6725var result = new BoundObjectInitializerExpression(this.Syntax, placeholder, initializers, type, this.HasErrors); 6774var result = new BoundObjectInitializerMember(this.Syntax, memberSymbol, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, resultKind, accessorKind, receiverType, type, this.HasErrors); 6819var result = new BoundDynamicObjectInitializerMember(this.Syntax, memberName, receiverType, type, this.HasErrors); 6847var result = new BoundCollectionInitializerExpression(this.Syntax, placeholder, initializers, type, this.HasErrors); 6892var result = new BoundCollectionElementInitializer(this.Syntax, addMethod, arguments, implicitReceiverOpt, expanded, argsToParamsOpt, defaultArguments, invokedAsExtensionMethod, resultKind, type, this.HasErrors); 6924var result = new BoundDynamicCollectionElementInitializer(this.Syntax, applicableMethods, expression, arguments, type, this.HasErrors); 6959var result = new BoundImplicitReceiver(this.Syntax, type, this.HasErrors); 6995var result = new BoundAnonymousObjectCreationExpression(this.Syntax, constructor, arguments, declarations, type, this.HasErrors); 7035var result = new BoundAnonymousPropertyDeclaration(this.Syntax, property, type, this.HasErrors); 7065var result = new BoundNewT(this.Syntax, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 7101var result = new BoundDelegateCreationExpression(this.Syntax, argument, methodOpt, isExtensionMethod, wasTargetTyped, type, this.HasErrors); 7133var result = new BoundArrayCreation(this.Syntax, bounds, initializerOpt, type, this.HasErrors); 7164var result = new BoundArrayInitialization(this.Syntax, isInferred, initializers, this.HasErrors); 7210var result = new BoundStackAllocArrayCreation(this.Syntax, elementType, count, initializerOpt, type, this.HasErrors); 7239var result = new BoundConvertedStackAllocExpression(this.Syntax, elementType, count, initializerOpt, type, this.HasErrors); 7279var result = new BoundFieldAccess(this.Syntax, receiverOpt, fieldSymbol, constantValueOpt, resultKind, isByValue, isDeclaration, type, this.HasErrors); 7319var result = new BoundHoistedFieldAccess(this.Syntax, fieldSymbol, type, this.HasErrors); 7357var result = new BoundPropertyAccess(this.Syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning, propertySymbol, autoPropertyAccessorKind, resultKind, type, this.HasErrors); 7393var result = new BoundEventAccess(this.Syntax, receiverOpt, eventSymbol, isUsableAsField, resultKind, type, this.HasErrors); 7444var result = new BoundIndexerAccess(this.Syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, accessorKind, argsToParamsOpt, defaultArguments, originalIndexersOpt, type, this.HasErrors); 7493var result = new BoundImplicitIndexerAccess(this.Syntax, receiver, argument, lengthOrCountAccess, receiverPlaceholder, indexerOrSliceAccess, argumentPlaceholders, type, this.HasErrors); 7534var result = new BoundInlineArrayAccess(this.Syntax, expression, argument, isValue, getItemOrSliceHelper, type, this.HasErrors); 7574var result = new BoundDynamicIndexerAccess(this.Syntax, receiver, arguments, argumentNamesOpt, argumentRefKindsOpt, applicableIndexers, type, this.HasErrors); 7614var result = new BoundLambda(this.Syntax, unboundLambda, symbol, body, diagnostics, binder, type, this.HasErrors); 7658var result = new UnboundLambda(this.Syntax, data, functionType, withDependencies, this.HasErrors); 7699var result = new BoundQueryClause(this.Syntax, value, definedSymbol, operation, cast, binder, unoptimizedForm, type, this.HasErrors); 7725var result = new BoundTypeOrInstanceInitializers(this.Syntax, statements, this.HasErrors); 7758var result = new BoundNameOfOperator(this.Syntax, argument, constantValueOpt, type, this.HasErrors); 7800var result = new BoundUnconvertedInterpolatedString(this.Syntax, parts, constantValueOpt, type, this.HasErrors); 7828var result = new BoundInterpolatedString(this.Syntax, interpolationData, parts, constantValueOpt, type, this.HasErrors); 7856var result = new BoundInterpolatedStringHandlerPlaceholder(this.Syntax, type, this.HasErrors); 7894var result = new BoundInterpolatedStringArgumentPlaceholder(this.Syntax, argumentIndex, type, this.HasErrors); 7929var result = new BoundStringInsert(this.Syntax, value, alignment, format, isInterpolatedStringHandlerAppendCall, this.HasErrors); 7971var result = new BoundIsPatternExpression(this.Syntax, expression, pattern, isNegated, reachabilityDecisionDag, whenTrueLabel, whenFalseLabel, type, this.HasErrors); 8036var result = new BoundConstantPattern(this.Syntax, value, constantValue, inputType, narrowedType, this.HasErrors); 8076var result = new BoundDiscardPattern(this.Syntax, inputType, narrowedType, this.HasErrors); 8129var result = new BoundDeclarationPattern(this.Syntax, declaredType, isVar, variable, variableAccess, inputType, narrowedType, this.HasErrors); 8170var result = new BoundRecursivePattern(this.Syntax, declaredType, deconstructMethod, deconstruction, properties, isExplicitNotNullTest, variable, variableAccess, inputType, narrowedType, this.HasErrors); 8214var result = new BoundListPattern(this.Syntax, subpatterns, hasSlice, lengthAccess, indexerAccess, receiverPlaceholder, argumentPlaceholder, variable, variableAccess, inputType, narrowedType, this.HasErrors); 8253var result = new BoundSlicePattern(this.Syntax, pattern, indexerAccess, receiverPlaceholder, argumentPlaceholder, inputType, narrowedType, this.HasErrors); 8293var result = new BoundITuplePattern(this.Syntax, getLengthMethod, getItemMethod, subpatterns, inputType, narrowedType, this.HasErrors); 8335var result = new BoundPositionalSubpattern(this.Syntax, symbol, pattern, this.HasErrors); 8365var result = new BoundPropertySubpattern(this.Syntax, member, isLengthOrCount, pattern, this.HasErrors); 8397var result = new BoundPropertySubpatternMember(this.Syntax, receiver, symbol, type, this.HasErrors); 8433var result = new BoundTypePattern(this.Syntax, declaredType, isExplicitNotNullTest, inputType, narrowedType, this.HasErrors); 8472var result = new BoundBinaryPattern(this.Syntax, disjunction, left, right, inputType, narrowedType, this.HasErrors); 8506var result = new BoundNegatedPattern(this.Syntax, negated, inputType, narrowedType, this.HasErrors); 8545var result = new BoundRelationalPattern(this.Syntax, relation, value, constantValue, inputType, narrowedType, this.HasErrors); 8580var result = new BoundDiscardExpression(this.Syntax, nullableAnnotation, isInferred, type, this.HasErrors); 8608var result = new BoundThrowExpression(this.Syntax, expression, type, this.HasErrors); 8651var result = new OutVariablePendingInference(this.Syntax, variableSymbol, receiverOpt, this.HasErrors); 8677var result = new DeconstructionVariablePendingInference(this.Syntax, variableSymbol, receiverOpt, this.HasErrors); 8712var result = new OutDeconstructVarPendingInference(this.Syntax, variableSymbol, isDiscardExpression, this.HasErrors); 8748var result = new BoundNonConstructorMethodBody(this.Syntax, blockBody, expressionBody, this.HasErrors); 8778var result = new BoundConstructorMethodBody(this.Syntax, locals, initializer, blockBody, expressionBody, this.HasErrors); 8809var result = new BoundExpressionWithNullability(this.Syntax, expression, nullableAnnotation, type, this.HasErrors); 8844var result = new BoundWithExpression(this.Syntax, receiver, cloneMethod, initializerExpression, type, this.HasErrors);

128var factory = new SyntheticBoundNodeFactory(containingSymbol, statement.Syntax, compilationState, diagnostics); 137var tryStatementSyntax = node.Syntax; 548Debug.Assert(node.Syntax.IsKind(SyntaxKind.CatchClause)); 549var tryStatementSyntax = (TryStatementSyntax)node.Syntax.Parent; 739var 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, 376Debug.Assert(node.Syntax.IsKind(SyntaxKind.AwaitExpression) || node.WasCompilerGenerated); 378var 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);

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, 1439return new BoundNoOpStatement(node.Syntax, NoOpStatementFlavor.Default); 1654RemapLambdaOrLocalFunction(node.Syntax, node.Symbol, default(ImmutableArray<TypeWithAnnotations>), closureKind, ref referencedMethod, out receiver, out constructedFrame); 1665node.Syntax, 1683InLoopOrLambda(node.Syntax, lambdaScope.Syntax); 1688var F = new SyntheticBoundNodeFactory(_currentMethod, node.Syntax, CompilationState, Diagnostics);

116var r = new ExpressionLambdaRewriter(compilationState, typeMap, node.Syntax, recursionDepth, diagnostics); 120diagnostics.Add(ErrorCode.ERR_MissingPredefinedMember, node.Syntax.Location, r.ExpressionType, "Lambda"); 173_bound.Syntax = node.Syntax; 351return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 382return new BoundBadExpression(node.Syntax, 0, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 1091return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1098return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1130return 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) 291left = new BoundConversion(left.Syntax, left, conversion, node.Operator.Kind.IsChecked(), 333_diagnostics.Add(ErrorCode.WRN_BadRefCompareLeft, node.Syntax.Location, t); 338_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)); 394var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal, original.Syntax); 464var toStringMethod = GetSpecialMethodSymbol(SpecialMember.System_Object__ToString, value.Syntax); 525var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal: null, original.Syntax); 589var 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); 173return new BoundBadStatement(statement.Syntax, ImmutableArray.Create<BoundNode>(statement), hasErrors: true); 249var nameofIdentiferSyntax = (IdentifierNameSyntax)((InvocationExpressionSyntax)nameofOperator.Syntax).Expression; 262var result = MakeLiteral(node.Syntax, constantValue, type); 300visited.Syntax, 318var result = new BoundFieldAccess(node.Syntax, new BoundThisReference(node.Syntax, primaryCtor.ContainingType), field, ConstantValue.NotAvailable, LookupResultKind.Viable, node.Type); 343location = node.Syntax.Location; 578return BadExpression(node.Syntax, node.Type, ImmutableArray.Create(node)); 662tryGetResult = TryGetSpecialTypeMethod(node.Syntax, SpecialMember.System_Type__GetTypeFromHandle, out getTypeFromHandle); 666tryGetResult = TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Type__GetTypeFromHandle, out getTypeFromHandle); 671return new BoundTypeOfOperator(node.Syntax, sourceType, null, type, hasErrors: true); 688if (!TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Type__GetTypeFromHandle, out getTypeFromHandle)) 690return new BoundRefTypeOperator(node.Syntax, operand, null, type, hasErrors: true); 730statement.Syntax, 814return new BoundStatementList(node.Syntax, rewrittenStatements, node.HasErrors); 863var 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); 1063ArrayBuilder<BoundStatement> sectionBuilder = BuilderForSection(whenNode.Syntax); 1086var whenClauseSyntax = whenNodes[0].Syntax; 1089Debug.Assert(whenNodes.All(n => n.Syntax == whenClauseSyntax)); 1155ArrayBuilder<BoundStatement> sectionBuilder = BuilderForSection(whenClause.Syntax); 1163addConditionalGoto(whenClause.WhenExpression, whenClause.Syntax, trueLabel, sectionBuilder); 1200_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); 191var outputTemp = new BoundDagTemp(d.Syntax, parameter.Type, d, i - extensionExtra); 212var outputTemp = new BoundDagTemp(t.Syntax, type, t); 218_localRewriter._diagnostics.Add(t.Syntax, useSiteInfo); 224_localRewriter.TryGetNullableMethod(t.Syntax, inputType, SpecialMember.System_Nullable_T_GetValueOrDefault, out MethodSymbol getValueOrDefault)) 249var outputTemp = new BoundDagTemp(e.Syntax, type, e); 274var outputTemp = new BoundDagTemp(e.Syntax, e.IndexerType, e); 300var outputTemp = new BoundDagTemp(e.Syntax, e.SliceType, e); 332return new BoundRangeExpression(e.Syntax, makeUnloweredIndexArgument(e.StartIndex), end, 342_factory.Syntax = test.Syntax; 348return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullNotEqual : BinaryOperatorKind.NotEqual); 355return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullEqual : BinaryOperatorKind.Equal); 359return MakeValueTest(d.Syntax, input, d.Value); 364return MakeRelationalTest(d.Syntax, input, d.OperatorKind, d.Value); 478BoundExpression output = _tempAllocator.GetTemp(new BoundDagTemp(evaluation.Syntax, typeEvaluation1.Type, evaluation)); 494BoundExpression output = _tempAllocator.GetTemp(new BoundDagTemp(evaluation.Syntax, baseType, evaluation)); 497_localRewriter._diagnostics.Add(test.Syntax, useSiteInfo); 558loweredInput.Syntax.Kind() == SyntaxKind.TupleExpression && 623var originalInput = BoundDagTemp.ForOriginalInput(loweredInput.Syntax, loweredInput.Type); 630var fieldFetchEvaluation = new BoundDagFieldEvaluation(expr.Syntax, field, originalInput); 631var 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); 121return RewriteWindowsRuntimeEventAssignmentOperator(eventAccess.Syntax, 151EmbedIfNeedTo(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.Method, original.ConstrainedToType, 209Debug.Assert(oldNode == null || (oldNode.Syntax == syntax)); 751_diagnostics.Add(loweredLeft.Syntax, useSiteInfo); 775_diagnostics.Add(loweredLeft.Syntax, useSiteInfo); 2153SyntaxNode rightSyntax = loweredRight.Syntax; 2232_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); 57loweredReceiver = new BoundTypeExpression(node.Syntax, null, _factory.CurrentType); // Tracked by https://github.com/dotnet/roslyn/issues/76130 : Follow up (_factory.CompilationState.Type?) 66EmbedIfNeedTo(loweredReceiver, methodGroup.Methods, node.Syntax); 421var rewrittenCall = MakeCall(node, node.Syntax, rewrittenReceiver, method, rewrittenArguments, argRefKindsOpt, node.ResultKind, temps.ToImmutableAndFree()); 979new BoundComplexConditionalReceiver(receiverTemp.Syntax, 1151optimized = CreateArrayEmptyCallIfAvailable(possibleParamsArray.Syntax, ((ArrayTypeSymbol)possibleParamsArray.Type!).ElementType); 1606value.Syntax, 1673argument.Syntax,

38_factory.Syntax = node.Syntax; 146new BoundExpressionStatement(iteratorBody.Syntax, iteratorBody)); 168if (!TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Linq_Enumerable__ToList, out MethodSymbol? toListGeneric, isOptional: true)) 252var syntax = node.Syntax; 359var syntax = iteratorBody.Syntax; 376node.Syntax, 402var syntax = node.Syntax; 493node.Syntax, 720var syntax = node.Syntax; 791var expressionSyntax = rewrittenValue.Syntax; 1013sideEffects.Add(new BoundAssignmentOperator(rewrittenSpreadOperand.Syntax, indexTemp, _factory.Binary(BinaryOperatorKind.Addition, indexTemp.Type, indexTemp, spreadLength), isRef: false, indexTemp.Type)); 1127var expressionSyntax = rewrittenValue.Syntax; 1196node.Syntax, 1256var statements = builder.SelectAsArray(expr => (BoundStatement)new BoundExpressionStatement(expr.Syntax, expr)); 1261new BoundBlock(iteratorBody.Syntax, locals: ImmutableArray<LocalSymbol>.Empty, statements); 1340var 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()); 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); 322return new BoundDynamicMemberAccess(memberAccess.Syntax, receiverTemp, memberAccess.TypeArgumentsOpt, memberAccess.Name, memberAccess.Invoked, memberAccess.Indexed, memberAccess.Type); 403SyntaxNode syntax = indexerAccess.Syntax; 618indexerAccess.Syntax, 724return MakeFieldAccess(fieldAccess.Syntax, receiverOpt, fieldAccess.FieldSymbol, fieldAccess.ConstantValueOpt, fieldAccess.ResultKind, fieldAccess.Type, fieldAccess); 816return MakeEventAccess(eventAccess.Syntax, receiverOpt, eventAccess.EventSymbol, eventAccess.ConstantValueOpt, eventAccess.ResultKind, eventAccess.Type); 849rewrittenReceiver.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, 305Debug.Assert(oldNodeOpt == null || oldNodeOpt.Syntax == syntax); 553return new BoundFunctionPointerLoad(oldNodeOpt.Syntax, symbolOpt, 567_factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax; 575EnsureParamCollectionAttributeExists(rewrittenOperand.Syntax, rewrittenType); 804return MakeConversionNode(rewrittenOperand.Syntax, rewrittenOperand, conversion, rewrittenType, @checked); 818diagnostics.Add(rewrittenOperand.Syntax, useSiteInfo); 829rewrittenOperand.Syntax.Location, 1019syntax: expression.Syntax, 1320seq.Syntax, 1324conditional.Syntax, 1386MethodSymbol ctor = UnsafeGetNullableMethod(call.Syntax, resultType, SpecialMember.System_Nullable_T__ctor); 1387return 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; 325module.EmbeddedTypesManagerOpt.EmbedEventIfNeedTo(node.Event.GetCciAdapter(), node.Syntax, _diagnostics.DiagnosticBag, isUsedForComAwareEventBinding: true); 333return 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>(); 449VariableDeclaratorSyntax? declarator = fixedInitializer.Syntax.FirstAncestorOrSelf<VariableDeclaratorSyntax>(); 479if (TryGetWellKnownTypeMember(fixedInitializer.Syntax, WellKnownMember.System_Runtime_CompilerServices_RuntimeHelpers__get_OffsetToStringData, out offsetMethod)) 485helperCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 540if (TryGetSpecialTypeMethod(fixedInitializer.Syntax, SpecialMember.System_Array__get_Length, out lengthMethod)) 546lengthCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(factory.Local(pinnedTemp)), ErrorTypeSymbol.UnknownResultType);

61else if (node.AwaitOpt is null && CanRewriteForEachAsFor(node.Syntax, nodeExpressionType, out var indexerGet, out var lengthGetter)) 149var forEachSyntax = (CSharpSyntaxNode)node.Syntax; 604var forEachSyntax = (CSharpSyntaxNode)node.Syntax; 617arrayVarDecl = new BoundStatementList(arrayVarDecl.Syntax, ImmutableArray.Create(collectionVarInitializationPreamble, arrayVarDecl)).MakeCompilerGenerated(); 817iterationVarDecl = new BoundExpressionStatement(assignment.Syntax, loweredAssignment); 894var forEachSyntax = (CSharpSyntaxNode)node.Syntax; 1043var forEachSyntax = (CSharpSyntaxNode)node.Syntax; 1274CommonForEachStatementSyntax 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, 328createSpan = _factory.ModuleBuilderOpt.EnsureInlineArrayAsReadOnlySpanExists(node.Syntax, spanType, intType, _diagnostics.DiagnosticBag); 332createSpan = _factory.ModuleBuilderOpt.EnsureInlineArrayAsSpanExists(node.Syntax, spanType, intType, _diagnostics.DiagnosticBag); 354elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayFirstElementRefExists(node.Syntax, _diagnostics.DiagnosticBag); 359elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayFirstElementRefReadOnlyExists(node.Syntax, _diagnostics.DiagnosticBag); 373elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayElementRefExists(node.Syntax, intType, _diagnostics.DiagnosticBag); 378elementRef = _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; 45var leftPlaceholder = new BoundValuePlaceholder(lhsRead.Syntax, lhsRead.Type); 71if (!TryGetNullableMethod(leftOperand.Syntax, 79if (!TryGetNullableMethod(leftOperand.Syntax, 103var tmp = _factory.StoreToTemp(BoundCall.Synthesized(leftOperand.Syntax, lhsRead, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault), 110var tmpAssignment = MakeAssignmentOperator(node.Syntax, tmp, loweredRight, used: true, isChecked: false, isCompoundAssignment: false); 118node.Syntax, 126var 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); 194withExpr.Syntax, 314var rewrittenNewT = MakeNewT(node.Syntax, (TypeParameterSymbol)node.Type); 320return MakeExpressionWithInitializer(node.Syntax, rewrittenNewT, node.InitializerExpressionOpt, rewrittenNewT.Type!); 377_factory.Syntax = node.Syntax; 389newGuid = new BoundBadExpression(node.Syntax, LookupResultKind.NotCreatable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 407callGetTypeFromCLSID = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 419rewrittenObjectCreation = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, node.Type); 429return 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)); 473result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, used: false)); 506result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, used: false)); 540result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, isRef: false, used: false)); 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); 484arg.Syntax, 497arg.Syntax, 507args[i] = BoundCall.Synthesized(arg.Syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, stringImplicitConversionToReadOnlySpan, arg); 560var method = UnsafeGetSpecialTypeMethod(current.Syntax, member); 563currentResult = new BoundBinaryOperator(current.Syntax, current.OperatorKind, constantValueOpt: null, method, constrainedToTypeOpt: null, default(LookupResultKind), currentResult, right, current.Type); 576var 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)); 142result.Add(new BoundRestorePreviousSequencePoint(node.Syntax, restorePointForEnclosingStatement));

71syntax: expr.Syntax, 84tuple.Syntax, sourceTuple: null, wasTargetTyped: true, newArguments, ImmutableArray<string?>.Empty, 106var syntax = boundConversion.Syntax; 162tuple.Syntax, sourceTuple: null, wasTargetTyped: false, newArguments, ImmutableArray<string?>.Empty, 206return new BoundLiteral(expr.Syntax, ConstantValue.Null, expr.Type); 214syntax: expr.Syntax, operand: deferredOperand, 259return new BoundLiteral(left.Syntax, ConstantValue.Create(nullnull.Kind == BinaryOperatorKind.Equal), boolType); 342_factory.Conditional(leftHasValue, innerSequence, MakeBooleanConstant(right.Syntax, boolValue), boolType), 343MakeBooleanConstant(right.Syntax, !boolValue), 359hasValue = MakeBooleanConstant(expr.Syntax, true); 369hasValue = MakeBooleanConstant(expr.Syntax, false); 371value = new BoundDefaultExpression(expr.Syntax, expr.Type.StrippedType()); 378hasValue = MakeBooleanConstant(expr.Syntax, true); 411return _factory.MakeNullableHasValue(expr.Syntax, expr); 455syntax: operand.Syntax, 467BoundExpression valueOrDefaultCall = MakeOptimizedGetValueOrDefault(expr.Syntax, expr); 475expr.Syntax, expr, conversion, enclosing.Checked, enclosing.ExplicitCastInCode, 530return MakeTupleFieldAccessAndReportUseSiteDiagnostics(tuple, tuple.Syntax, tuple.Type.TupleElements[i]); 558return _factory.Not(MakeUnaryOperator(UnaryOperatorKind.DynamicFalse, left.Syntax, method: null, constrainedToTypeOpt: null, dynamicResult, boolType)); 562return MakeUnaryOperator(UnaryOperatorKind.DynamicTrue, left.Syntax, method: null, constrainedToTypeOpt: null, dynamicResult, boolType); 569return new BoundLiteral(left.Syntax, ConstantValue.Create(operatorKind == BinaryOperatorKind.Equal), boolType); 584result = MakeUnaryOperator(boolOperator.Kind, binary.Syntax, boolOperator.Method, boolOperator.ConstrainedToTypeOpt, convertedBinary, boolType); 610oldNodeOpt: 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()); 581SyntaxNode syntax = node.Syntax; 785SyntaxNode syntax = node.Syntax; 822BoundExpression condition = _factory.MakeNullableHasValue(node.Syntax, boundTemp); 895syntax: node.Syntax, 902MethodSymbol ctor = UnsafeGetNullableMethod(node.Syntax, binaryOperandType, SpecialMember.System_Nullable_T__ctor); 903boundOne = new BoundObjectCreationExpression(node.Syntax, ctor, boundOne); 921return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null, constrainedToTypeOpt: null); 936binOp = MakeDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand); 940binOp = MakeLiftedDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand); 944binOp = MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperandType, method: null, constrainedToTypeOpt: null); 1013return MakePropertyGetAccess(transformedExpression.Syntax, propertyAccess.ReceiverOpt, propertyAccess.PropertySymbol, propertyAccess); 1021return 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); 199if (TryReplaceWithProxy(node.ParameterSymbol, node.Syntax, out BoundNode? replacement)) 215if (TryReplaceWithProxy(node.LocalSymbol, node.Syntax, out BoundNode? replacement)) 301SyntheticBoundNodeFactory factory = new SyntheticBoundNodeFactory(this.CurrentMethod, rewrittenLeft.Syntax, this.CompilationState, this.Diagnostics); 309node.Syntax, 345method = 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; 626builder = new BoundSpillSequenceBuilder(lastSpill < newList.Length ? (newList[lastSpill] as BoundSpillSequenceBuilder)?.Syntax : null); 720exceptionFilterPrologueOpt = new BoundStatementList(node.Syntax, builder.GetStatements()); 751var builder = new BoundSpillSequenceBuilder(node.Syntax); 754_F.Syntax = node.Syntax; 789builder = new BoundSpillSequenceBuilder(indicesBuilder.Syntax); 817var boundsBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 870var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 991var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1029var receiverBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1054_F.Syntax = node.Syntax; 1058receiverBuilder.AddStatement(_F.ExpressionStatement(new BoundComplexConditionalReceiver(node.Syntax, cache, _F.Sequence(new[] { _F.AssignmentExpression(cache, receiver) }, cache), receiverType) { WasCompilerGenerated = true })); 1094var invokedExpressionBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1120if (conditionBuilder == null) conditionBuilder = new BoundSpillSequenceBuilder((consequenceBuilder ?? alternativeBuilder).Syntax); 1121if (consequenceBuilder == null) consequenceBuilder = new BoundSpillSequenceBuilder(alternativeBuilder.Syntax); 1122if (alternativeBuilder == null) alternativeBuilder = new BoundSpillSequenceBuilder(consequenceBuilder.Syntax); 1246var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1281if (receiverBuilder == null) receiverBuilder = new BoundSpillSequenceBuilder((whenNotNullBuilder ?? whenNullBuilder).Syntax); 1282if (whenNotNullBuilder == null) whenNotNullBuilder = new BoundSpillSequenceBuilder(whenNullBuilder.Syntax); 1283if (whenNullBuilder == null) whenNullBuilder = new BoundSpillSequenceBuilder(whenNotNullBuilder.Syntax); 1431var expressionBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1464builder = new BoundSpillSequenceBuilder(valueBuilder.Syntax);

68walker.CaptureVariable(method.ThisParameter, node.Syntax); 220CaptureRefInitializer(variableInitializer, local.SynthesizedKind != SynthesizedLocalKind.UserDefined ? variableInitializer.Syntax : syntax); 291CaptureVariable(node.ParameterSymbol, node.Syntax); 300CaptureVariable(thisSymbol, node.Syntax); 308CaptureVariable(topLevelMethod.ThisParameter, node.Syntax); 314CaptureVariable(topLevelMethod.ThisParameter, node.Syntax); 402Capture(_topLevelMethod.ThisParameter, node.Syntax); 408Capture(_topLevelMethod.ThisParameter, node.Syntax); 414Capture(node.LocalSymbol, node.Syntax); 420Capture(node.ParameterSymbol, node.Syntax);

734F.Syntax = node.Syntax; 788translated = new BoundStatementList(node.Syntax, statements);

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

519innerInstrumentation.Syntax, 1232return new BoundThrowExpression(thrown.Syntax, thrown, type) { WasCompilerGenerated = true }; 1641return new BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.BoolLogicalNegation, expression, null, null, constrainedToTypeOpt: null, LookupResultKind.Viable, expression.Type); 1693var syntax = argument.Syntax; 1741return 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; 1522SyntaxNode syntax = boundBinaryOperator.Syntax; 1566SyntaxNode syntax = boundTupleBinaryOperator.Syntax; 1578SyntaxNode syntax = boundConditionalOperator.Syntax; 1589SyntaxNode syntax = boundNullCoalescingOperator.Syntax; 1608SyntaxNode syntax = boundNode.Syntax; 1618SyntaxNode syntax = boundAwaitExpression.Syntax; 1628SyntaxNode syntax = boundArrayAccess.Syntax; 1639SyntaxNode syntax = boundIndexerAccess.Syntax; 1661SyntaxNode syntax = boundInlineArrayAccess.Syntax; 1671SyntaxNode syntax = boundNameOfOperator.Syntax; 1681SyntaxNode syntax = boundThrowExpression.Syntax; 1690SyntaxNode syntax = boundAddressOfOperator.Syntax; 1699SyntaxNode syntax = boundImplicitReceiver.Syntax; 1709SyntaxNode syntax = boundConditionalAccess.Syntax; 1718SyntaxNode syntax = boundConditionalReceiver.Syntax; 1728SyntaxNode syntax = boundFieldEqualsValue.Syntax; 1737SyntaxNode syntax = boundPropertyEqualsValue.Syntax; 1746SyntaxNode syntax = boundParameterEqualsValue.Syntax; 1755SyntaxNode syntax = boundBlock.Syntax; 1764SyntaxNode syntax = boundContinueStatement.Syntax; 1773SyntaxNode syntax = boundBreakStatement.Syntax; 1781SyntaxNode syntax = boundYieldBreakStatement.Syntax; 1790SyntaxNode syntax = boundGotoStatement.Syntax; 1797SyntaxNode syntax = boundNoOpStatement.Syntax; 1831SyntaxNode syntax = boundIfStatement.Syntax; 1853SyntaxNode syntax = boundWhileStatement.Syntax; 1867SyntaxNode syntax = boundDoStatement.Syntax; 1882SyntaxNode syntax = boundForStatement.Syntax; 1968var declaratorSyntax = boundForEachStatement.IterationVariableType.Syntax; 1989SyntaxNode syntax = boundForEachStatement.Syntax; 2000SyntaxNode syntax = boundTryStatement.Syntax; 2014SyntaxNode syntax = boundCatchBlock.Syntax; 2024SyntaxNode syntax = boundFixedStatement.Syntax; 2042SyntaxNode syntax = boundUsingStatement.Syntax; 2050SyntaxNode syntax = boundThrowStatement.Syntax; 2059SyntaxNode syntax = boundReturnStatement.Syntax; 2067SyntaxNode syntax = boundYieldReturnStatement.Syntax; 2077legacyMode ? null : new SynthesizedLocal((_semanticModel.GetEnclosingSymbol(boundLockStatement.Syntax.SpanStart) as IMethodSymbol).GetSymbol(), 2080syntaxOpt: boundLockStatement.Argument.Syntax).GetPublicSymbol(); 2083SyntaxNode syntax = boundLockStatement.Syntax; 2091SyntaxNode syntax = boundBadStatement.Syntax; 2094bool isImplicit = boundBadStatement.WasCompilerGenerated || boundBadStatement.ChildBoundNodes.Any(static (e, boundBadStatement) => e?.Syntax == boundBadStatement.Syntax, boundBadStatement); 2101var node = boundLocalDeclaration.Syntax; 2155SyntaxNode declarationGroupSyntax = boundMultipleLocalDeclarations.Syntax; 2192SyntaxNode syntax = boundLabelStatement.Syntax; 2201SyntaxNode syntax = boundLabeledStatement.Syntax; 2211bool isImplicit = boundExpressionStatement.WasCompilerGenerated || boundExpressionStatement.Syntax == boundExpressionStatement.Expression.Syntax; 2212SyntaxNode syntax = boundExpressionStatement.Syntax; 2219Debug.Assert(boundExpressionStatement.Syntax == sequence.Value.Syntax); 2228SyntaxNode syntax = boundTupleExpression.Syntax; 2264SyntaxNode syntax = boundInterpolatedString.Syntax; 2361builder.Add(new InterpolatedStringTextOperation(valueOperation, _semanticModel, part.Syntax, isImplicit)); 2369Debug.Assert(valueOperation.Syntax != part.Syntax); 2371builder.Add(new InterpolationOperation(valueOperation, alignmentOperation, formatOperation, _semanticModel, part.Syntax, isImplicit)); 2404SyntaxNode syntax = boundStringInsert.Syntax; 2412SyntaxNode syntax = boundNode.Syntax; 2431conversion.Syntax, 2442return new InterpolatedStringAdditionOperation(left, right, _semanticModel, current.Syntax, current.WasCompilerGenerated); 2464return new InterpolatedStringAppendOperation(@this.Create(part), operationKind, @this._semanticModel, part.Syntax, isImplicit: true); 2470interpolatedString.Syntax, 2483SyntaxNode syntax = placeholder.Syntax; 2510placeholder.Syntax, 2518SyntaxNode syntax = boundConstantPattern.Syntax; 2529SyntaxNode syntax = boundRelationalPattern.Syntax; 2548SyntaxNode syntax = boundDeclarationPattern.Syntax; 2571boundRecursivePattern.Syntax, 2590boundITuplePattern.Syntax, 2601syntax: boundTypePattern.Syntax, 2614boundNode.Syntax, 2628boundNode.Syntax, 2639boundNegatedPattern.Syntax, 2679boundBinaryPattern.Syntax, 2690SyntaxNode syntax = boundSwitchStatement.Syntax; 2701return new SwitchCaseOperation(clauses, body, locals, condition: null, _semanticModel, boundSwitchSection.Syntax, isImplicit: boundSwitchSection.WasCompilerGenerated); 2725boundSwitchExpression.Syntax, 2741boundSwitchExpressionArm.Syntax, 2747SyntaxNode syntax = boundSwitchLabel.Syntax; 2751if (boundSwitchLabel.Syntax.Kind() == SyntaxKind.DefaultSwitchLabel) 2775SyntaxNode syntax = boundIsPatternExpression.Syntax; 2783if (boundQueryClause.Syntax.Kind() != SyntaxKind.QueryExpression) 2790SyntaxNode syntax = boundQueryClause.Syntax; 2807boundNode.Syntax, 2822boundIndex.Syntax, 2837boundRange.Syntax, 2848boundNode.Syntax, 2856SyntaxNode subpatternSyntax = subpattern.Syntax; 2869var nameSyntax = member.Syntax; 2876nameSyntax = member.Syntax; 2934SyntaxNode 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);

51base(unboundLambda.Syntax.GetReference()) 59_syntax = unboundLambda.Syntax;

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

269VerifyParamDefaultValueMatchesAttributeIfAny(_lazyDefaultSyntaxValue, parameterEqualsValue.Value.Syntax, diagnostics); 278parameterEqualsValue.Value.Syntax.Location);

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

220NullableWalker.AnalyzeIfNeeded(binder, boundGetAccessor, boundGetAccessor.Syntax, diagnostics, getterNullResilienceData: (getAccessor, _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();