75this.Syntax = syntax;

869return new BoundBlock(statement.Syntax, locals, ImmutableArray.Create(statement)) 885return new BoundBlock(statement.Syntax, locals, localFunctions, hasUnsafeModifier: false, instrumentation: null,

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

354BindDefaultArguments(indexerAccess.Syntax, parameters, argumentsBuilder, refKindsBuilderOpt, ref argsToParams, out defaultArguments, indexerAccess.Expanded, enableCallerInfo: true, diagnostics); 396Debug.Assert(expr.Syntax.Kind() != SyntaxKind.Argument || valueKind == BindValueKind.RefOrOut); 447diagnostics.Add(expr.Syntax, useSiteInfo); 481expr.Syntax, 489if (!hasResolutionErrors && CheckValueKind(expr.Syntax, expr, valueKind, checkingReceiver: false, diagnostics: diagnostics) || 705return CheckMethodReturnValueKind(call.Method, call.Syntax, node, valueKind, checkingReceiver, diagnostics); 709expr.Syntax, 723return CheckMethodReturnValueKind(sliceAccess.Method, sliceAccess.Syntax, node, valueKind, checkingReceiver, diagnostics); 740(CheckValueKind(conditional.Consequence.Syntax, conditional.Consequence, valueKind, checkingReceiver: false, diagnostics: diagnostics) & 741CheckValueKind(conditional.Alternative.Syntax, conditional.Alternative, valueKind, checkingReceiver: false, diagnostics: diagnostics))) 808Error(diagnostics, ErrorCode.ERR_BadSKknown, expr.Syntax, ((BoundNamespaceExpression)expr).NamespaceSymbol, MessageID.IDS_SK_NAMESPACE.Localize(), MessageID.IDS_SK_VARIABLE.Localize()); 811Error(diagnostics, ErrorCode.ERR_BadSKunknown, expr.Syntax, expr.Type, MessageID.IDS_SK_TYPE.Localize()); 834diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, local.Syntax.Location, localSymbol); 884Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnLocal2 : ErrorCode.ERR_RefReturnLocal2, local.Syntax, localSymbol); 895Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnNonreturnableLocal2 : ErrorCode.ERR_RefReturnNonreturnableLocal2, local.Syntax, localSymbol); 970diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, parameter.Syntax.Location, parameterSymbol.Name); 1097(checkingReceiver: true, isRefScoped: true, inUnsafeRegion: false, _) => (ErrorCode.ERR_RefReturnScopedParameter2, parameter.Syntax), 1098(checkingReceiver: true, isRefScoped: true, inUnsafeRegion: true, _) => (ErrorCode.WRN_RefReturnScopedParameter2, parameter.Syntax), 1099(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: false, ReturnOnlyScope) => (ErrorCode.ERR_RefReturnOnlyParameter2, parameter.Syntax), 1100(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: true, ReturnOnlyScope) => (ErrorCode.WRN_RefReturnOnlyParameter2, parameter.Syntax), 1101(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: false, _) => (ErrorCode.ERR_RefReturnParameter2, parameter.Syntax), 1102(checkingReceiver: true, isRefScoped: false, inUnsafeRegion: true, _) => (ErrorCode.WRN_RefReturnParameter2, parameter.Syntax), 1491Error(diagnostics, ErrorCode.ERR_ReturnNotLValue, expr.Syntax, propertySymbol); 1965CheckRefEscape(argument.Syntax, argument, escapeFrom, escapeTo, false, diagnostics) : 1966CheckValEscape(argument.Syntax, argument, escapeFrom, escapeTo, false, diagnostics); 1983return CheckValEscape(receiver.Syntax, receiver, escapeFrom, escapeTo, false, diagnostics); 2028CheckRefEscape(argument.Syntax, argument, escapeFrom, escapeTo, false, diagnostics) : 2029CheckValEscape(argument.Syntax, argument, escapeFrom, escapeTo, false, diagnostics); 2089receiver = new BoundCapturedReceiverPlaceholder(receiver.Syntax, receiver, _localScopeDepth, receiver.Type).MakeCompilerGenerated(); 2494if (!hasMixingError && !CheckValEscape(argument.Syntax, argument, scopeOfTheContainingExpression, escapeTo, false, diagnostics)) 2562? CheckRefEscape(fromArg.Syntax, fromArg, scopeOfTheContainingExpression, toArgEscape, checkingReceiver: false, diagnostics) 2563: CheckValEscape(fromArg.Syntax, fromArg, scopeOfTheContainingExpression, toArgEscape, checkingReceiver: false, diagnostics); 2897CheckRefEscape(expr.Syntax, expr, _localScopeDepth, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 2901CheckValEscape(expr.Syntax, expr, _localScopeDepth, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3233return CheckRefEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 3234CheckRefEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3265call.Syntax, 3290indexerAccess.Syntax, 3320indexerAccess.Syntax, 3345call.Syntax, 3373functionPointerInvocation.Syntax, 3397propertyAccess.Syntax, 3934Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, node, expr.Syntax); 3951return CheckValEscape(underlyingReceiver.Syntax, underlyingReceiver, escapeFrom, escapeTo, checkingReceiver, diagnostics); 3966CheckValEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 3967CheckValEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3974var consValid = CheckValEscape(conditional.Consequence.Syntax, conditional.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3983return CheckValEscape(conditional.Alternative.Syntax, conditional.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 3988return CheckValEscape(coalescingOp.LeftOperand.Syntax, coalescingOp.LeftOperand, escapeFrom, escapeTo, checkingReceiver, diagnostics) && 3989CheckValEscape(coalescingOp.RightOperand.Syntax, coalescingOp.RightOperand, escapeFrom, escapeTo, checkingReceiver, diagnostics); 4010call.Syntax, 4029ptrInvocation.Syntax, 4048indexerAccess.Syntax, 4073indexerAccess.Syntax, 4094call.Syntax, 4116propertyAccess.Syntax, 4135objectCreation.Syntax, 4153initializerExpr.Syntax, 4170escape = escape && CheckValEscape(initializerExpr.Syntax, initializerExpr, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4205return CheckValEscape(compound.Left.Syntax, compound.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 4206CheckValEscape(compound.Right.Syntax, compound.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4216return CheckValEscape(binary.Left.Syntax, binary.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 4217CheckValEscape(binary.Right.Syntax, binary.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4222if (range.LeftOperandOpt is { } left && !CheckValEscape(left.Syntax, left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 4227return !(range.RightOperandOpt is { } right && !CheckValEscape(right.Syntax, right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)); 4232return CheckValEscape(uo.Left.Syntax, uo.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) && 4233CheckValEscape(uo.Right.Syntax, uo.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4237return CheckValEscape(clauseValue.Syntax, clauseValue, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4241return CheckValEscape(variableValue.Syntax, variableValue, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4261return CheckValEscape(accessedExpression.Syntax, accessedExpression, escapeFrom, escapeTo, checkingReceiver, diagnostics); 4265return CheckValEscape(operandExpression.Syntax, operandExpression, escapeFrom, escapeTo, checkingReceiver, diagnostics); 4279if (!CheckValEscape(result.Syntax, result, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 4425if (!CheckValEscape(element.Syntax, element, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 4442? CheckRefEscape(expression.Syntax, assignment.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) 4443: CheckValEscape(expression.Syntax, assignment.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics); 4458if (!CheckValEscape(expression.Syntax, expression, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 4472if (!CheckValEscape(expression.Syntax, expression, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics)) 4490CheckValEscape(expression.Syntax, data.Construction, escapeFrom, escapeTo, checkingReceiver: false, diagnostics); 4498if (!CheckValEscape(argument.Syntax, argument, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))

279Debug.Assert(boundAttribute.Syntax.Kind() == SyntaxKind.Attribute); 287return new SourceAttributeData(boundAttribute.Syntax.GetReference(), attributeType, attributeConstructor, hasErrors); 291ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)boundAttribute.Syntax).Name, diagnostics, ref hasErrors); 313(AttributeSyntax)boundAttribute.Syntax, 324diagnostics.Add(boundAttribute.Syntax, useSiteInfo); 327boundAttribute.Syntax.GetReference(), 1027Binder.Error(diagnostics, ErrorCode.ERR_AttrArgWithTypeVars, node.Syntax, typeOfArgument.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)); 1111Binder.Error(diagnostics, ErrorCode.ERR_BadAttributeArgument, node.Syntax);

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

26diagnostics.Add(source.Syntax, useSiteInfo); 27return CreateConversion(source.Syntax, source, conversion, isCast: false, conversionGroupOpt: null, destination: destination, diagnostics: diagnostics); 36return CreateConversion(source.Syntax, source, conversion, isCast: false, conversionGroupOpt: null, destination: destination, diagnostics: diagnostics); 75var placeholder2 = new BoundValuePlaceholder(source.Syntax, source.Type); 190unconvertedSource.Syntax, 252source = new BoundDefaultExpression(source.Syntax, targetType: null, constantValue, type: destination) 346BoundExpression expr = bindObjectCreationExpression(node.Syntax, node.InitializerOpt, node.Binder, destination.StrippedType(), arguments, diagnostics); 354Debug.Assert(expr is not BoundBadExpression { ChildBoundNodes: var children } || !children.Any((child, node) => child.Syntax == node.Syntax, node)); 425? CreateConversion(source.Consequence.Syntax, source.Consequence, underlyingConversions[0], isCast: false, conversionGroupOpt: null, destination, diagnostics) 429? CreateConversion(source.Alternative.Syntax, source.Alternative, underlyingConversions[1], isCast: false, conversionGroupOpt: null, destination, diagnostics) 437source.Syntax.Location, 444return new BoundConditionalOperator(source.Syntax, isRef: false, condition, trueExpr, falseExpr, constantValue, source.Type, wasTargetTyped: targetTyped, destination, hasErrors) 464? CreateConversion(oldValue.Syntax, oldValue, underlyingConversions[i], isCast: false, conversionGroupOpt: null, destination, diagnostics) 467new BoundSwitchExpressionArm(oldCase.Syntax, oldCase.Locals, oldCase.Pattern, oldCase.WhenClause, newValue, oldCase.Label, oldCase.HasErrors); 473source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.ReachabilityDecisionDag, 540syntax: source.Syntax, 928var tupleSyntax = (TupleExpressionSyntax)sourceTuple.Syntax; 957convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, destType.Type, diagnostics)); 961sourceTuple.Syntax, 973sourceTuple.Syntax, 1526return 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;

214expr.Syntax, 290var exprSyntax = (SwitchExpressionSyntax)expr.Syntax; 321diagnostics.Add(op.NoCommonTypeError, op.Syntax.Location, trueArg, falseArg); 335sourceTuple.Syntax, 350diagnostics.Add(ErrorCode.ERR_DefaultLiteralNoTargetType, defaultExpr.Syntax.GetLocation()); 354defaultExpr.Syntax, 373diagnostics.Add(ErrorCode.ERR_ImplicitObjectCreationNoTargetType, expr.Syntax.GetLocation(), expr.Display); 401var syntax = expr.Syntax; 2516GenerateAnonymousFunctionConversionError(diagnostics, operand.Syntax, (UnboundLambda)operand, targetType); 2606GenerateImplicitConversionError(diagnostics, operand.Syntax, conversion, operand, targetType); 2648GenerateExplicitConversionErrors(diagnostics, argument.Syntax, elementConversion, argument, targetElementType); 3186arguments[arg] = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, parameterTypeWithAnnotations.Type, diagnostics); 3211arguments[arg] = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, parameterTypeWithAnnotations.Type, diagnostics); 3226ReportUnsafeIfNotAllowed(argument.Syntax, diagnostics); 3738Error(diagnostics, ErrorCode.ERR_ConstantExpected, size.Syntax); 3975Error(diagnostics, ErrorCode.ERR_ConstantExpected, sizeOpt.Syntax); 4316diagnostics.Add(ErrorCode.WRN_CapturedPrimaryConstructorParameterPassedToBase, boundParameter.Syntax.Location, parameter); 4425Debug.Assert(result is not BoundBadExpression { ChildBoundNodes: var children } || !children.Any((child, node) => child.Syntax == node, node)); 4507var argSyntax = analyzedArguments.Arguments[0].Syntax; 4509var end = analyzedArguments.Arguments[analyzedArguments.Arguments.Count - 1].Syntax.Span.End; 4550GenerateImplicitConversionError(diagnostics, unboundLambda.Syntax, conversion, unboundLambda, type); 4563CheckValidScopedMethodConversion(unboundLambda.Syntax, boundLambda.Symbol, type, invokedAsExtensionMethod: false, diagnostics); 4590diagnostics.Add(ErrorCode.ERR_MethodNameExpected, argument.Syntax.Location); 4614Conversion conv = Conversions.MethodGroupConversion(argument.Syntax, methodGroup, type, ref useSiteInfo); 4619argument.Syntax, default, WellKnownMemberNames.DelegateInvokeName, ImmutableArray.Create(sourceDelegate.DelegateInvokeMethod), 4635if (!this.MethodGroupConversionHasErrors(argument.Syntax, conv, argument, conv.IsExtensionMethod, isAddressOf: false, type, diagnostics)) 4651diagnostics.Add(ErrorCode.ERR_MethodNameExpected, argument.Syntax.Location); 4727var result = MakeBadExpressionForObjectCreation(node.Syntax, CreateErrorType(), arguments, node.InitializerOpt, typeSyntax: node.Syntax, diagnostics); 4896typeSyntax: boundLeft.Syntax, 5060diagnostics.Add(ErrorCode.ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers, argument.Syntax.Location); 5095if (!CheckValueKind(boundMember.Syntax, boundMember, valueKind, checkingReceiver: false, diagnostics: diagnostics)) 5191var memberInitializerSyntax = boundMemberInitializer.Syntax; 5280diagnostics.Add(ErrorCode.ERR_RequiredMembersMustBeAssignedValue, initializerExpression.Syntax.Location, requiredMember); 5420var boundElementInitializer = BindInitializerExpressionOrValue(elementInitializer, initializerType, BindValueKind.RValue, implicitReceiver.Syntax, diagnostics); 5753CheckRequiredMembersInObjectInitializer(creation.Constructor, creation.InitializerExpressionOpt?.Initializers ?? default, creation.Syntax, diagnostics); 6777CheckFeatureAvailability(boundLeft.Syntax, MessageID.IDS_FeatureStaticAbstractMembersInInterfaces, diagnostics); 6782Error(diagnostics, ErrorCode.ERR_LookupInTypeVariable, boundLeft.Syntax, leftType); 6829diagnostics.Add(expr.Syntax, useSiteInfo); 8019Error(diagnostics, ErrorCode.WRN_NegativeArrayIndex, index.Syntax); 8033var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(expr.Syntax, isEquivalentToThisReference: expr.IsEquivalentToThisReference, expr.Type) { WasCompilerGenerated = true }; 8034var argumentPlaceholders = ImmutableArray.Create(new BoundImplicitIndexerValuePlaceholder(convertedArguments[0].Syntax, int32) { WasCompilerGenerated = true }); 8065var node = index.Syntax; 8173BoundExpression result = CreateConversion(expr.Syntax, expr, conversion, isCast: false, conversionGroupOpt: null, destination: targetType, diagnostics); // UNDONE: was cast? 8214Error(diagnostics, ErrorCode.ERR_VoidError, expr.Syntax); 8232Error(diagnostics, ErrorCode.ERR_BadArgExtraRef, analyzedArguments.Argument(i).Syntax, i + 1, refKind.ToArgumentDisplayString()); 8312var syntax = propertyGroup.Syntax; 8555var receiverPlaceholder = new BoundImplicitIndexerReceiverPlaceholder(receiver.Syntax, isEquivalentToThisReference: receiver.IsEquivalentToThisReference, receiver.Type) { WasCompilerGenerated = true }; 8883node, node.Syntax, node.Name, analyzedArguments, isMethodGroupConversion, ref useSiteInfo, 9101return GetMethodGroupOrLambdaDelegateType(node.Syntax, method); 9137PopulateExtensionMethodsFromSingleBinder(scope, methodGroup, node.Syntax, receiver, node.Name, node.TypeArgumentsOpt, BindingDiagnosticBag.Discarded); 9436diagnostics.Add(new CSDiagnostic(diagnosticInfo, access.Syntax.Location)); 9437receiver = BadExpression(receiver.Syntax, receiver); 9479if (receiver?.Syntax != GetConditionalReceiverSyntax(conditionalAccessNode)) 9494receiver = 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); 265unconvertedInterpolatedString.Syntax, 356binaryOperator.Syntax, 365convertedBinaryOperator = UpdateBinaryOperatorWithInterpolatedContents(binaryOperator, appendCalls, data, binaryOperator.Syntax, diagnostics); 386expression.Syntax, 396original.Syntax, 437unconvertedInterpolatedString.Syntax, 447unconvertedInterpolatedString.Syntax, 474binaryOperator.Syntax, 482var result = UpdateBinaryOperatorWithInterpolatedContents(binaryOperator, appendCalls, data, binaryOperator.Syntax, diagnostics); 543CheckFeatureAvailability(value.Syntax, MessageID.IDS_FeatureImprovedInterpolatedStrings, diagnostics); 553CheckFeatureAvailability(value.Syntax, MessageID.IDS_FeatureImprovedInterpolatedStrings, diagnostics); 685var objectType = GetSpecialType(SpecialType.System_Object, diagnostics, unconvertedInterpolatedString.Syntax); 771parameterNamesAndLocationsBuilder.Add(("alignment", insert.Alignment.Syntax.Location)); 777parameterNamesAndLocationsBuilder.Add(("format", insert.Format.Syntax.Location)); 807var call = MakeInvocationExpression(part.Syntax, implicitBuilderReceiver, methodName, arguments, diagnostics, names: parameterNamesAndLocations, searchExtensionMethodsIfNecessary: false); 821diagnostics.Add(ErrorCode.ERR_InterpolatedStringHandlerMethodReturnMalformed, part.Syntax.Location, method); 831diagnostics.Add(ErrorCode.ERR_InterpolatedStringHandlerMethodReturnInconsistent, part.Syntax.Location, method, expected); 874diagnostics.Add(ErrorCode.ERR_InterpolatedStringHandlerArgumentAttributeMalformed, unconvertedString.Syntax.Location, interpolatedStringParameter, interpolatedStringParameter.Type); 876unconvertedString.Syntax, 892unconvertedString.Syntax, 975unconvertedString.Syntax.Location, 994arguments[argumentIndex].Syntax.Location, 1014placeholderSyntax = receiver.Syntax; 1017placeholderSyntax = unconvertedString.Syntax; 1021placeholderSyntax = arguments[argumentIndex].Syntax; 1049interpolatedString.Syntax,

218Error(diagnostics, ErrorCode.ERR_CantUseVoidInArglist, argument.Syntax); 233Error(diagnostics, ErrorCode.ERR_CantUseInOrOutInArglist, argument.Syntax); 419Error(diagnostics, ErrorCode.ERR_NamedArgumentSpecificationBeforeFixedArgumentInDynamicInvocation, arguments.Arguments[i].Syntax); 459Error(diagnostics, ErrorCode.ERR_InDynamicMethodArg, arguments[argIndex].Syntax); 480Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArgLambda, arg.Syntax); 486Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArgMemgrp, arg.Syntax); 494Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, "__arglist"); 503Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, arg.Syntax, arg.Type); 889Error(diagnostics, ErrorCode.ERR_NoImplicitConv, call.ReceiverOpt.Syntax, distinguisher.First, distinguisher.Second); 895Error(diagnostics, ErrorCode.ERR_NoImplicitConv, call.ReceiverOpt.Syntax, distinguisher.First, distinguisher.Second); 909Error(diagnostics, ErrorCode.ERR_BadDynamicMethodArg, dynInvoke.Expression.Syntax, dynInvoke.Expression.Type); 1068CheckFeatureAvailability(receiverArgument.Syntax, MessageID.IDS_FeatureRefExtensionMethods, diagnostics); 1074CheckFeatureAvailability(receiverArgument.Syntax, MessageID.IDS_FeatureRefExtensionMethods, diagnostics); 1396defaultValue = new BoundLiteral(syntax, ConstantValue.Create(argument.Syntax.ToString()), Compilation.GetSpecialType(SpecialType.System_String)) { WasCompilerGenerated = true }; 1447defaultValue.Syntax, 1484Error(diagnostics, ErrorCode.WRN_ImplicitCopyInReadOnlyMember, receiver.Syntax, method, ThisParameterSymbol.SymbolName); 1919diagnostics.Add(methodGroup.Syntax, useSiteInfo); 1923diagnostics.Add(ErrorCode.ERR_NameofExtensionMethod, methodGroup.Syntax.Location); 2035boundExpression.Syntax,

63var placeholder = new BoundValuePlaceholder(right.Syntax, left.HasDynamicType() ? left.Type : right.Type).MakeCompilerGenerated(); 243var leftPlaceholder = new BoundValuePlaceholder(left.Syntax, leftType).MakeCompilerGenerated(); 756left = BindSimpleBinaryOperator((BinaryExpressionSyntax)current.Syntax, diagnostics, left ?? current.Left, right, leaveUnconvertedIfInterpolatedString: false); 791GenerateImplicitConversionError(diagnostics, right.Syntax, conversion, right, left.Type); 1043var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, left.Type).MakeCompilerGenerated(); 1044CreateConversion(left.Syntax, operandPlaceholder, implicitConversion, isCast: false, conversionGroupOpt: null, booleanType, diagnostics); 1051diagnostics.Add(left.Syntax, useSiteInfo); 1057diagnostics.Add(left.Syntax, useSiteInfo); 1063diagnostics.Add(left.Syntax, useSiteInfo); 1818Error(diagnostics, ErrorCode.ERR_ConstantStringTooLong, right.Syntax); 2326var operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 2417Error(diagnostics, ErrorCode.ERR_IllegalSuppression, expr.Syntax); 2423Error(diagnostics, ErrorCode.ERR_DuplicateNullSuppression, expr.Syntax); 2568bool receiverIsLValue = CheckValueKind(receiver.Syntax, receiver, BindValueKind.AddressOf, checkingReceiver: false, diagnostics: BindingDiagnosticBag.Discarded); 2675Error(diagnostics, ErrorCode.ERR_IllegalSuppression, expr.Syntax); 2745var resultOperand = CreateConversion(operand.Syntax, operand, best.Conversion, isCast: false, conversionGroupOpt: null, signature.OperandType, diagnostics); 3041if (node.Operand != operand.Syntax || operand.Syntax.Kind() != SyntaxKind.NumericLiteralExpression) 3046var literal = (LiteralExpressionSyntax)operand.Syntax; 3711operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 3721operand = new BoundDefaultExpression(operand.Syntax, targetType: null, constantValueOpt: ConstantValue.Null, 3758operandPlaceholder = new BoundValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated(); 3971var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 3993var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType0).MakeCompilerGenerated(); 4012var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 4062var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType0).MakeCompilerGenerated(); 4076var leftPlaceholder = new BoundValuePlaceholder(leftOperand.Syntax, optLeftType).MakeCompilerGenerated(); 4279diagnostics.Add(ErrorCode.ERR_RefConditionalDifferentTypes, falseExpr.Syntax.Location, trueType); 4315CheckValEscape(falseExpr.Syntax, falseExpr, currentScope, whenTrueEscape, checkingReceiver: false, diagnostics: diagnostics); 4317CheckValEscape(trueExpr.Syntax, trueExpr, currentScope, whenFalseEscape, checkingReceiver: false, diagnostics: diagnostics);

34expression = BadExpression(expression.Syntax, expression); 59this.Compilation, pattern.Syntax, expression, innerPattern, whenTrueLabel: whenTrueLabel, whenFalseLabel: whenFalseLabel, diagnostics); 604diagnostics.Add(ErrorCode.ERR_ValueCantBeNull, expression.Syntax.Location, inputType); 614diagnostics.Add(ErrorCode.ERR_PatternWrongType, expression.Syntax.Location, inputType, expression.Display); 626expression.Syntax.Location, inputType, expression.Display, new CSharpRequiredLanguageVersion(requiredVersion)); 664diagnostics.Add(ErrorCode.ERR_PatternSpanCharCannotBeStringNull, convertedExpression.Syntax.Location, inputType);

735yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), CreateErrorType()); 741yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), yExpression.Type); 802field2Value = new BoundBadExpression(field2Value.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(field2Value), field2Value.Type, true); 817new AnonymousTypeField(fieldName, fieldValue.Syntax.Location, TypeWithAnnotations.Create(TypeOrError(fieldValue)), RefKind.None, ScopedKind.None); 948diagnostics.Add(ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax.Location, ((BoundNamespaceExpression)ultimateReceiver).NamespaceSymbol, MessageID.IDS_SK_NAMESPACE.Localize()); 974receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType()); 981Error(diagnostics, ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax, ultimateReceiver.Type, MessageID.IDS_SK_TYVAR.Localize()); 996receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType());

155Debug.Assert(result.Syntax is StatementSyntax, "BoundStatement should be associated with a statement syntax."); 157Debug.Assert(System.Linq.Enumerable.Contains(result.Syntax.AncestorsAndSelf(), node), @"Bound statement (or one of its parents) 679Error(diagnostics, ErrorCode.WRN_UnobservedAwaitableExpression, expression.Syntax); 1242SyntaxNode initializerSyntax = initializerOpt.Syntax; 1309CheckFeatureAvailability(initializerOpt.Syntax, MessageID.IDS_FeatureExtensibleFixedStatement, diagnostics); 1338var result = PerformPatternMethodLookup(initializer, methodName, initializer.Syntax, additionalDiagnostics, out var patternMethodSymbol); 1351additionalDiagnostics.Add(ErrorCode.WRN_PatternBadSignature, initializer.Syntax.Location, initializer.Type, "fixed", patternMethodSymbol); 1372SyntaxNode initializerSyntax = initializer.Syntax; 1476diagnostics.Add(ErrorCode.ERR_VoidAssignment, op1.Syntax.Location); 1571Error(diagnostics, errorCode, node, getName(op1), op2.Syntax); 1592Error(diagnostics, errorCode, node, getName(op1), op2.Syntax); 1684var syntax = expr.Syntax; 1732SyntaxNode syntax = expr.Syntax; 1934diagnostics.Add(expression.Syntax, useSiteInfo); 1940Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, expression.Syntax, targetType); 1958GenerateImplicitConversionError(diagnostics, expression.Syntax, conversion, expression, targetType); 1965return CreateConversion(expression.Syntax, expression, conversion, isCast: false, conversionGroupOpt: null, targetType, diagnostics); 2368Error(diagnostics, ErrorCode.ERR_InvalidAddrOp, ((BoundAddressOfOperator)operand).Operand.Syntax); 2387GenerateImplicitConversionError(diagnostics, expr.Syntax, conversion, expr, targetType); 2487GenerateImplicitConversionError(diagnostics, argument.Syntax, elementConversion, argument, targetElementType); 2572diagnostics.Add(expr.Syntax, useSiteInfo); 2587Error(diagnostics, ErrorCode.WRN_IncorrectBooleanAssg, assignment.Syntax); 2593syntax: expr.Syntax, 3065Error(diagnostics, ErrorCode.ERR_RefReturnMustHaveIdentityConversion, argument.Syntax, returnType); 3082Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType, argument.Type); 3086GenerateImplicitConversionError(diagnostics, argument.Syntax, conversion, argument, returnType); 3089ReportCantConvertLambdaReturn(argument.Syntax, diagnostics); 3096return CreateConversion(argument.Syntax, argument, conversion, isCast: false, conversionGroupOpt: null, returnType, diagnostics); 3349var syntax = expressionSyntax ?? expression.Syntax;

1432diagnostics.Add(colorColorValueReceiver.Syntax, useSiteInfo); 1439Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, colorColorValueReceiver.Syntax, parameter.Name, parameter.Type, parameter); 1449receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Ambiguous, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(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);

135return MakeBoundDecisionDag(syntax, ImmutableArray.Create(MakeTestsForPattern(index: 1, pattern.Syntax, rootIdentifier, pattern, whenClause: null, whenTrueLabel))); 150if (label.Syntax.Kind() != SyntaxKind.DefaultSwitchLabel) 152builder.Add(MakeTestsForPattern(++i, label.Syntax, rootIdentifier, label.Pattern, label.WhenClause, label.Label)); 172builder.Add(MakeTestsForPattern(++i, arm.Syntax, rootIdentifier, arm.Pattern, arm.WhenClause, arm.Label)); 321var syntax = pattern.Syntax; 399input = MakeConvertToType(input, declaration.Syntax, type!, isExplicitTest: false, tests); 423output = MakeConvertToType(input: input, syntax: typePattern.Syntax, type: type, isExplicitTest: typePattern.IsExplicitNotNullTest, tests: tests); 487return new Tests.One(new BoundDagExplicitNullTest(constant.Syntax, input)); 492return new Tests.One(new BoundDagValueTest(constant.Syntax, constant.ConstantValue, input)); 498output = input = constant.Value.Type is { } type ? MakeConvertToType(input, constant.Syntax, type, isExplicitTest: false, tests) : input; 507tests.Add(new Tests.One(new BoundDagValueTest(constant.Syntax, constant.ConstantValue, input))); 522output = input = MakeConvertToType(input, recursive.Syntax, inputType, isExplicitTest: recursive.IsExplicitNotNullTest, tests); 530var evaluation = new BoundDagDeconstructEvaluation(recursive.Syntax, method, OriginalInput(input, method)); 537SyntaxNode syntax = pattern.Syntax; 558SyntaxNode syntax = pattern.Syntax; 571tests.Add(new Tests.One(new BoundDagTypeTest(recursive.Syntax, ErrorType(), input, hasErrors: true))); 585tests.Add(new Tests.One(new BoundDagTypeTest(recursive.Syntax, ErrorType(), input, hasErrors: true))); 611input = MakeConvertToType(input, member.Syntax, member.Receiver.Type.StrippedType(), isExplicitTest: false, tests); 618evaluation = new BoundDagPropertyEvaluation(member.Syntax, property, isLengthOrCount, OriginalInput(input, property)); 621evaluation = new BoundDagFieldEvaluation(member.Syntax, field, OriginalInput(input, field)); 628input = new BoundDagTemp(member.Syntax, member.Type, evaluation); 660output = MakeConvertToType(input: input, syntax: bin.Syntax, type: bin.NarrowedType, isExplicitTest: false, tests: builder); 682output = MakeConvertToType(input, rel.Syntax, rel.Value.Type, isExplicitTest: false, tests); 691tests.Add(new Tests.One(new BoundDagRelationalTest(rel.Syntax, rel.Relation, rel.ConstantValue, output, rel.HasErrors))); 723var boundDecisionDag = new BoundDecisionDag(rootDecisionDagNode.Syntax, rootDecisionDagNode); 908state.SelectedTest = new BoundDagNonNullTest(t.Syntax, isExplicitTest: true, t.Input, t.HasErrors); 999state.Dag = uniqifyDagNode(new BoundEvaluationDecisionDagNode(e.Syntax, e, next)); 1008state.Dag = uniqifyDagNode(new BoundTestDecisionDagNode(d.Syntax, d, whenTrue, whenFalse)); 1421Debug.Assert(s1LengthTemp.Syntax is ListPatternSyntax); 1422Debug.Assert(s2LengthTemp.Syntax is ListPatternSyntax); 1426s1LengthTemp.Syntax != s2LengthTemp.Syntax) 1691builder.Append($" WHEN[{cd.WhenClause.Syntax}]"); 1992SyntaxNode syntax = test.Syntax; 2064if (e.Syntax.IsKind(SyntaxKind.ListPattern)) 2087new One(new BoundDagValueTest(t.Syntax, safeAdd(t.Value, offset), lengthTemp)); 2091new One(new BoundDagRelationalTest(t.Syntax, t.OperatorKind, safeAdd(t.Value, offset), lengthTemp));

21var syntax = list.Syntax; 24output = input = MakeConvertToType(input, list.Syntax, list.NarrowedType, isExplicitTest: false, tests); 28tests.Add(new Tests.One(new BoundDagTypeTest(list.Syntax, ErrorType(), input, hasErrors: true))); 63var sliceEvaluation = new BoundDagSliceEvaluation(slicePattern.Syntax, slicePattern.InputType, lengthTemp, startIndex: startIndex, endIndex: index, 67var sliceTemp = new BoundDagTemp(slicePattern.Syntax, slicePattern.InputType, sliceEvaluation); 78var indexEvaluation = new BoundDagIndexerEvaluation(subpattern.Syntax, subpattern.InputType, lengthTemp, index++, 82var indexTemp = new BoundDagTemp(subpattern.Syntax, subpattern.InputType, indexEvaluation);

227messageId.CheckFeatureAvailability(diagnostics, Compilation, collectionExpr.Syntax.Location); 231Error(diagnostics, ErrorCode.ERR_RefLvalueExpected, collectionExpr.Syntax); 337collectionExpr.Syntax, 451Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, collectionExpr.Syntax, iterationVariableType.Type); 534BoundExpression convertedCollectionExpression = CreateConversion(collectionExpr.Syntax, collectionExpr, collectionConversionClassification, isCast: false, conversionGroupOpt: null, builder.CollectionType, diagnostics); 542collectionExpr.Syntax, 635inferredType = TypeWithAnnotations.Create(GetSpecialType(SpecialType.System_Char, diagnostics, collectionExpr.Syntax)); 653SyntaxNode exprSyntax = collectionExpr.Syntax; 935collectionExpr.Syntax, 1052CheckFeatureAvailability(expr.Syntax, MessageID.IDS_FeatureDisposalPattern, diagnostics); 1326collectionExpr.Syntax, 1339collectionExpr.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);

487ValidateAssignment(node.Syntax, node.Left, node.Right, node.IsRef, _diagnostics); 562ValidateRefConditionalOperator(node.Syntax, node.Consequence, node.Alternative, _diagnostics); 590node.Syntax, 644node.Syntax, 667node.Syntax, 690node.Syntax, 729VisitDeconstructionArguments(variables, right.Syntax, right.Conversion, right.Operand);

158GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateInvokeMethodOpt.Parameters, binder.Compilation); 202diagnostics.Add(expr.Syntax, useSiteInfo); 238expr.Syntax.Location, 249expr.Syntax.Location, 261binder: binder, location: expr.Syntax.Location, nodeOpt: expr.Syntax, diagnostics: overloadDiagnostics, 263receiver: resolution.MethodGroup.Receiver, invokedExpression: expr.Syntax, arguments: resolution.AnalyzedArguments,

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

1394Conversions.GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateParameters, binder.Compilation);

1133SourceLocation 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);

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

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

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

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

20this.Syntax,

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

99if (this.HasErrors || this.Syntax != null && this.Syntax.HasErrors) 142return Syntax?.SyntaxTree; 373if (Syntax != null) 375result += " " + Syntax.ToString();

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

21this.Syntax,

19this.Syntax,

185SyntaxNode syntax = node.Syntax;

651public 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; } } 430var lambda = new UnboundLambda(Syntax, data, FunctionType, WithDependencies, nullableState, HasErrors); 443var lambda = new UnboundLambda(Syntax, data, FunctionType, WithDependencies, _nullableState, HasErrors); 573this.Binder.GenerateAnonymousFunctionConversionError(diagnostics, _unboundLambda.Syntax, _unboundLambda, targetType); 681var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder)); 727_unboundLambda.Syntax, 773lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder), inExpressionTree ? BinderFlags.InExpressionTree : BinderFlags.None); 835var result = new BoundLambda(_unboundLambda.Syntax, _unboundLambda, block, diagnostics.ToReadOnlyAndFree(), lambdaBodyBinder, delegateType, inferredReturnType: default) 931_unboundLambda.Syntax, 960var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, GetWithParametersBinder(lambdaSymbol, Binder)); 1181_unboundLambda.Syntax, 1454public override MessageID MessageID { get { return this.UnboundLambda.Syntax.Kind() == SyntaxKind.AnonymousMethodExpression ? MessageID.IDS_AnonMethod : MessageID.IDS_Lambda; } } 1460return UnboundLambda.Syntax.AnonymousFunctionBody(); 1467var 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(); 98return new BoundFieldAccess(this.Syntax, 120switch (this.Syntax.Kind()) 123designation = (SingleVariableDesignationSyntax)((DeclarationExpressionSyntax)this.Syntax).Designation; 126designation = (SingleVariableDesignationSyntax)this.Syntax;

193result = AllocateTemp(_method.ReturnType, _boundBody.Syntax, slotConstraints); 368SyntaxNode syntax = node.Syntax; 443Debug.Assert(node.Syntax is { }); 447EmitStepThroughSequencePoint(node.Syntax.SyntaxTree, span); 452EmitStepThroughSequencePoint(node.Syntax.SyntaxTree, node.Span);

140var temp = this.AllocateTemp(type, expression.Syntax); 144EmitSymbolToken(type, expression.Syntax); 241EmitInitObj(receiverType, true, expression.Syntax); 242EmitBox(receiverType, expression.Syntax); 315EmitSymbolToken(refValue.Type, refValue.Syntax); 328var value = this.AllocateTemp(expression.Type, expression.Syntax); 404EmitSymbolToken(elementType, arrayAccess.Syntax); 409arrayAccess.Syntax, _diagnostics.DiagnosticBag); 444EmitStaticFieldAddress(field, fieldAccess.Syntax); 527EmitBox(receiver.Type, receiver.Syntax); 556EmitSymbolToken(field, fieldAccess.Syntax); 579EmitSymbolToken(fixedElementField, fieldAccess.Syntax);

57_builder.EmitArrayBlockInitializer(data, inits.Syntax, _diagnostics.DiagnosticBag); 92EmitVectorElementStore(arrayType, init.Syntax); 207EmitArrayElementStore(arrayType, init.Syntax); 455var rosPointerCtor = (MethodSymbol?)Binder.GetWellKnownTypeMember(_module.Compilation, WellKnownMember.System_ReadOnlySpan_T__ctor_Pointer, _diagnostics, syntax: wrappedExpression.Syntax, isOptional: true); 540EmitSymbolToken(spanType, wrappedExpression.Syntax); 550EmitDefaultValue(spanType, used, wrappedExpression.Syntax); 572var field = _builder.module.GetFieldForData(data, alignment: 1, wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 574_builder.EmitToken(field, wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 590EmitSymbolToken(rosPointerCtor.AsMember(spanType), wrappedExpression.Syntax, optArgList: null); 625MethodSymbol? createSpan = (MethodSymbol?)Binder.GetWellKnownTypeMember(_module.Compilation, WellKnownMember.System_Runtime_CompilerServices_RuntimeHelpers__CreateSpanRuntimeFieldHandle, _diagnostics, syntax: wrappedExpression.Syntax, isOptional: true); 633var field = _builder.module.GetFieldForData(data, alignment: (ushort)specialElementType.SizeInBytes(), wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 635_builder.EmitToken(field, wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 637EmitSymbolToken(createSpan.Construct(elementType), wrappedExpression.Syntax, optArgList: null); 645var rosArrayCtor = (MethodSymbol?)Binder.GetWellKnownTypeMember(_module.Compilation, WellKnownMember.System_ReadOnlySpan_T__ctor_Array, _diagnostics, syntax: wrappedExpression.Syntax, isOptional: true); 665var cachingField = _builder.module.GetArrayCachingFieldForData(data, _module.Translate(arrayType), wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 671_builder.EmitToken(cachingField, wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 681EmitSymbolToken(arrayType.ElementType, wrappedExpression.Syntax); 682_builder.EmitArrayBlockInitializer(data, wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 685_builder.EmitToken(cachingField, wrappedExpression.Syntax, _diagnostics.DiagnosticBag); 691EmitSymbolToken(rosArrayCtor.AsMember(spanType), wrappedExpression.Syntax, optArgList: null);

86EmitSymbolToken(expression.ConversionMethod, expression.Syntax, optArgList: null); 231EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 242EmitSymbolToken(conversion.Type, conversion.Syntax); 250EmitStaticCast(conversion.Type, conversion.Syntax); 263EmitBox(conversion.Operand.Type, conversion.Operand.Syntax); 274EmitSymbolToken(conversion.Type, conversion.Syntax); 279EmitSymbolToken(conversion.Type, conversion.Syntax); 336EmitSymbolToken(receiver.Type, receiver.Syntax); 344EmitBox(receiver.Type, receiver.Syntax); 367EmitSymbolToken(method, node.Syntax, null); 372var ctor = DelegateConstructor(node.Syntax, delegateType); 373if ((object)ctor != null) EmitSymbolToken(ctor, node.Syntax, null);

55EmitConstantExpression(expression.Type, constantValue, used, expression.Syntax); 178EmitLoadIndirect(thisType, expression.Syntax); 179EmitBox(thisType, expression.Syntax); 359EmitDefaultValue(node.Type, used, node.Syntax); 372EmitInitObj(receiverType, true, expression.Syntax); 373EmitBox(receiverType, expression.Syntax); 456EmitDefaultValue(receiverType, true, receiver.Syntax); 457EmitBox(receiverType, receiver.Syntax); 459EmitLoadIndirect(receiverType, receiver.Syntax); 461cloneTemp = AllocateTemp(receiverType, receiver.Syntax); 465EmitBox(receiverType, receiver.Syntax); 476EmitLoadIndirect(receiverType, receiver.Syntax); 477EmitBox(receiverType, receiver.Syntax); 509EmitSymbolToken(hasValueOpt, expression.Syntax, null); 530EmitDefaultValue(expression.Type, used, expression.Syntax); 646EmitLoadIndirect(expression.Type, expression.Syntax); 655EmitLoadIndirect(expression.Type, expression.Syntax); 668EmitSymbolToken(expression.Operand.Type, expression.Operand.Syntax); 683EmitSymbolToken(getTypeMethod, expression.Syntax, null); 757EmitLoadIndirect(expression.Type, expression.Syntax); 778EmitLoadIndirect(expression.Type, expression.Syntax); 800EmitLoadIndirect(thisType, thisRef.Syntax); 820var syntax = node.Syntax; 866DefineLocal(local, sequence.Syntax); 900var seqLocal = DefineLocal(local, sequence.Syntax); 1065EmitSymbolToken(elementType, arrayAccess.Syntax); 1072_builder.EmitArrayElementLoad(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Expression.Syntax, _diagnostics.DiagnosticBag); 1106EmitLoadIndirect(field.Type, fieldAccess.Syntax); 1125EmitSymbolToken(field, fieldAccess.Syntax); 1152EmitSymbolToken(field, fieldAccess.Syntax); 1198EmitSymbolToken(receiver.Type, receiver.Syntax); 1212EmitSymbolToken(field, fieldAccess.Syntax); 1374EmitLoadIndirect(local.LocalSymbol.Type, local.Syntax); 1387EmitLoadIndirect(parameterType, parameter.Syntax); 1610EmitSymbolToken(method.ContainingType, call.Syntax); 1634EmitSymbolToken(receiver.Type, receiver.Syntax); 1639EmitSymbolToken(method, call.Syntax, 1642EmitCallCleanup(call.Syntax, useKind, method); 1716EmitBox(receiverType, receiver.Syntax); 1788EmitSymbolToken(receiver.Type, receiver.Syntax); 1793EmitSymbolToken(actualMethodTargetedByTheCall, call.Syntax, 1796EmitCallCleanup(call.Syntax, useKind, method); 1841EmitDefaultValue(receiverType, true, receiver.Syntax); 1842EmitBox(receiverType, receiver.Syntax); 1849EmitLoadIndirect(receiverType, receiver.Syntax); 1850tempOpt = AllocateTemp(receiverType, receiver.Syntax); 2158EmitSymbolToken(arrayType.ElementType, expression.Syntax); 2162_builder.EmitArrayCreation(_module.Translate(arrayType), expression.Syntax, _diagnostics.DiagnosticBag); 2209EmitInitObj(expression.Type, used, expression.Syntax); 2238EmitSymbolToken(constructor, expression.Syntax, 2461EmitSymbolToken(target.Type, target.Syntax); 2495EmitSymbolToken(constructor, objCreation.Syntax, 2833assignmentOperator.Left.Syntax, 2861EmitIndirectStore(local.LocalSymbol.Type, local.Syntax); 2880EmitArrayElementStore(arrayType, expression.Syntax); 2893EmitIndirectStore(expression.Type, expression.Syntax); 2898EmitIndirectStore(expression.Type, expression.Syntax); 2904EmitIndirectStore(expression.Type, expression.Syntax); 2916EmitIndirectStore(expression.Type, expression.Syntax); 2921EmitIndirectStore(expression.Type, expression.Syntax); 2938EmitIndirectStore(nested.Type, expression.Syntax); 2965EmitLoadIndirect(assignment.Type, assignment.Syntax); 2974EmitSymbolToken(thisRef.Type, thisRef.Syntax); 3068EmitIndirectStore(field.Type, fieldAccess.Syntax); 3073EmitSymbolToken(field, fieldAccess.Syntax); 3083EmitIndirectStore(parameter.ParameterSymbol.Type, parameter.Syntax); 3171EmitBox(operand.Type, operand.Syntax); 3174EmitSymbolToken(isOp.TargetType.Type, isOp.Syntax); 3196EmitBox(operandType, operand.Syntax); 3199EmitSymbolToken(targetType, asOp.Syntax); 3204EmitSymbolToken(targetType, asOp.Syntax); 3250EmitDefaultValue(expression.Type, used, expression.Syntax); 3287EmitSymbolToken(getTypeMethod, boundTypeOf.Syntax, null); 3294EmitSymbolToken(type, boundTypeOfOperator.SourceType.Syntax); 3302EmitSymbolToken(type, boundSizeOfOperator.SourceType.Syntax); 3320EmitSymbolToken(symbol, node.Syntax, null, encodeAsRawDefinitionToken: true); 3333EmitHoistedVariableId(node.HoistedField, node.Syntax); 3347EmitHoistedVariableId(node.HoistedField, node.Syntax); 3381_builder.EmitToken(_module.GetModuleVersionId(_module.Translate(node.Type, node.Syntax, _diagnostics.DiagnosticBag), node.Syntax, _diagnostics.DiagnosticBag), node.Syntax, _diagnostics.DiagnosticBag); 3404_builder.EmitToken(_module.GetInstrumentationPayloadRoot(node.AnalysisKind, _module.Translate(node.Type, node.Syntax, _diagnostics.DiagnosticBag), node.Syntax, _diagnostics.DiagnosticBag), node.Syntax, _diagnostics.DiagnosticBag); 3417EmitSymbolToken(node.Method, node.Syntax, null); 3430EmitSymbolToken(node.Method.ContainingType, node.Syntax); 3434EmitSymbolToken(getMethod, node.Syntax, null); 3438EmitSymbolToken(node.Type, node.Syntax); 3445EmitSymbolToken(node.Field, node.Syntax); 3457EmitSymbolToken(node.Field.ContainingType, node.Syntax); 3461EmitSymbolToken(getField, node.Syntax, null); 3465EmitSymbolToken(node.Type, node.Syntax); 3516EmitStaticCast(expr.Type, expr.Syntax); 3521EmitStaticCast(expr.Type, expr.Syntax); 3540EmitStaticCast(expr.Type, expr.Syntax); 3545EmitStaticCast(expr.Type, expr.Syntax); 3577EmitStaticCast(expr.Type, expr.Syntax); 3582EmitStaticCast(expr.Type, expr.Syntax); 3590EmitBox(expr.Type, expr.LeftOperand.Syntax); 3607EmitStaticCast(expr.Type, expr.Syntax); 3751temp = AllocateTemp(ptrInvocation.InvokedExpression.Type, ptrInvocation.Syntax); 3766EmitSignatureToken(ptrInvocation.FunctionPointer, ptrInvocation.Syntax); 3767EmitCallCleanup(ptrInvocation.Syntax, useKind, method); 3838EmitSymbolToken(load.ConstrainedToTypeOpt, load.Syntax); 3842EmitSymbolToken(load.TargetMethod, load.Syntax, optArgList: null);

441EmitBox(comparandType, comparand.Syntax); 455EmitBox(comparandType, comparand.Syntax);

53var field = _builder.module.GetFieldForData(data, alignment: 1, inits.Syntax, _diagnostics.DiagnosticBag); 56_builder.EmitToken(field, inits.Syntax, _diagnostics.DiagnosticBag); 134EmitIndirectStore(elementType, init.Syntax); 173EmitSymbolToken(elementType, init.Syntax);

182this.EmitBox(exprType, thrown.Syntax); 593EmitBox(operand.Type, operand.Syntax); 596EmitSymbolToken(isOp.TargetType.Type, isOp.TargetType.Syntax); 613EmitBox(conditionType, condition.Syntax); 681DefineLocal(instrumentation.Local, block.Syntax); 728DefineLocal(local, !declaringReferences.IsEmpty ? (CSharpSyntaxNode)declaringReferences[0].GetSyntax() : block.Syntax); 833(boundReturnStatement.Syntax.IsKind(SyntaxKind.Block) || _method?.IsImplicitConstructor == true) && 890_module.Translate(expressionOpt.Type, boundReturnStatement.Syntax, _diagnostics.DiagnosticBag); 1024_module.Translate(catchBlock.ExceptionTypeOpt, catchBlock.Syntax, _diagnostics.DiagnosticBag) : 1025_module.GetSpecialType(SpecialType.System_Object, catchBlock.Syntax, _diagnostics.DiagnosticBag); 1039var syntax = catchBlock.Syntax as CatchClauseSyntax; 1071var exceptionType = _module.Translate(catchBlock.ExceptionTypeOpt, catchBlock.Syntax, _diagnostics.DiagnosticBag); 1074_builder.EmitToken(exceptionType, catchBlock.Syntax, _diagnostics.DiagnosticBag); 1092var localSyntax = !declaringReferences.IsEmpty ? (CSharpSyntaxNode)declaringReferences[0].GetSyntax() : catchBlock.Syntax; 1106EmitSymbolToken(exceptionSourceOpt.Type, exceptionSourceOpt.Syntax); 1144var temp = AllocateTemp(exceptionSource.Type, exceptionSource.Syntax); 1276temp = AllocateTemp(expression.Type, expression.Syntax); 1290this.EmitStringSwitchJumpTable(switchCaseLabels, fallThroughLabel, key, expression.Syntax, expression.Type); 1294this.EmitLengthBasedStringSwitchJumpTable(lengthBasedSwitchStringJumpTableOpt, fallThroughLabel, key, expression.Syntax, expression.Type);

1591PushEvalStack(new BoundDefaultExpression(node.Syntax, node.Operand.Type), ExprContext.Value); 2067return new BoundDup(node.Syntax, node.LocalSymbol.RefKind, node.Type);

2060boundNodeForSyntacticParent.Syntax.Kind() == SyntaxKind.ObjectCreationExpression && 2061((ObjectCreationExpressionSyntax)boundNodeForSyntacticParent.Syntax).Type == boundExpr.Syntax)) // Do not return any type information for a ObjectCreationExpressionSyntax.Type node. 2206var binder = this.GetEnclosingBinder(boundExpr.Syntax.Span.Start); 3363if (expr.Syntax.Kind() is SyntaxKind.ObjectCreationExpression or SyntaxKind.ImplicitObjectCreationExpression) 3390boundNodeForSyntacticParent.Syntax.Kind() == SyntaxKind.ObjectCreationExpression && 3391((ObjectCreationExpressionSyntax)boundNodeForSyntacticParent.Syntax).Type == boundType.Syntax && 3670Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 3961SyntaxNode parentSyntax = boundNodeForSyntacticParent.Syntax; 3963parentSyntax == boundNode.Syntax.Parent && 3964parentSyntax.Kind() == SyntaxKind.Attribute && ((AttributeSyntax)parentSyntax).Name == boundNode.Syntax) 4011Debug.Assert(binderOpt != null || IsInTree(lowestBoundNode.Syntax)); 4015Debug.Assert(lowestBoundNode.Syntax != null); 4020Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(lowestBoundNode.Syntax)); 4071Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4080Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 4225Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4238Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(boundNode.Syntax)); 4250InvocationExpressionSyntax invocation = call.Syntax as InvocationExpressionSyntax; 4251if (invocation != null && invocation.Expression.SkipParens() == ((ExpressionSyntax)boundNode.Syntax).SkipParens() && (object)call.Method != null) 4370Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax)); 4392var elementAccess = indexer.Syntax as ElementAccessExpressionSyntax; 4393if (elementAccess != null && elementAccess.Expression == boundNode.Syntax && (object)indexer.Indexer != null)

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

1449alreadyInTree = _guardedBoundNodeMap.ContainsKey(bound.Syntax); 1457Debug.Assert(syntax != _root || _guardedBoundNodeMap.ContainsKey(bound.Syntax)); 1481alreadyInTree = _guardedBoundNodeMap.ContainsKey(bound.Syntax); 1493Debug.Assert(syntax != _root || _guardedBoundNodeMap.ContainsKey(bound.Syntax)); 1802return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, unbound.Syntax), 1803position, unbound.BindForErrorRecovery().Binder, unbound.Syntax); 1806return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, lambda.Body.Syntax), 1807position, lambda.Binder, lambda.Body.Syntax); 1815return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, queryClause.Syntax), 1816position, queryClause.Binder, queryClause.Syntax); 1831var span = expr.Syntax.FullSpan; 1850if (value.Syntax.FullSpan.Contains(position)) 1855if (expr.Syntax.FullSpan.Contains(position)) 1931_guardedBoundNodeMap.ContainsKey(bind(bindableRoot, out _).Syntax));

43Debug.Assert(node == null || root == null || !(root.Syntax is StatementSyntax), "individually added nodes are not supposed to be statements."); 45if (root == null || map.ContainsKey(root.Syntax)) 188_map.Add(current.Syntax, current); 208_map.Add(binOp.Syntax, binOp); 246if (_thisSyntaxNodeOnly != null && currentBoundNode.Syntax != _thisSyntaxNodeOnly) 275if (node.Syntax != node.Initializer?.Syntax)

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

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

1022body = BoundBlock.SynthesizedNoLocals(initializerStatements.Syntax, initializerStatements.Statements); 1174var syntax = body.Syntax; 1515return new BoundBadStatement(body.Syntax, ImmutableArray.Create<BoundNode>(body), hasErrors: true); 1895body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer)); 1899body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer, body)); 2239if (!LambdaUtilities.TryGetLambdaBodies(node.Syntax, out var body1, out var body2)) 2286var constructorInitializer = new BoundExpressionStatement(initializerInvocation.Syntax, initializerInvocation) { WasCompilerGenerated = method.IsImplicitlyDeclared }; 2301compilationState.ReportCtorInitializerCycles(method, ctorCall.Method, ctorCall.Syntax, diagnostics);

202int startLocation = firstInRegion.Syntax.SpanStart; 203int endLocation = lastInRegion.Syntax.Span.End; 891Diagnostics.Add(ErrorCode.ERR_InternalError, node.Syntax.Location); 1294VisitLocalFunctionUse(localFunc, node.Syntax, isCall: true); 1522VisitLocalFunctionUse(localFunc, node.Syntax, isCall: false); 1645VisitLocalFunctionUse(localFunc, node.Syntax, isCall: false); 2686if (AwaitUsingAndForeachAddsPendingBranch && ((CommonForEachStatementSyntax)node.Syntax).AwaitKeyword != default)

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

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

84if (IsInside && pending.Branch != null && !RegionContains(pending.Branch.Syntax.Span)) 106if (node.Syntax != null && RegionContains(node.Syntax.Span)) _labelsInside.Add(label); 136if (branch.Branch != null && RegionContains(branch.Branch.Syntax.Span) && !_labelsInside.Contains(branch.Label))

219var loc = new SourceLocation(leave.Syntax.GetFirstToken()); 227var loc = new SourceLocation(leave.Syntax.GetFirstToken()); 266statement.Syntax.Span.Length != 0) 268var firstToken = statement.Syntax.GetFirstToken(); 303var location = new SourceLocation(branch.Branch.Syntax.GetFirstToken()); 341var sourceLocation = node.Syntax.Location; 380var syntax = node.SwitchLabels.Last().Syntax;

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

387LeaveParameters(methodParameters, returnBranch.Branch.Syntax, null); 388if ((object)methodThisParameter != null) LeaveParameter(methodThisParameter, returnBranch.Branch.Syntax, null); 1523LeaveParameter(param, node.Syntax, paramExpr.Syntax.Location); 2190if ((localSymbol as SourceLocalSymbol)?.IsVar == true && localSymbol.ForbiddenZone?.Contains(node.Syntax) == true) 2204CheckAssigned(localSymbol, node.Syntax); 2211Diagnostics.Add(ErrorCode.ERR_FixedLocalInLambda, new SourceLocation(node.Syntax), localSymbol); 2279LeaveParameters(node.Symbol.Parameters, node.Syntax, null); 2288LeaveParameters(node.Symbol.Parameters, pending.Branch.Syntax, null); 2307CheckAssigned(MethodThisParameter, node.Syntax); 2315CheckAssigned(node.ParameterSymbol, node.Syntax); 2386if (_unassignedVariableAddressOfSyntaxes?.Contains(node.Syntax as PrefixUnaryExpressionSyntax) == false) 2393_unsafeAddressTakenVariables.Add(variable, node.Syntax.Location); 2410CheckAssigned(arg, arg.Syntax); 2505CheckAssigned(MethodThisParameter, node.Syntax); 2532if (node.FieldSymbol.IsFixedSizeBuffer && node.Syntax != null && !SyntaxFacts.IsFixedStatementExpression(node.Syntax)) 2540_unsafeAddressTakenVariables.Add(receiver, node.Syntax.Location); 2547CheckAssigned(node, node.FieldSymbol, node.Syntax); 2568ReportUnassignedIfNotCapturedInLocalFunction(backingField, node.Syntax, unassignedSlot); 2587CheckAssigned(node, associatedField, node.Syntax);

61if (!gotoStmt.WasCompilerGenerated && !targetStmt.WasCompilerGenerated && RegionContains(targetStmt.Syntax.Span) && !RegionContains(gotoStmt.Syntax.Span)) 62_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 }; 115var F = new SyntheticBoundNodeFactory(method, body.Syntax, compilationState, diagnostics); 172SyntaxNode syntax = body.Syntax;

576enforceMemberNotNull(syntaxOpt: pendingReturn.Branch.Syntax, pendingReturn.State); 580EnforceParameterNotNullOnExit(returnStatement.Syntax, pendingReturn.State); 765Diagnostics.Add(ErrorCode.WRN_MemberNotNull, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name); 776enforceMemberNotNullWhen(returnStatement.Syntax, sense: value, pendingReturn.State); 789enforceMemberNotNullWhenIfAffected(returnStatement.Syntax, sense: true, method.ContainingType.GetMembers(memberName), pendingReturn.StateWhenTrue, pendingReturn.StateWhenFalse); 794enforceMemberNotNullWhenIfAffected(returnStatement.Syntax, sense: false, method.ContainingType.GetMembers(memberName), pendingReturn.StateWhenFalse, pendingReturn.StateWhenTrue); 800enforceMemberNotNullWhen(returnStatement.Syntax, sense: value, pendingReturn.State); 836Diagnostics.Add(ErrorCode.WRN_MemberNotNullWhen, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name, sense ? "true" : "false"); 1115EnforceParameterNotNullWhenOnExit(returnStatement.Syntax, parameters, sense: value, stateWhen: pendingReturn.State); 1129ReportParameterIfBadConditionalState(returnStatement.Syntax, parameter, sense: true, stateWhen: pendingReturn.StateWhenTrue); 1130ReportParameterIfBadConditionalState(returnStatement.Syntax, parameter, sense: false, stateWhen: pendingReturn.StateWhenFalse); 1137EnforceParameterNotNullWhenOnExit(returnStatement.Syntax, parameters, sense: value, stateWhen: pendingReturn.State); 1170location = syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(); 1256var location = syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(); 1279ReportDiagnostic(ErrorCode.WRN_ShouldNotReturn, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation()); 1333compilation.GetBinderFactory(node.SyntaxTree).GetBinder(node.Syntax); 1760var key = (object?)symbol ?? methodMainNode.Syntax; 1803Debug.Assert(AreCloseEnough(originalSymbol, updatedSymbol), $"Attempting to set {node.Syntax} from {originalSymbol.ToDisplayString()} to {updatedSymbol.ToDisplayString()}"); 2251location ??= value.Syntax.GetLocation(); 2780CheckDisallowedNullAssignment(resultType, parameterAnnotations, equalsValue.Value.Syntax.Location); 2807EnforceDoesNotReturn(node.Syntax); 2837CheckDisallowedNullAssignment(returnState, ToInwardAnnotations(returnAnnotations), node.Syntax.Location, boundValueOpt: expr); 2849EnforceDoesNotReturn(node.Syntax); 2865EnforceNotNullIfNotNull(node.Syntax, this.State, method.Parameters, method.ReturnNotNullIfParameterNotNull, ResultType.State, outputParam: null); 2883ReportNullabilityMismatchInAssignment(expr.Syntax, lvalueResultType, destinationType); 2943if (local is SourceLocalSymbol { IsVar: true } && local.ForbiddenZone?.Contains(node.Syntax) == true) 3123EnforceParameterNotNullOnExit(returnStatement.Syntax, pendingReturn.State); 3833ReportDiagnostic(ErrorCode.WRN_NullReferenceInitializer, initializer.Syntax, symbol); 4690CheckDisallowedNullAssignment(resultType, parameterAnnotations, expr.Syntax.Location, operand); 5437ReportNullabilityMismatchInAssignment(node.Syntax, consequenceLValue, alternativeLValue); 5664new BoundExpressionWithNullability(expr.Syntax, expr, type.NullableAnnotation, type.Type); 6082var syntax = node.Syntax; 6215var syntax = node.Syntax; 6578ReportNullabilityMismatchInArgument(argumentNoConversion.Syntax, argumentResultType, parameter, parameterType.Type, forOutput: false); 6598if (CheckDisallowedNullAssignment(stateAfterConversion, parameterAnnotations, argumentNoConversion.Syntax.Location)) 6620CheckDisallowedNullAssignment(resultType, parameterAnnotations, argumentNoConversion.Syntax.Location); 6720var parameterValue = new BoundParameter(argument.Syntax, parameter); 6760var parameterValue = new BoundParameter(argument.Syntax, parameter); 6763CheckDisallowedNullAssignment(parameterWithState, leftAnnotations, argument.Syntax.Location); 6776ReportNullabilityMismatchInArgument(argument.Syntax, lValueType.Type, parameter, parameterType.Type, forOutput: true); 7160return new BoundExpressionWithNullability(argument.Syntax, argument, NullableAnnotation.Oblivious, type: null); 7162return new BoundExpressionWithNullability(argument.Syntax, argument, argumentType.NullableAnnotation, argumentType.Type); 7253ReportNullabilityMismatchInAssignment(sourceExpression.Syntax, GetTypeAsDiagnosticArgument(sourceType), destinationType); 7591var locations = tupleOpt.TupleElements.SelectAsArray((element, location) => element.Locations.FirstOrDefault() ?? location, node.Syntax.Location); 7592tupleOpt.CheckConstraints(new ConstraintsHelper.CheckConstraintsArgs(compilation, _conversions, includeNullability: true, node.Syntax.Location, diagnostics: null), 7593typeSyntax: node.Syntax, locations, nullabilityDiagnosticsOpt: new BindingDiagnosticBag(Diagnostics)); 7758diagnosticLocation: (conversionOpt ?? convertedNode).Syntax.GetLocation()); 7825if (lambda.Syntax is LambdaExpressionSyntax lambdaSyntax) 7960diagnosticLocationOpt ??= (conversionOpt ?? conversionOperand).Syntax.GetLocation(); 8501Location operandLocation = conversionOperand.Syntax.GetLocation(); 8514if (!isLiftedConversion && CheckDisallowedNullAssignment(operandType, parameterAnnotations, conversionOperand.Syntax.Location)) 8589conversionOpt.Syntax.SpanStart != convertedNode.Syntax.SpanStart) 8785ReportNullabilityMismatchWithTargetDelegate(group.Syntax.Location, delegateType, delegateInvokeMethod, method, node.IsExtensionMethod); 8857ReportNullabilityMismatchWithTargetDelegate(arg.Syntax.Location, delegateType, delegateInvokeMethod, argInvokeMethod, invokedAsExtensionMethod: false); 8913var syntax = group.Syntax; 8918if (method.IsGenericMethod && HasImplicitTypeArguments(group.Syntax)) 9044left = new BoundPropertyAccess(fieldAccess.Syntax, fieldAccess.ReceiverOpt, autoProperty, LookupResultKind.Viable, autoProperty.Type, fieldAccess.HasErrors); 9047left = new BoundEventAccess(fieldAccess.Syntax, fieldAccess.ReceiverOpt, @event, isUsableAsField: true, LookupResultKind.Viable, @event.Type, fieldAccess.HasErrors); 9083CheckDisallowedNullAssignment(rightState, leftAnnotations, right.Syntax.Location); 9300placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 9307CheckMethodConstraints(invocation.Syntax, deconstructMethod); 9421CheckDisallowedNullAssignment(valueType, leftAnnotations, right.Syntax.Location); 9522return fields.SelectAsArray((f, e) => (BoundExpression)new BoundFieldAccess(e.Syntax, e, f, constantValueOpt: null), expr); 9691CheckDisallowedNullAssignment(resultType, leftAnnotations, node.Syntax.Location); 9736ReportNullabilityMismatchInArgument(argument.Syntax, argType, parameter, paramType.Type, forOutput: false); 9743argument.Syntax, argumentType, parameterType, 10101ReportDiagnostic(ErrorCode.WRN_NullReferenceReceiver, expr.Syntax.GetLocation()); 10155var variableLocation = node.Syntax switch 10159_ => throw ExceptionUtilities.UnexpectedValue(node.Syntax) 10189var foreachSyntax = (ForEachStatementSyntax)node.Syntax; 10888if (!ReportPossibleNullReceiverIfNeeded(resultTypeSymbol, resultType.State, checkNullableValueType, receiverOpt.Syntax, out reportedDiagnostic)) 11065ReportDiagnostic(ErrorCode.WRN_ThrowPossibleNull, expr.Syntax);

69Debug.Assert(_analyzedNullabilityMap.ContainsKey(expression), $"Did not find {expression} `{expression.Syntax}` in the map.");

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

262var labelStateMap = LearnFromDecisionDag(node.Syntax, node.ReachabilityDecisionDag, node.Expression, expressionState, stateWhenNotNullOpt: null); 414var output = new BoundDagTemp(e.Syntax, parameterType.Type, e, i); 423var output = new BoundDagTemp(e.Syntax, e.Type, e); 452var output = new BoundDagTemp(e.Syntax, type.Type, e); 496var output = new BoundDagTemp(e.Syntax, type.Type, e); 521var output = new BoundDagTemp(e.Syntax, type.Type, e); 533var output = new BoundDagTemp(e.Syntax, type.Type, e); 800var output = new BoundDagTemp(e.Syntax, type.Type, e, index: index); 852var labelStateMap = LearnFromDecisionDag(node.Syntax, node.ReachabilityDecisionDag, node.Expression, expressionState, stateWhenNotNullOpt: null); 867((SwitchExpressionSyntax)node.Syntax).SwitchKeyword.GetLocation(), 1015var labelStateMap = LearnFromDecisionDag(node.Syntax, node.ReachabilityDecisionDag, node.Expression, expressionState, hasStateWhenNotNull ? conditionalStateWhenNotNull : null);

171var receiverSyntax = receiver.Syntax; 237if (!IsInside && node.Syntax != null && node.Syntax.Span.Contains(RegionSpan))

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

316var result = new BoundFieldEqualsValue(this.Syntax, field, locals, value, this.HasErrors); 346var result = new BoundPropertyEqualsValue(this.Syntax, property, locals, value, this.HasErrors); 376var result = new BoundParameterEqualsValue(this.Syntax, parameter, locals, value, this.HasErrors); 404var result = new BoundGlobalStatementInitializer(this.Syntax, statement, this.HasErrors); 477var result = new BoundValuePlaceholder(this.Syntax, type, this.HasErrors); 507var result = new BoundCapturedReceiverPlaceholder(this.Syntax, receiver, localScopeDepth, type, this.HasErrors); 548var result = new BoundDeconstructValuePlaceholder(this.Syntax, variableSymbol, isDiscardExpression, type, this.HasErrors); 583var result = new BoundTupleOperandPlaceholder(this.Syntax, type, this.HasErrors); 612var result = new BoundAwaitableValuePlaceholder(this.Syntax, type, this.HasErrors); 647var result = new BoundDisposableValuePlaceholder(this.Syntax, type, this.HasErrors); 685var result = new BoundObjectOrCollectionValuePlaceholder(this.Syntax, isNewInstance, type, this.HasErrors); 720var result = new BoundImplicitIndexerValuePlaceholder(this.Syntax, type, this.HasErrors); 758var result = new BoundImplicitIndexerReceiverPlaceholder(this.Syntax, isEquivalentToThisReference, type, this.HasErrors); 793var result = new BoundListPatternReceiverPlaceholder(this.Syntax, type, this.HasErrors); 828var result = new BoundListPatternIndexPlaceholder(this.Syntax, type, this.HasErrors); 863var result = new BoundSlicePatternReceiverPlaceholder(this.Syntax, type, this.HasErrors); 898var result = new BoundSlicePatternRangePlaceholder(this.Syntax, type, this.HasErrors); 929var result = new BoundDup(this.Syntax, refKind, type, this.HasErrors); 957var result = new BoundPassByCopy(this.Syntax, expression, type, this.HasErrors); 990var result = new BoundBadExpression(this.Syntax, resultKind, symbols, childBoundNodes, type, this.HasErrors); 1018var result = new BoundBadStatement(this.Syntax, childBoundNodes, this.HasErrors); 1046var result = new BoundExtractedFinallyBlock(this.Syntax, finallyBlock, this.HasErrors); 1081var result = new BoundTypeExpression(this.Syntax, aliasOpt, boundContainingTypeOpt, boundDimensionsOpt, typeWithAnnotations, type, this.HasErrors); 1119var result = new BoundTypeOrValueExpression(this.Syntax, data, type, this.HasErrors); 1160var result = new BoundNamespaceExpression(this.Syntax, namespaceSymbol, aliasOpt, this.HasErrors); 1202var result = new BoundUnaryOperator(this.Syntax, operatorKind, operand, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1250var result = new BoundIncrementOperator(this.Syntax, operatorKind, operand, methodOpt, constrainedToTypeOpt, operandPlaceholder, operandConversion, resultPlaceholder, resultConversion, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1282var result = new BoundAddressOfOperator(this.Syntax, operand, isManaged, type, this.HasErrors); 1311var result = new BoundUnconvertedAddressOfOperator(this.Syntax, operand, this.HasErrors); 1354var result = new BoundFunctionPointerLoad(this.Syntax, targetMethod, constrainedToTypeOpt, type, this.HasErrors); 1386var result = new BoundPointerIndirectionOperator(this.Syntax, operand, refersToLocation, type, this.HasErrors); 1423var result = new BoundPointerElementAccess(this.Syntax, expression, index, @checked, refersToLocation, type, this.HasErrors); 1460var result = new BoundFunctionPointerInvocation(this.Syntax, invokedExpression, arguments, argumentRefKindsOpt, resultKind, type, this.HasErrors); 1492var result = new BoundRefTypeOperator(this.Syntax, operand, getTypeFromHandle, type, this.HasErrors); 1522var result = new BoundMakeRefOperator(this.Syntax, operand, type, this.HasErrors); 1554var result = new BoundRefValueOperator(this.Syntax, nullableAnnotation, operand, type, this.HasErrors); 1586var result = new BoundFromEndIndexExpression(this.Syntax, operand, methodOpt, type, this.HasErrors); 1619var result = new BoundRangeExpression(this.Syntax, leftOperandOpt, rightOperandOpt, methodOpt, type, this.HasErrors); 1672var result = new BoundBinaryOperator(this.Syntax, operatorKind, data, resultKind, left, right, type, this.HasErrors); 1710var result = new BoundTupleBinaryOperator(this.Syntax, left, right, operatorKind, operators, type, this.HasErrors); 1755var result = new BoundUserDefinedConditionalLogicalOperator(this.Syntax, operatorKind, logicalOperator, trueOperator, falseOperator, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, left, right, type, this.HasErrors); 1802var result = new BoundCompoundAssignmentOperator(this.Syntax, @operator, left, right, leftPlaceholder, leftConversion, finalPlaceholder, finalConversion, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors); 1836var result = new BoundAssignmentOperator(this.Syntax, left, right, isRef, type, this.HasErrors); 1871var result = new BoundDeconstructionAssignmentOperator(this.Syntax, left, right, isUsed, type, this.HasErrors); 1912var result = new BoundNullCoalescingOperator(this.Syntax, leftOperand, rightOperand, leftPlaceholder, leftConversion, operatorResultKind, @checked, type, this.HasErrors); 1943var result = new BoundNullCoalescingAssignmentOperator(this.Syntax, leftOperand, rightOperand, type, this.HasErrors); 1982var result = new BoundUnconvertedConditionalOperator(this.Syntax, condition, consequence, alternative, constantValueOpt, noCommonTypeError, this.HasErrors); 2026var result = new BoundConditionalOperator(this.Syntax, isRef, condition, consequence, alternative, constantValueOpt, naturalTypeOpt, wasTargetTyped, type, this.HasErrors); 2059var result = new BoundArrayAccess(this.Syntax, expression, indices, type, this.HasErrors); 2089var result = new BoundArrayLength(this.Syntax, expression, type, this.HasErrors); 2122var result = new BoundAwaitableInfo(this.Syntax, awaitableInstancePlaceholder, isDynamic, getAwaiter, isCompleted, getResult, this.HasErrors); 2155var result = new BoundAwaitExpression(this.Syntax, expression, awaitableInfo, type, this.HasErrors); 2208var result = new BoundTypeOfOperator(this.Syntax, sourceType, getTypeFromHandle, type, this.HasErrors); 2242var result = new BoundBlockInstrumentation(this.Syntax, local, prologue, epilogue, this.HasErrors); 2282var result = new BoundMethodDefIndex(this.Syntax, method, type, this.HasErrors); 2325var result = new BoundLocalId(this.Syntax, local, hoistedField, type, this.HasErrors); 2368var result = new BoundParameterId(this.Syntax, parameter, hoistedField, type, this.HasErrors); 2403var result = new BoundStateMachineInstanceId(this.Syntax, type, this.HasErrors); 2438var result = new BoundMaximumMethodDefIndex(this.Syntax, type, this.HasErrors); 2476var result = new BoundInstrumentationPayloadRoot(this.Syntax, analysisKind, type, this.HasErrors); 2511var result = new BoundModuleVersionId(this.Syntax, type, this.HasErrors); 2546var result = new BoundModuleVersionIdString(this.Syntax, type, this.HasErrors); 2586var result = new BoundSourceDocumentIndex(this.Syntax, document, type, this.HasErrors); 2629var result = new BoundMethodInfo(this.Syntax, method, getMethodFromHandle, type, this.HasErrors); 2672var result = new BoundFieldInfo(this.Syntax, field, getFieldFromHandle, type, this.HasErrors); 2726var result = new BoundDefaultExpression(this.Syntax, targetType, constantValueOpt, type, this.HasErrors); 2761var result = new BoundIsOperator(this.Syntax, operand, targetType, conversionKind, type, this.HasErrors); 2798var result = new BoundAsOperator(this.Syntax, operand, targetType, operandPlaceholder, operandConversion, type, this.HasErrors); 2830var result = new BoundSizeOfOperator(this.Syntax, sourceType, constantValueOpt, type, this.HasErrors); 2874var result = new BoundConversion(this.Syntax, operand, conversion, isBaseConversion, @checked, explicitCastInCode, constantValueOpt, conversionGroupOpt, originalUserDefinedConversionsOpt, type, this.HasErrors); 2907var result = new BoundReadOnlySpanFromArray(this.Syntax, operand, conversionMethod, type, this.HasErrors); 2942var result = new BoundArgList(this.Syntax, type, this.HasErrors); 2973var result = new BoundArgListOperator(this.Syntax, arguments, argumentRefKindsOpt, type, this.HasErrors); 3012var result = new BoundFixedLocalCollectionInitializer(this.Syntax, elementPointerType, elementPointerPlaceholder, elementPointerConversion, expression, getPinnableOpt, type, this.HasErrors); 3051var result = new BoundSequencePoint(this.Syntax, statementOpt, this.HasErrors); 3078var result = new BoundSequencePointWithSpan(this.Syntax, statementOpt, span, this.HasErrors); 3115var result = new BoundSavePreviousSequencePoint(this.Syntax, identifier, this.HasErrors); 3152var result = new BoundRestorePreviousSequencePoint(this.Syntax, identifier, this.HasErrors); 3183var result = new BoundStepThroughSequencePoint(this.Syntax, span, this.HasErrors); 3219var result = new BoundBlock(this.Syntax, locals, localFunctions, hasUnsafeModifier, instrumentation, statements, this.HasErrors); 3248var result = new BoundScope(this.Syntax, locals, statements, this.HasErrors); 3279var result = new BoundStateMachineScope(this.Syntax, fields, statement, this.HasErrors); 3315var result = new BoundLocalDeclaration(this.Syntax, localSymbol, declaredTypeOpt, initializerOpt, argumentsOpt, inferredType, this.HasErrors); 3355var result = new BoundMultipleLocalDeclarations(this.Syntax, localDeclarations, this.HasErrors); 3385var result = new BoundUsingLocalDeclarations(this.Syntax, patternDisposeInfoOpt, awaitOpt, localDeclarations, this.HasErrors); 3417var result = new BoundLocalFunctionStatement(this.Syntax, symbol, blockBody, expressionBody, this.HasErrors); 3448var result = new BoundNoOpStatement(this.Syntax, flavor, this.HasErrors); 3477var result = new BoundReturnStatement(this.Syntax, refKind, expressionOpt, @checked, this.HasErrors); 3505var result = new BoundYieldReturnStatement(this.Syntax, expression, this.HasErrors); 3547var result = new BoundThrowStatement(this.Syntax, expressionOpt, this.HasErrors); 3575var result = new BoundExpressionStatement(this.Syntax, expression, this.HasErrors); 3612var result = new BoundBreakStatement(this.Syntax, label, this.HasErrors); 3649var result = new BoundContinueStatement(this.Syntax, label, this.HasErrors); 3694var result = new BoundSwitchStatement(this.Syntax, expression, innerLocals, innerLocalFunctions, switchSections, reachabilityDecisionDag, defaultLabel, breakLabel, this.HasErrors); 3730var result = new BoundSwitchDispatch(this.Syntax, expression, cases, defaultLabel, lengthBasedStringSwitchDataOpt, this.HasErrors); 3763var result = new BoundIfStatement(this.Syntax, condition, consequence, alternativeOpt, this.HasErrors); 3843var result = new BoundDoStatement(this.Syntax, locals, condition, body, breakLabel, continueLabel, this.HasErrors); 3873var result = new BoundWhileStatement(this.Syntax, locals, condition, body, breakLabel, continueLabel, this.HasErrors); 3915var result = new BoundForStatement(this.Syntax, outerLocals, initializer, innerLocals, condition, increment, body, breakLabel, continueLabel, this.HasErrors); 3966var result = new BoundForEachStatement(this.Syntax, enumeratorInfoOpt, elementPlaceholder, elementConversion, iterationVariableType, iterationVariables, iterationErrorExpressionOpt, expression, deconstructionOpt, awaitOpt, body, breakLabel, continueLabel, this.HasErrors); 3997var result = new BoundForEachDeconstructStep(this.Syntax, deconstructionAssignment, targetPlaceholder, this.HasErrors); 4036var result = new BoundUsingStatement(this.Syntax, locals, declarationsOpt, expressionOpt, body, awaitOpt, patternDisposeInfoOpt, this.HasErrors); 4070var result = new BoundFixedStatement(this.Syntax, locals, declarations, body, this.HasErrors); 4101var result = new BoundLockStatement(this.Syntax, argument, body, this.HasErrors); 4138var result = new BoundTryStatement(this.Syntax, tryBlock, catchBlocks, finallyBlockOpt, finallyLabelOpt, preferFaultHandler, this.HasErrors); 4179var result = new BoundCatchBlock(this.Syntax, locals, exceptionSourceOpt, exceptionTypeOpt, exceptionFilterPrologueOpt, exceptionFilterOpt, body, isSynthesizedAsyncCatchAll, this.HasErrors); 4210var result = new BoundLiteral(this.Syntax, constantValueOpt, type, this.HasErrors); 4250var result = new BoundUtf8String(this.Syntax, value, type, this.HasErrors); 4285var result = new BoundThisReference(this.Syntax, type, this.HasErrors); 4320var result = new BoundPreviousSubmissionReference(this.Syntax, type, this.HasErrors); 4355var result = new BoundHostObjectMemberReference(this.Syntax, type, this.HasErrors); 4384var result = new BoundBaseReference(this.Syntax, type, this.HasErrors); 4433var result = new BoundLocal(this.Syntax, localSymbol, declarationKind, constantValueOpt, isNullableUnknown, type, this.HasErrors); 4478var result = new BoundPseudoVariable(this.Syntax, localSymbol, emitExpressions, type, this.HasErrors); 4511var result = new BoundRangeVariable(this.Syntax, rangeVariableSymbol, value, type, this.HasErrors); 4551var result = new BoundParameter(this.Syntax, parameterSymbol, type, this.HasErrors); 4588var result = new BoundLabelStatement(this.Syntax, label, this.HasErrors); 4620var result = new BoundGotoStatement(this.Syntax, label, caseExpressionOpt, labelExpressionOpt, this.HasErrors); 4651var result = new BoundLabeledStatement(this.Syntax, label, body, this.HasErrors); 4688var result = new BoundLabel(this.Syntax, label, type, this.HasErrors); 4725var result = new BoundStatementList(this.Syntax, statements, this.HasErrors); 4758var result = new BoundConditionalGoto(this.Syntax, condition, jumpIfTrue, label, this.HasErrors); 4821var result = new BoundSwitchExpressionArm(this.Syntax, locals, pattern, whenClause, value, label, this.HasErrors); 4849var result = new BoundUnconvertedSwitchExpression(this.Syntax, expression, switchArms, reachabilityDecisionDag, defaultLabel, reportedNotExhaustive, type, this.HasErrors); 4883var result = new BoundConvertedSwitchExpression(this.Syntax, naturalTypeOpt, wasTargetTyped, expression, switchArms, reachabilityDecisionDag, defaultLabel, reportedNotExhaustive, type, this.HasErrors); 4911var result = new BoundDecisionDag(this.Syntax, rootNode, this.HasErrors); 4956var result = new BoundEvaluationDecisionDagNode(this.Syntax, evaluation, next, this.HasErrors); 4990var result = new BoundTestDecisionDagNode(this.Syntax, test, whenTrue, whenFalse, this.HasErrors); 5025var result = new BoundWhenDecisionDagNode(this.Syntax, bindings, whenExpression, whenTrue, whenFalse, this.HasErrors); 5062var result = new BoundLeafDecisionDagNode(this.Syntax, label, this.HasErrors); 5108var result = new BoundDagTemp(this.Syntax, type, source, index, this.HasErrors); 5137var result = new BoundDagTypeTest(this.Syntax, type, input, this.HasErrors); 5165var result = new BoundDagNonNullTest(this.Syntax, isExplicitTest, input, this.HasErrors); 5191var result = new BoundDagExplicitNullTest(this.Syntax, input, this.HasErrors); 5220var result = new BoundDagValueTest(this.Syntax, value, input, this.HasErrors); 5251var result = new BoundDagRelationalTest(this.Syntax, operatorKind, value, input, this.HasErrors); 5292var result = new BoundDagDeconstructEvaluation(this.Syntax, deconstructMethod, input, this.HasErrors); 5321var result = new BoundDagTypeEvaluation(this.Syntax, type, input, this.HasErrors); 5350var result = new BoundDagFieldEvaluation(this.Syntax, field, input, this.HasErrors); 5381var result = new BoundDagPropertyEvaluation(this.Syntax, property, isLengthOrCount, input, this.HasErrors); 5412var result = new BoundDagIndexEvaluation(this.Syntax, property, index, input, this.HasErrors); 5459var result = new BoundDagIndexerEvaluation(this.Syntax, indexerType, lengthTemp, index, indexerAccess, receiverPlaceholder, argumentPlaceholder, input, this.HasErrors); 5508var result = new BoundDagSliceEvaluation(this.Syntax, sliceType, lengthTemp, startIndex, endIndex, indexerAccess, receiverPlaceholder, argumentPlaceholder, input, this.HasErrors); 5537var result = new BoundDagAssignmentEvaluation(this.Syntax, target, input, this.HasErrors); 5569var result = new BoundSwitchSection(this.Syntax, locals, switchLabels, statements, this.HasErrors); 5602var result = new BoundSwitchLabel(this.Syntax, label, pattern, whenClause, this.HasErrors); 5644var result = new BoundSequencePointExpression(this.Syntax, expression, type, this.HasErrors); 5680var result = new BoundSequence(this.Syntax, locals, sideEffects, value, type, this.HasErrors); 5716var result = new BoundSpillSequence(this.Syntax, locals, sideEffects, value, type, this.HasErrors); 5755var result = new BoundDynamicMemberAccess(this.Syntax, receiver, typeArgumentsOpt, name, invoked, indexed, type, this.HasErrors); 5808var result = new BoundDynamicInvocation(this.Syntax, argumentNamesOpt, argumentRefKindsOpt, applicableMethods, expression, arguments, type, this.HasErrors); 5841var result = new BoundConditionalAccess(this.Syntax, receiver, accessExpression, type, this.HasErrors); 5882var result = new BoundLoweredConditionalAccess(this.Syntax, receiver, hasValueMethodOpt, whenNotNull, whenNullOpt, id, forceCopyOfNullableValueType, type, this.HasErrors); 5920var result = new BoundConditionalReceiver(this.Syntax, id, type, this.HasErrors); 5953var result = new BoundComplexConditionalReceiver(this.Syntax, valueTypeReceiver, referenceTypeReceiver, type, this.HasErrors); 5994var result = new BoundMethodGroup(this.Syntax, typeArgumentsOpt, name, methods, lookupSymbolOpt, lookupError, flags, functionType, receiverOpt, resultKind, this.HasErrors); 6022var result = new BoundPropertyGroup(this.Syntax, properties, receiverOpt, resultKind, this.HasErrors); 6075var result = new BoundCall(this.Syntax, receiverOpt, method, arguments, argumentNamesOpt, argumentRefKindsOpt, isDelegateCall, expanded, invokedAsExtensionMethod, argsToParamsOpt, defaultArguments, resultKind, originalMethodsOpt, type, this.HasErrors); 6114var result = new BoundEventAssignmentOperator(this.Syntax, @event, isAddition, isDynamic, receiverOpt, argument, type, this.HasErrors); 6159var result = new BoundAttribute(this.Syntax, constructor, constructorArguments, constructorArgumentNamesOpt, constructorArgumentsToParamsOpt, constructorExpanded, constructorDefaultArguments, namedArguments, resultKind, type, this.HasErrors); 6197var result = new BoundUnconvertedObjectCreationExpression(this.Syntax, arguments, argumentNamesOpt, argumentRefKindsOpt, initializerOpt, binder, this.HasErrors); 6269var result = new BoundObjectCreationExpression(this.Syntax, constructor, constructorsGroup, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, constantValueOpt, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 6314var result = new BoundTupleLiteral(this.Syntax, arguments, argumentNamesOpt, inferredNamesOpt, type, this.HasErrors); 6344var result = new BoundConvertedTupleLiteral(this.Syntax, sourceTuple, wasTargetTyped, arguments, argumentNamesOpt, inferredNamesOpt, type, this.HasErrors); 6387var result = new BoundDynamicObjectCreationExpression(this.Syntax, name, arguments, argumentNamesOpt, argumentRefKindsOpt, initializerExpressionOpt, applicableMethods, wasTargetTyped, type, this.HasErrors); 6419var result = new BoundNoPiaObjectCreationExpression(this.Syntax, guidString, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 6466var result = new BoundObjectInitializerExpression(this.Syntax, placeholder, initializers, type, this.HasErrors); 6513var result = new BoundObjectInitializerMember(this.Syntax, memberSymbol, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, resultKind, receiverType, type, this.HasErrors); 6558var result = new BoundDynamicObjectInitializerMember(this.Syntax, memberName, receiverType, type, this.HasErrors); 6586var result = new BoundCollectionInitializerExpression(this.Syntax, placeholder, initializers, type, this.HasErrors); 6631var result = new BoundCollectionElementInitializer(this.Syntax, addMethod, arguments, implicitReceiverOpt, expanded, argsToParamsOpt, defaultArguments, invokedAsExtensionMethod, resultKind, type, this.HasErrors); 6663var result = new BoundDynamicCollectionElementInitializer(this.Syntax, applicableMethods, expression, arguments, type, this.HasErrors); 6698var result = new BoundImplicitReceiver(this.Syntax, type, this.HasErrors); 6734var result = new BoundAnonymousObjectCreationExpression(this.Syntax, constructor, arguments, declarations, type, this.HasErrors); 6774var result = new BoundAnonymousPropertyDeclaration(this.Syntax, property, type, this.HasErrors); 6804var result = new BoundNewT(this.Syntax, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors); 6840var result = new BoundDelegateCreationExpression(this.Syntax, argument, methodOpt, isExtensionMethod, wasTargetTyped, type, this.HasErrors); 6872var result = new BoundArrayCreation(this.Syntax, bounds, initializerOpt, type, this.HasErrors); 6903var result = new BoundArrayInitialization(this.Syntax, isInferred, initializers, this.HasErrors); 6949var result = new BoundStackAllocArrayCreation(this.Syntax, elementType, count, initializerOpt, type, this.HasErrors); 6978var result = new BoundConvertedStackAllocExpression(this.Syntax, elementType, count, initializerOpt, type, this.HasErrors); 7018var result = new BoundFieldAccess(this.Syntax, receiverOpt, fieldSymbol, constantValueOpt, resultKind, isByValue, isDeclaration, type, this.HasErrors); 7058var result = new BoundHoistedFieldAccess(this.Syntax, fieldSymbol, type, this.HasErrors); 7092var result = new BoundPropertyAccess(this.Syntax, receiverOpt, propertySymbol, resultKind, type, this.HasErrors); 7128var result = new BoundEventAccess(this.Syntax, receiverOpt, eventSymbol, isUsableAsField, resultKind, type, this.HasErrors); 7175var result = new BoundIndexerAccess(this.Syntax, receiverOpt, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, originalIndexersOpt, type, this.HasErrors); 7224var result = new BoundImplicitIndexerAccess(this.Syntax, receiver, argument, lengthOrCountAccess, receiverPlaceholder, indexerOrSliceAccess, argumentPlaceholders, type, this.HasErrors); 7264var result = new BoundDynamicIndexerAccess(this.Syntax, receiver, arguments, argumentNamesOpt, argumentRefKindsOpt, applicableIndexers, type, this.HasErrors); 7304var result = new BoundLambda(this.Syntax, unboundLambda, symbol, body, diagnostics, binder, type, this.HasErrors); 7348var result = new UnboundLambda(this.Syntax, data, functionType, withDependencies, this.HasErrors); 7389var result = new BoundQueryClause(this.Syntax, value, definedSymbol, operation, cast, binder, unoptimizedForm, type, this.HasErrors); 7415var result = new BoundTypeOrInstanceInitializers(this.Syntax, statements, this.HasErrors); 7448var result = new BoundNameOfOperator(this.Syntax, argument, constantValueOpt, type, this.HasErrors); 7490var result = new BoundUnconvertedInterpolatedString(this.Syntax, parts, constantValueOpt, type, this.HasErrors); 7518var result = new BoundInterpolatedString(this.Syntax, interpolationData, parts, constantValueOpt, type, this.HasErrors); 7546var result = new BoundInterpolatedStringHandlerPlaceholder(this.Syntax, type, this.HasErrors); 7584var result = new BoundInterpolatedStringArgumentPlaceholder(this.Syntax, argumentIndex, type, this.HasErrors); 7619var result = new BoundStringInsert(this.Syntax, value, alignment, format, isInterpolatedStringHandlerAppendCall, this.HasErrors); 7661var result = new BoundIsPatternExpression(this.Syntax, expression, pattern, isNegated, reachabilityDecisionDag, whenTrueLabel, whenFalseLabel, type, this.HasErrors); 7722var result = new BoundConstantPattern(this.Syntax, value, constantValue, inputType, narrowedType, this.HasErrors); 7758var result = new BoundDiscardPattern(this.Syntax, inputType, narrowedType, this.HasErrors); 7807var result = new BoundDeclarationPattern(this.Syntax, declaredType, isVar, variable, variableAccess, inputType, narrowedType, this.HasErrors); 7844var result = new BoundRecursivePattern(this.Syntax, declaredType, deconstructMethod, deconstruction, properties, isExplicitNotNullTest, variable, variableAccess, inputType, narrowedType, this.HasErrors); 7888var result = new BoundListPattern(this.Syntax, subpatterns, hasSlice, lengthAccess, indexerAccess, receiverPlaceholder, argumentPlaceholder, variable, variableAccess, inputType, narrowedType, this.HasErrors); 7927var result = new BoundSlicePattern(this.Syntax, pattern, indexerAccess, receiverPlaceholder, argumentPlaceholder, inputType, narrowedType, this.HasErrors); 7963var result = new BoundITuplePattern(this.Syntax, getLengthMethod, getItemMethod, subpatterns, inputType, narrowedType, this.HasErrors); 8005var result = new BoundPositionalSubpattern(this.Syntax, symbol, pattern, this.HasErrors); 8035var result = new BoundPropertySubpattern(this.Syntax, member, isLengthOrCount, pattern, this.HasErrors); 8067var result = new BoundPropertySubpatternMember(this.Syntax, receiver, symbol, type, this.HasErrors); 8099var result = new BoundTypePattern(this.Syntax, declaredType, isExplicitNotNullTest, inputType, narrowedType, this.HasErrors); 8134var result = new BoundBinaryPattern(this.Syntax, disjunction, left, right, inputType, narrowedType, this.HasErrors); 8164var result = new BoundNegatedPattern(this.Syntax, negated, inputType, narrowedType, this.HasErrors); 8199var result = new BoundRelationalPattern(this.Syntax, relation, value, constantValue, inputType, narrowedType, this.HasErrors); 8234var result = new BoundDiscardExpression(this.Syntax, nullableAnnotation, isInferred, type, this.HasErrors); 8262var result = new BoundThrowExpression(this.Syntax, expression, type, this.HasErrors); 8305var result = new OutVariablePendingInference(this.Syntax, variableSymbol, receiverOpt, this.HasErrors); 8331var result = new DeconstructionVariablePendingInference(this.Syntax, variableSymbol, receiverOpt, this.HasErrors); 8366var result = new OutDeconstructVarPendingInference(this.Syntax, variableSymbol, isDiscardExpression, this.HasErrors); 8402var result = new BoundNonConstructorMethodBody(this.Syntax, blockBody, expressionBody, this.HasErrors); 8432var result = new BoundConstructorMethodBody(this.Syntax, locals, initializer, blockBody, expressionBody, this.HasErrors); 8463var result = new BoundExpressionWithNullability(this.Syntax, expression, nullableAnnotation, type, this.HasErrors); 8498var result = new BoundWithExpression(this.Syntax, receiver, cloneMethod, initializerExpression, type, this.HasErrors);

126var factory = new SyntheticBoundNodeFactory(containingSymbol, statement.Syntax, compilationState, diagnostics); 135var tryStatementSyntax = node.Syntax; 517Debug.Assert(node.Syntax.IsKind(SyntaxKind.CatchClause)); 518var tryStatementSyntax = (TryStatementSyntax)node.Syntax.Parent; 706var newFrame = new AwaitFinallyFrame(_currentAwaitFinallyFrame, _analysis.Labels(statement), statement.Syntax);

265AddResumableState(_iteratorStateAllocator, node.Syntax, out var stateNumber, out GeneratedLabelSymbol resumeLabel);

166var block = body.Syntax as BlockSyntax; 196body.Syntax, 368Debug.Assert(node.Syntax.IsKind(SyntaxKind.AwaitExpression) || node.WasCompilerGenerated); 370var 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);

109public override string ToString() => BoundNode.Syntax.GetText().ToString(); 445AddIfCaptured(node.Method.OriginalDefinition, node.Syntax); 456AddIfCaptured(method, node.Syntax); 464AddIfCaptured(node.ParameterSymbol, node.Syntax); 470AddIfCaptured(node.LocalSymbol, node.Syntax); 476AddIfCaptured(_topLevelMethod.ThisParameter, node.Syntax); 485AddIfCaptured(thisParam, node.Syntax); 563var function = new NestedFunction(functionSymbol, body.Syntax.GetReference());

296body = new BoundBlock(body.Syntax, _addedLocals.ToImmutableAndFree(), _addedStatements.ToImmutableAndFree()) { WasCompilerGenerated = true }; 362var syntax = scopeBoundNode.Syntax; 634result.Add(new BoundExpressionStatement(node.Syntax, (BoundExpression)(BoundNode)node)); 657SyntaxNode syntax = node.Syntax; 809return new BoundParameter(node.Syntax, replacementParameter, node.HasErrors); 829FramePointer(node.Syntax, (NamedTypeSymbol)node.Type)); 836: FramePointer(node.Syntax, _topLevelMethod.ContainingType); // technically, not the correct static type 1065node.Syntax, 1106syntax: node.Syntax, 1192return new BoundStatementList(node.Syntax, statements); 1231rewrittenExceptionSource.Syntax, 1244prologueBuilder.Add(new BoundExpressionStatement(p.Syntax, p) { WasCompilerGenerated = true }); 1251rewrittenFilterPrologue = new BoundStatementList(rewrittenFilter.Syntax, prologueBuilder.ToImmutableAndFree()); 1304return new BoundBlock(node.Syntax, newLocals.ToImmutableAndFree(), newStatements.ToImmutableAndFree(), node.HasErrors); 1328node.Syntax, 1336node.Syntax, 1355node.Syntax, 1386syntax: conversion.Syntax, 1420return new BoundNoOpStatement(node.Syntax, NoOpStatementFlavor.Default); 1623RemapLambdaOrLocalFunction(node.Syntax, node.Symbol, default(ImmutableArray<TypeWithAnnotations>), closureKind, ref referencedMethod, out receiver, out constructedFrame); 1634node.Syntax, 1652InLoopOrLambda(node.Syntax, lambdaScope.Syntax); 1657var F = new SyntheticBoundNodeFactory(_currentMethod, node.Syntax, CompilationState, Diagnostics);

118var r = new ExpressionLambdaRewriter(compilationState, typeMap, node.Syntax, recursionDepth, diagnostics); 122diagnostics.Add(ErrorCode.ERR_MissingPredefinedMember, node.Syntax.Location, r.ExpressionType, "Lambda"); 175_bound.Syntax = node.Syntax; 353return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 384return new BoundBadExpression(node.Syntax, 0, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 1000return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1007return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1039return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type);

60_diagnostics.Add(code, node.Syntax.Location, args); 267Binder.ReportDiagnosticsIfObsolete(_diagnostics, node.EventSymbol.AssociatedField, node.Syntax, hasBaseReceiver, _containingSymbol, _containingSymbol.ContainingType, BinderFlags.None); 281Binder.ReportDiagnosticsIfObsolete(_diagnostics, node.Event, ((AssignmentExpressionSyntax)node.Syntax).Left, hasBaseReceiver, _containingSymbol, _containingSymbol.ContainingType, BinderFlags.None); 548switch (node.Syntax.Kind()) 552var lambdaSyntax = (ParenthesizedLambdaExpressionSyntax)node.Syntax; 570var 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.Kind()) 65var decl = (ConstructorDeclarationSyntax)original.Syntax; 69var init = (ConstructorInitializerSyntax)original.Syntax; 81SyntaxNode syntax = original.Syntax; 131if (original.WasCompilerGenerated && original.Syntax.Kind() == SyntaxKind.Block) 134return new BoundSequencePointWithSpan(original.Syntax, rewritten, ((BlockSyntax)original.Syntax).CloseBraceToken.Span); 152if (original.Syntax is BlockSyntax blockSyntax && !original.WasCompilerGenerated) 154prologue = new BoundSequencePointWithSpan(original.Syntax, previousPrologue, blockSyntax.OpenBraceToken.Span); 158SyntaxNode? parent = original.Syntax.Parent; 161epilogue = new BoundSequencePointWithSpan(original.Syntax, previousEpilogue, blockSyntax.CloseBraceToken.Span); 186return AddConditionSequencePoint(base.InstrumentDoStatementCondition(original, rewrittenCondition, factory), original.Syntax, factory); 193return AddConditionSequencePoint(base.InstrumentWhileStatementCondition(original, rewrittenCondition, factory), original.Syntax, factory); 198var doSyntax = (DoStatementSyntax)original.Syntax; 208WhileStatementSyntax whileSyntax = (WhileStatementSyntax)original.Syntax; 226var forEachSyntax = (CommonForEachStatementSyntax)original.Syntax; 233var forEachSyntax = (ForEachVariableStatementSyntax)original.Syntax; 247var forEachSyntax = (CommonForEachStatementSyntax)original.Syntax; 269switch (original.Syntax.Kind()) 273var forEachSyntax = (ForEachStatementSyntax)original.Syntax; 279var forEachSyntax = (ForEachVariableStatementSyntax)original.Syntax; 284throw ExceptionUtilities.UnexpectedValue(original.Syntax.Kind()); 286return new BoundSequencePointWithSpan(original.Syntax, 294return BoundSequencePoint.Create(original.Condition?.Syntax, 300var syntax = (CommonForEachStatementSyntax)original.Syntax; 310return AddConditionSequencePoint(base.InstrumentForStatementCondition(original, rewrittenCondition, factory), original.Syntax, factory); 315var syntax = (IfStatementSyntax)original.Syntax; 329return AddConditionSequencePoint(base.InstrumentIfStatementCondition(original, rewrittenCondition, factory), original.Syntax, factory); 334var labeledSyntax = (LabeledStatementSyntax)original.Syntax; 343return AddSequencePoint(original.Syntax.Kind() == SyntaxKind.VariableDeclarator ? 344(VariableDeclaratorSyntax)original.Syntax : 345((LocalDeclarationStatementSyntax)original.Syntax).Declaration.Variables.First(), 351LockStatementSyntax lockSyntax = (LockStatementSyntax)original.Syntax; 361if (original.WasCompilerGenerated && original.ExpressionOpt == null && original.Syntax.Kind() == SyntaxKind.Block) 364return new BoundSequencePointWithSpan(original.Syntax, rewritten, ((BlockSyntax)original.Syntax).CloseBraceToken.Span); 367return new BoundSequencePoint(original.Syntax, rewritten); 372SwitchStatementSyntax switchSyntax = (SwitchStatementSyntax)original.Syntax; 386WhenClauseSyntax? whenClause = original.Syntax.FirstAncestorOrSelf<WhenClauseSyntax>(); 397return AddSequencePoint((UsingStatementSyntax)original.Syntax, 427var filterClause = ((CatchClauseSyntax)original.Syntax).Filter; 437return AddConditionSequencePoint(base.InstrumentSwitchStatementExpression(original, rewrittenExpression, factory), original.Syntax, factory); 442return new BoundSequencePointExpression(original.Syntax, base.InstrumentSwitchExpressionArmExpression(original, rewrittenExpression, factory), rewrittenExpression.Type);

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

49Debug.Assert(!original.WasCompilerGenerated || original.Syntax.Kind() == SyntaxKind.Block); 114Debug.Assert(original.Syntax.Kind() == SyntaxKind.DoStatement); 122Debug.Assert(original.Syntax.Kind() == SyntaxKind.WhileStatement); 130Debug.Assert(original.Syntax.Kind() == SyntaxKind.DoStatement); 137Debug.Assert(original.Syntax.Kind() == SyntaxKind.WhileStatement); 145Debug.Assert(original.Syntax is CommonForEachStatementSyntax); 151Debug.Assert(original.Syntax is CommonForEachStatementSyntax); 158Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForEachStatement); 165Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForEachVariableStatement); 172Debug.Assert(original.Syntax is CommonForEachStatementSyntax); 179Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForStatement); 186Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForStatement); 193Debug.Assert(original.Syntax.Kind() == SyntaxKind.IfStatement); 200Debug.Assert(original.Syntax.Kind() == SyntaxKind.IfStatement); 207Debug.Assert(original.Syntax.Kind() == SyntaxKind.LabeledStatement); 213Debug.Assert(original.Syntax.Kind() == SyntaxKind.VariableDeclarator || 214(original.Syntax.Kind() == SyntaxKind.LocalDeclarationStatement && 215((LocalDeclarationStatementSyntax)original.Syntax).Declaration.Variables.Count == 1)); 244Debug.Assert(original.Syntax.Kind() == SyntaxKind.LockStatement); 255Debug.Assert(original.Syntax.Kind() == SyntaxKind.SwitchStatement); 267Debug.Assert(original.Syntax.FirstAncestorOrSelf<WhenClauseSyntax>() != null); 274Debug.Assert(original.Syntax.Kind() == SyntaxKind.UsingStatement); 287Debug.Assert(original.Syntax.Kind() == SyntaxKind.CatchClause); 294Debug.Assert(original.Syntax.Kind() == SyntaxKind.SwitchStatement);

181var scope = new Scope(factory.SynthesizedLocal(contextType, methodBody.Syntax, kind: SynthesizedLocalKind.LocalStoreTracker)); 275_scope.Open(_factory.SynthesizedLocal(_contextType, original.Syntax, kind: SynthesizedLocalKind.LocalStoreTracker)); 396var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal, original.Syntax); 466var toStringMethod = GetWellKnownMethodSymbol(WellKnownMember.System_Object__ToString, value.Syntax); 527var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal: null, original.Syntax); 591var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal: null, invocation.Syntax);

149newBody = F.SequencePoint(body.Syntax, HandleReturn(newBody)); 336AddResumableState(node.Syntax, out StateMachineState stateNumber, out GeneratedLabelSymbol resumeLabel); 465var 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);

49_factory.Syntax = boundDelegateCreation.Syntax;

100var factory = new SyntheticBoundNodeFactory(method, statement.Syntax, compilationState, diagnostics, instrumentationState); 152return new BoundBadStatement(statement.Syntax, ImmutableArray.Create<BoundNode>(statement), hasErrors: true); 231return MakeLiteral(node.Syntax, constantValue, type); 262visited.Syntax, 280var result = new BoundFieldAccess(node.Syntax, new BoundThisReference(node.Syntax, primaryCtor.ContainingType), field, ConstantValue.NotAvailable, LookupResultKind.Viable, node.Type); 508return BadExpression(node.Syntax, node.Type, ImmutableArray.Create(node)); 586if (!TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Type__GetTypeFromHandle, out getTypeFromHandle)) 588return new BoundTypeOfOperator(node.Syntax, sourceType, null, type, hasErrors: true); 603if (!TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Type__GetTypeFromHandle, out getTypeFromHandle)) 605return new BoundRefTypeOperator(node.Syntax, operand, null, type, hasErrors: true); 691return new BoundStatementList(node.Syntax, rewrittenStatements, node.HasErrors); 740var syntax = initializer.Syntax;

475_factory.Syntax = test.Syntax; 569return new ValueDispatchNode.LeafDispatchNode(node.Syntax, label); 574return new ValueDispatchNode.LeafDispatchNode(node.Syntax, label); 584return ValueDispatchNode.RelationalDispatch.CreateBalanced(testNode.Syntax, relational.Value, relational.OperatorKind, whenTrue: whenTrue, whenFalse: whenFalse); 605return PushEqualityTestsIntoTree(value.Syntax, otherwise, cases.ToImmutableAndFree(), fac); 610return 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); 189var outputTemp = new BoundDagTemp(d.Syntax, parameter.Type, d, i - extensionExtra); 208var outputTemp = new BoundDagTemp(t.Syntax, type, t); 214_localRewriter._diagnostics.Add(t.Syntax, useSiteInfo); 220_localRewriter.TryGetNullableMethod(t.Syntax, inputType, SpecialMember.System_Nullable_T_GetValueOrDefault, out MethodSymbol getValueOrDefault)) 245var outputTemp = new BoundDagTemp(e.Syntax, type, e); 270var outputTemp = new BoundDagTemp(e.Syntax, e.IndexerType, e); 296var outputTemp = new BoundDagTemp(e.Syntax, e.SliceType, e); 328return new BoundRangeExpression(e.Syntax, makeUnloweredIndexArgument(e.StartIndex), end, 338_factory.Syntax = test.Syntax; 344return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullNotEqual : BinaryOperatorKind.NotEqual); 351return MakeNullCheck(d.Syntax, input, input.Type.IsNullableType() ? BinaryOperatorKind.NullableNullEqual : BinaryOperatorKind.Equal); 355return MakeValueTest(d.Syntax, input, d.Value); 360return MakeRelationalTest(d.Syntax, input, d.OperatorKind, d.Value); 474BoundExpression output = _tempAllocator.GetTemp(new BoundDagTemp(evaluation.Syntax, typeEvaluation1.Type, evaluation)); 490BoundExpression output = _tempAllocator.GetTemp(new BoundDagTemp(evaluation.Syntax, baseType, evaluation)); 493_localRewriter._diagnostics.Add(test.Syntax, useSiteInfo); 554loweredInput.Syntax.Kind() == SyntaxKind.TupleExpression && 619var originalInput = BoundDagTemp.ForOriginalInput(loweredInput.Syntax, loweredInput.Type); 626var fieldFetchEvaluation = new BoundDagFieldEvaluation(expr.Syntax, field, originalInput); 627var 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, node.Type, used); 121return RewriteWindowsRuntimeEventAssignmentOperator(eventAccess.Syntax, 151EmbedIfNeedTo(loweredReceiver, indexerAccess.ApplicableIndexers, indexerAccess.Syntax);

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

70var syntax = node.Syntax; 117return LowerPartsToString(data, parts, node.Syntax, node.Type); 150loweredLeft = MakeBinaryOperator(original, original.Syntax, original.OperatorKind, loweredLeft, loweredRight, original.Type, original.Method, original.ConstrainedToType, 200Debug.Assert(oldNode == null || (oldNode.Syntax == syntax)); 737_diagnostics.Add(loweredLeft.Syntax, useSiteInfo); 2055SyntaxNode rightSyntax = loweredRight.Syntax; 2134_factory.Syntax = loweredRight.Syntax;

42return new BoundBlock(node.Syntax, node.Locals.AddRange(additionalLocals), node.LocalFunctions, node.HasUnsafeModifier, instrumentation, builder.ToImmutableAndFree(), node.HasErrors); 105? new BoundBlock(node.Syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty)

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

52loweredReceiver = new BoundTypeExpression(node.Syntax, null, firstContainer); 58loweredReceiver = new BoundTypeExpression(node.Syntax, null, _factory.CurrentType); 67EmbedIfNeedTo(loweredReceiver, methodGroup.Methods, node.Syntax); 156syntax: node.Syntax, 720new BoundComplexConditionalReceiver(receiverTemp.Syntax, 1447value.Syntax, 1515argument.Syntax,

97rewrittenAssignment = new BoundSequence(node.Syntax, eventTemps.ToImmutableAndFree(), sequence.ToImmutableAndFree(), condition, condition.Type!); 108node.Syntax, 120SyntaxNode syntax = node.Syntax; 240return new BoundDynamicMemberAccess(memberAccess.Syntax, receiverTemp, memberAccess.TypeArgumentsOpt, memberAccess.Name, memberAccess.Invoked, memberAccess.Indexed, memberAccess.Type); 321SyntaxNode syntax = indexerAccess.Syntax; 530indexerAccess.Syntax, 636return MakeFieldAccess(fieldAccess.Syntax, receiverOpt, fieldAccess.FieldSymbol, fieldAccess.ConstantValueOpt, fieldAccess.ResultKind, fieldAccess.Type, fieldAccess); 723return MakeEventAccess(eventAccess.Syntax, receiverOpt, eventAccess.EventSymbol, eventAccess.ConstantValueOpt, eventAccess.ResultKind, eventAccess.Type); 756rewrittenReceiver.Syntax,

85loweredReceiver.Syntax, 152node.Syntax, 155UnsafeGetNullableMethod(node.Syntax, loweredReceiver.Type, SpecialMember.System_Nullable_T_get_HasValue) : 183result = RewriteConditionalOperator(node.Syntax, 212newtarget = 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); 72var result = MakeConversionNode(node, node.Syntax, rewrittenOperand, node.Conversion, node.Checked, node.ExplicitCastInCode, node.ConstantValueOpt, rewrittenType); 93_factory.Syntax = node.Syntax; 99BadExpression(node.Syntax, byteArray, ImmutableArray<BoundExpression>.Empty) : 100MakeUnderlyingArrayForUtf8Span(node.Syntax, byteArray, bytes, out length); 102if (!TryGetWellKnownTypeMember<MethodSymbol>(node.Syntax, WellKnownMember.System_ReadOnlySpan_T__ctor_Array_Start_Length, out MethodSymbol ctor)) 104result = BadExpression(node.Syntax, node.Type, ImmutableArray<BoundExpression>.Empty); 108result = new BoundObjectCreationExpression(node.Syntax, ctor.AsMember((NamedTypeSymbol)node.Type), utf8Bytes, _factory.Literal(0), _factory.Literal(length)); 128node.Syntax.Location, 300Debug.Assert(oldNodeOpt == null || oldNodeOpt.Syntax == syntax); 546return new BoundFunctionPointerLoad(oldNodeOpt.Syntax, symbolOpt, 560_factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax; 660return MakeConversionNode(rewrittenOperand.Syntax, rewrittenOperand, conversion, rewrittenType, @checked); 674diagnostics.Add(rewrittenOperand.Syntax, useSiteInfo); 685rewrittenOperand.Syntax.Location, 875syntax: expression.Syntax, 1171seq.Syntax, 1175conditional.Syntax, 1232MethodSymbol ctor = UnsafeGetNullableMethod(call.Syntax, resultType, SpecialMember.System_Nullable_T__ctor); 1233return new BoundObjectCreationExpression(call.Syntax, ctor, call);

254effects.assignments.Add(MakeAssignmentOperator(resultPart.Syntax, leftTarget, resultPart, leftTarget.Type, 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));

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

24var syntax = node.Syntax;

41return RewriteWindowsRuntimeEventAssignmentOperator(node.Syntax, node.Event, kind, rewrittenReceiverOpt, rewrittenArgument); 48return MakeCall(node.Syntax, rewrittenReceiverOpt, method, rewrittenArguments, node.Type); 207return MakeEventAccess(node.Syntax, rewrittenReceiver, node.EventSymbol, node.ConstantValueOpt, node.ResultKind, node.Type); 289_factory.Syntax = node.Syntax; 315module.EmbeddedTypesManagerOpt.EmbedEventIfNeedTo(node.Event.GetCciAdapter(), node.Syntax, _diagnostics.DiagnosticBag, isUsedForComAwareEventBinding: true); 323return 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>(); 414VariableDeclaratorSyntax? declarator = fixedInitializer.Syntax.FirstAncestorOrSelf<VariableDeclaratorSyntax>(); 444if (TryGetWellKnownTypeMember(fixedInitializer.Syntax, WellKnownMember.System_Runtime_CompilerServices_RuntimeHelpers__get_OffsetToStringData, out offsetMethod)) 450helperCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 505if (TryGetWellKnownTypeMember(fixedInitializer.Syntax, WellKnownMember.System_Array__get_Length, out lengthMethod)) 511lengthCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(factory.Local(pinnedTemp)), ErrorTypeSymbol.UnknownResultType);

52else if (node.AwaitOpt is null && CanRewriteForEachAsFor(node.Syntax, nodeExpressionType, out var indexerGet, out var lengthGetter)) 107var forEachSyntax = (CommonForEachStatementSyntax)node.Syntax; 523var forEachSyntax = (CommonForEachStatementSyntax)node.Syntax; 636var forEachSyntax = (CommonForEachStatementSyntax)forEachBound.Syntax; 654iterationVarDecl = new BoundExpressionStatement(assignment.Syntax, loweredAssignment); 700var forEachSyntax = (CommonForEachStatementSyntax)node.Syntax; 825var forEachSyntax = (CommonForEachStatementSyntax)node.Syntax; 1062CommonForEachStatementSyntax forEachSyntax = (CommonForEachStatementSyntax)original.Syntax;

74SyntaxNode syntax = original.Syntax; 138branchBack = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel); 212SyntaxNode syntax = node.Syntax; 238BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, node.BreakLabel);

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

17var syntax = node.Syntax;

23var syntax = (IfStatementSyntax)node.Syntax; 64builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, afterif)); 89builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, alt));

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,

62EmbedIfNeedTo(loweredReceiver, node.ApplicableIndexers, node.Syntax); 89node.Syntax,

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); 77(originalOpt.Syntax.Kind() == SyntaxKind.VariableDeclarator || 78(originalOpt.Syntax.Kind() == SyntaxKind.LocalDeclarationStatement && 79((LocalDeclarationStatementSyntax)originalOpt.Syntax).Declaration.Variables.Count == 1)))

21LockStatementSyntax lockSyntax = (LockStatementSyntax)node.Syntax; 35rewrittenArgument.Syntax, 47rewrittenArgument.Syntax, 100MakeLiteral(rewrittenArgument.Syntax, ConstantValue.False, boolType),

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

17SyntaxNode syntax = node.Syntax; 44var leftPlaceholder = new BoundValuePlaceholder(lhsRead.Syntax, lhsRead.Type); 71if (!TryGetNullableMethod(leftOperand.Syntax, 79if (!TryGetNullableMethod(leftOperand.Syntax, 103var tmp = _factory.StoreToTemp(BoundCall.Synthesized(leftOperand.Syntax, lhsRead, getValueOrDefault), 110var tmpAssignment = MakeAssignmentOperator(node.Syntax, tmp, loweredRight, node.Type, used: true, isChecked: false, isCompoundAssignment: false); 117node.Syntax, 126var lhsReadHasValue = BoundCall.Synthesized(leftOperand.Syntax, lhsRead, hasValue);

21return MakeNullCoalescingOperator(node.Syntax, rewrittenLeft, rewrittenRight, node.LeftPlaceholder, node.LeftConversion, node.OperatorResultKind, rewrittenResultType); 139&& TryGetNullableMethod(rewrittenLeft.Syntax, rewrittenLeft.Type, SpecialMember.System_Nullable_T_GetValueOrDefault, out MethodSymbol getValueOrDefault)) 141return BoundCall.Synthesized(rewrittenLeft.Syntax, rewrittenLeft, getValueOrDefault); 248MethodSymbol getValueOrDefault = UnsafeGetNullableMethod(rewrittenLeft.Syntax, rewrittenLeftType, SpecialMember.System_Nullable_T_GetValueOrDefault); 249rewrittenLeft = BoundCall.Synthesized(rewrittenLeft.Syntax, rewrittenLeft, getValueOrDefault);

21var constructorInvocation = _dynamicFactory.MakeDynamicConstructorInvocation(node.Syntax, node.Type, loweredArguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt).ToExpression(); 28return MakeExpressionWithInitializer(node.Syntax, constructorInvocation, node.InitializerExpressionOpt, node.Type); 58node.Syntax, 92rewrittenObjectCreation = new BoundDefaultExpression(rewrittenObjectCreation.Syntax, rewrittenObjectCreation.Type!); 98node.Syntax, 121return MakeExpressionWithInitializer(node.Syntax, rewrittenObjectCreation, node.InitializerExpressionOpt, node.Type); 166return new BoundSequence(withExpr.Syntax, temps.ToImmutableAndFree(), sideEffects.ToImmutableAndFree(), value, type); 187withExpr.Syntax, 307var rewrittenNewT = MakeNewT(node.Syntax, (TypeParameterSymbol)node.Type); 313return MakeExpressionWithInitializer(node.Syntax, rewrittenNewT, node.InitializerExpressionOpt, rewrittenNewT.Type!); 367_factory.Syntax = node.Syntax; 379newGuid = new BoundBadExpression(node.Syntax, LookupResultKind.NotCreatable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 397callGetTypeFromCLSID = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 409rewrittenObjectCreation = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, node.Type); 419return MakeExpressionWithInitializer(node.Syntax, rewrittenObjectCreation, node.InitializerExpressionOpt, node.Type);

125EmbedIfNeedTo(rewrittenReceiver, initializer.ApplicableMethods, initializer.Syntax); 152var syntax = initializer.Syntax; 357result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, isRef: assignment.IsRef, assignment.Type, used: false)); 406result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); 439result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); 513return MakeFieldAccess(rewrittenLeft.Syntax, rewrittenReceiver, fieldSymbol, null, rewrittenLeft.ResultKind, fieldSymbol.Type); 521rewrittenLeft.Syntax, 537rewrittenLeft.Syntax, 547return 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,

434return BoundCall.Synthesized(expr.Syntax, expr, structToStringMethod); 457expr = new BoundPassByCopy(expr.Syntax, expr, expr.Type); 459return BoundCall.Synthesized(expr.Syntax, expr, objectToStringMethod);

50_diagnostics.Add(rewrittenOperand.Syntax, useSiteInfo); 56rewrittenOperand.Syntax.Location, 67return MakeConversionNode(rewrittenOperand.Syntax, rewrittenOperand, conversion, rewrittenType, @checked: false); 210_factory.Syntax = node.Syntax; 285return LowerPartsToString(data, node.Parts, node.Syntax, node.Type); 330var placeholder = new BoundValuePlaceholder(result.Syntax, result.Type); 331result = 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);

59return MakeUnaryOperator(node, node.OperatorKind, node.Syntax, node.MethodOpt, node.ConstrainedToTypeOpt, loweredOperand, node.Type); 156return MakeConversionNode(newNode.Syntax, newNode, Conversion.ExplicitEnumeration, type, @checked: false); 429SyntaxNode syntax = node.Syntax; 631SyntaxNode syntax = node.Syntax; 663BoundExpression condition = _factory.MakeNullableHasValue(node.Syntax, boundTemp); 731syntax: node.Syntax, 738MethodSymbol ctor = UnsafeGetNullableMethod(node.Syntax, binaryOperandType, SpecialMember.System_Nullable_T__ctor); 739boundOne = new BoundObjectCreationExpression(node.Syntax, ctor, boundOne); 757return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null, constrainedToTypeOpt: null); 772binOp = MakeDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand); 776binOp = MakeLiftedDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand); 780binOp = MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperandType, method: null, constrainedToTypeOpt: null); 849return MakePropertyGetAccess(transformedExpression.Syntax, propertyAccess.ReceiverOpt, propertyAccess.PropertySymbol, propertyAccess); 857return MakePropertyGetAccess(transformedExpression.Syntax, indexerAccess.ReceiverOpt, indexerAccess.Indexer, indexerAccess.Arguments);

41: BoundBlock.SynthesizedNoLocals(node.Syntax, rewrittenBody); 50SyntaxToken awaitKeyword = node.Syntax.Kind() == SyntaxKind.UsingStatement ? ((UsingStatementSyntax)node.Syntax).AwaitKeyword : default; 51return MakeDeclarationUsingStatement(node.Syntax, 90LocalDeclarationStatementSyntax syntax = (LocalDeclarationStatementSyntax)usingDeclarations.Syntax; 150SyntaxNode expressionSyntax = rewrittenExpression.Syntax; 151UsingStatementSyntax usingSyntax = (UsingStatementSyntax)node.Syntax; 214SyntaxNode declarationSyntax = localDeclaration.Syntax;

65SyntaxNode syntax = loop.Syntax; 67BoundStatement ifConditionGotoStart = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel); 131SyntaxNode syntax = loop.Syntax; 133BoundStatement 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);

79_factory.Syntax = loweredOperand.Syntax; 121_factory.Syntax = loweredOperand.Syntax; 159_factory.Syntax = loweredLeft.Syntax; 203_factory.Syntax = loweredReceiver.Syntax; 266_factory.Syntax = loweredReceiver.Syntax; 302_factory.Syntax = loweredReceiver.Syntax; 364_factory.Syntax = loweredReceiver.Syntax; 401_factory.Syntax = loweredReceiver.Syntax; 441_factory.Syntax = loweredReceiver.Syntax; 502_factory.Syntax = loweredReceiver.Syntax;

242rewrittenMethodSymbol = GetMethodWrapperForBaseNonVirtualCall(rewrittenMethodSymbol, node.Syntax); 381if (TryReplaceWithProxy(node.ParameterSymbol, node.Syntax, out BoundNode? replacement)) 397if (TryReplaceWithProxy(node.LocalSymbol, node.Syntax, out BoundNode? replacement)) 440return new BoundLocal(node.Syntax, replacementLocal, node.ConstantValueOpt, replacementLocal.Type, node.HasErrors); 518SyntheticBoundNodeFactory factory = new SyntheticBoundNodeFactory(this.CurrentMethod, rewrittenLeft.Syntax, this.CompilationState, this.Diagnostics); 526node.Syntax, 585method = GetMethodWrapperForBaseNonVirtualCall(method, originalArgument.Syntax);

85var result = new BoundSpillSequenceBuilder(this.Syntax, value); 163AddStatement(new BoundExpressionStatement(expression.Syntax, expression) { WasCompilerGenerated = true }); 237var spiller = new SpillSequenceSpiller(method, body.Syntax, compilationState, tempSubstitution, receiverSubstitution, diagnostics); 297var result = new BoundBlock(statement.Syntax, builder.GetLocals(), builder.GetStatements()) { WasCompilerGenerated = true }; 310if (builder.Syntax != null) 311_F.Syntax = builder.Syntax; 555builder = new BoundSpillSequenceBuilder(lastSpill < newList.Length ? (newList[lastSpill] as BoundSpillSequenceBuilder)?.Syntax : null); 649exceptionFilterPrologueOpt = new BoundStatementList(node.Syntax, builder.GetStatements()); 680var builder = new BoundSpillSequenceBuilder(node.Syntax); 683_F.Syntax = node.Syntax; 718builder = new BoundSpillSequenceBuilder(indicesBuilder.Syntax); 746var boundsBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 799var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 920var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 958var receiverBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 983_F.Syntax = node.Syntax; 987receiverBuilder.AddStatement(_F.ExpressionStatement(new BoundComplexConditionalReceiver(node.Syntax, cache, _F.Sequence(new[] { _F.AssignmentExpression(cache, receiver) }, cache), receiverType) { WasCompilerGenerated = true })); 1023var invokedExpressionBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1049if (conditionBuilder == null) conditionBuilder = new BoundSpillSequenceBuilder((consequenceBuilder ?? alternativeBuilder).Syntax); 1050if (consequenceBuilder == null) consequenceBuilder = new BoundSpillSequenceBuilder(alternativeBuilder.Syntax); 1051if (alternativeBuilder == null) alternativeBuilder = new BoundSpillSequenceBuilder(consequenceBuilder.Syntax); 1148var leftBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1183if (receiverBuilder == null) receiverBuilder = new BoundSpillSequenceBuilder((whenNotNullBuilder ?? whenNullBuilder).Syntax); 1184if (whenNotNullBuilder == null) whenNotNullBuilder = new BoundSpillSequenceBuilder(whenNullBuilder.Syntax); 1185if (whenNullBuilder == null) whenNullBuilder = new BoundSpillSequenceBuilder(whenNotNullBuilder.Syntax); 1339var expressionBuilder = new BoundSpillSequenceBuilder(builder.Syntax); 1372builder = new BoundSpillSequenceBuilder(valueBuilder.Syntax);

68walker.CaptureVariable(method.ThisParameter, node.Syntax); 263CaptureVariable(node.ParameterSymbol, node.Syntax); 272CaptureVariable(thisSymbol, node.Syntax); 280CaptureVariable(topLevelMethod.ThisParameter, node.Syntax); 286CaptureVariable(topLevelMethod.ThisParameter, node.Syntax); 374Capture(_topLevelMethod.ThisParameter, node.Syntax); 380Capture(_topLevelMethod.ThisParameter, node.Syntax); 386Capture(node.LocalSymbol, node.Syntax); 392Capture(node.ParameterSymbol, node.Syntax);

691F.Syntax = node.Syntax; 745translated = new BoundStatementList(node.Syntax, statements);

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

1151return new BoundThrowExpression(thrown.Syntax, thrown, type) { WasCompilerGenerated = true }; 1499return new BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.BoolLogicalNegation, expression, null, null, constrainedToTypeOpt: null, LookupResultKind.Viable, expression.Type); 1551var syntax = argument.Syntax; 1599return new BoundLocal(node.Syntax, temp, constantValueOpt: null, type: node.Type) { WasCompilerGenerated = true };

322return new NoneOperation(children, _semanticModel, boundNode.Syntax, type: type, constantValue, isImplicit: isImplicit); 354boundNode.Syntax, 366boundNode.Syntax, 408builder.Add((IVariableDeclaratorOperation)CreateVariableDeclaratorInternal(decl, decl.Syntax)); 419SyntaxNode syntax = boundDeconstructValuePlaceholder.Syntax; 431SyntaxNode syntax = boundDeconstructionAssignmentOperator.Syntax; 440SyntaxNode syntax = boundCall.Syntax; 472SyntaxNode syntax = boundFunctionPointerInvocation.Syntax; 491boundUnconvertedAddressOf.Syntax, 501var invalidOperation = OperationFactory.CreateInvalidOperation(_semanticModel, boundAttribute.Syntax, GetIOperationChildren(boundAttribute), isImplicit: true); 502return new AttributeOperation(invalidOperation, _semanticModel, boundAttribute.Syntax, isAttributeImplicit); 509initializer = new ObjectOrCollectionInitializerOperation(namedArguments, _semanticModel, boundAttribute.Syntax, boundAttribute.GetPublicTypeSymbol(), isImplicit: true); 513var objectCreationOperation = new ObjectCreationOperation(boundAttribute.Constructor.GetPublicSymbol(), initializer, DeriveArguments(boundAttribute), _semanticModel, boundAttribute.Syntax, boundAttribute.GetPublicTypeSymbol(), boundAttribute.ConstantValueOpt, isImplicit: true); 514return new AttributeOperation(objectCreationOperation, _semanticModel, boundAttribute.Syntax, isAttributeImplicit); 553SyntaxNode syntax = boundLocal.Syntax; 573SyntaxNode syntax = boundFieldAccess.Syntax; 601CreateImplicitReceiver(boundObjectInitializerMember.Syntax, boundObjectInitializerMember.ReceiverType); 614SyntaxNode syntax = boundPropertyAccess.Syntax; 624SyntaxNode syntax = boundIndexerAccess.Syntax; 644SyntaxNode syntax = boundEventAccess.Syntax; 655SyntaxNode syntax = boundEventAssignmentOperator.Syntax; 665SyntaxNode syntax = boundParameter.Syntax; 673SyntaxNode syntax = boundLiteral.Syntax; 682SyntaxNode syntax = boundNode.Syntax; 690SyntaxNode syntax = boundAnonymousObjectCreationExpression.Syntax; 701SyntaxNode syntax = boundObjectCreationExpression.Syntax; 738SyntaxNode syntax = boundWithExpression.Syntax; 750SyntaxNode syntax = boundDynamicObjectCreationExpression.Syntax; 762implicitReceiver.Syntax, type: null, isImplicit: true); 766methodGroup.Syntax, methodGroup.GetPublicTypeSymbol(), methodGroup.WasCompilerGenerated); 779SyntaxNode syntax = boundDynamicInvocation.Syntax; 793return CreateImplicitReceiver(boundObjectInitializerMember.Syntax, boundObjectInitializerMember.ReceiverType); 821SyntaxNode syntax = boundDynamicIndexerAccess.Syntax; 830SyntaxNode syntax = boundObjectInitializerExpression.Syntax; 839SyntaxNode syntax = boundCollectionInitializerExpression.Syntax; 848SyntaxNode syntax = boundObjectInitializerMember.Syntax; 901CreateImplicitReceiver(boundObjectInitializerMember.Syntax, boundObjectInitializerMember.ReceiverType); 906IOperation instanceReceiver = CreateImplicitReceiver(boundDynamicObjectInitializerMember.Syntax, boundDynamicObjectInitializerMember.ReceiverType); 910SyntaxNode syntax = boundDynamicObjectInitializerMember.Syntax; 922SyntaxNode syntax = boundCollectionElementInitializer.Syntax; 940boundDynamicMemberAccess.Syntax, boundDynamicMemberAccess.GetPublicTypeSymbol(), boundDynamicMemberAccess.WasCompilerGenerated); 972SyntaxNode syntax = boundCollectionElementInitializer.Syntax; 992SyntaxNode syntax = boundLambda.Syntax; 1004SyntaxNode syntax = boundLocalFunctionStatement.Syntax; 1024SyntaxNode syntax = boundConversion.Syntax; 1052SyntaxNode syntax = boundConversion.Syntax; 1074if (boundOperand.Syntax == boundConversion.Syntax) 1095if (nestedConversion.Syntax == nestedOperand.Syntax && nestedConversion.ExplicitCastInCode && 1136SyntaxNode syntax = boundAsOperator.Syntax; 1148SyntaxNode syntax = boundDelegateCreationExpression.Syntax; 1159SyntaxNode bindingSyntax = boundMethodGroup.Syntax; 1170SyntaxNode syntax = boundIsOperator.Syntax; 1181SyntaxNode syntax = boundSizeOfOperator.Syntax; 1192SyntaxNode syntax = boundTypeOfOperator.Syntax; 1202SyntaxNode syntax = boundArrayCreation.Syntax; 1205(boundArrayCreation.InitializerOpt?.Syntax == syntax && !boundArrayCreation.InitializerOpt.WasCompilerGenerated); 1212SyntaxNode syntax = boundArrayInitialization.Syntax; 1219SyntaxNode syntax = boundDefaultLiteral.Syntax; 1227SyntaxNode syntax = boundDefaultExpression.Syntax; 1237SyntaxNode syntax = boundBaseReference.Syntax; 1246SyntaxNode syntax = boundThisReference.Syntax; 1270SyntaxNode syntax = boundAssignmentOperator.Syntax; 1282SyntaxNode syntax = boundAssignmentOperator.Syntax; 1299SyntaxNode syntax = boundCompoundAssignmentOperator.Syntax; 1326SyntaxNode syntax = boundIncrementOperator.Syntax; 1336SyntaxNode syntax = boundBadExpression.Syntax; 1341bool isImplicit = boundBadExpression.WasCompilerGenerated || boundBadExpression.ChildBoundNodes.Any(static (e, boundBadExpression) => e?.Syntax == boundBadExpression.Syntax, boundBadExpression); 1349SyntaxNode syntax = boundNewT.Syntax; 1358SyntaxNode syntax = creation.Syntax; 1369SyntaxNode syntax = boundUnaryOperator.Syntax; 1423SyntaxNode syntax = boundBinaryOperator.Syntax; 1455SyntaxNode syntax = boundBinaryOperator.Syntax; 1499SyntaxNode syntax = boundTupleBinaryOperator.Syntax; 1511SyntaxNode syntax = boundConditionalOperator.Syntax; 1522SyntaxNode syntax = boundNullCoalescingOperator.Syntax; 1541SyntaxNode syntax = boundNode.Syntax; 1551SyntaxNode syntax = boundAwaitExpression.Syntax; 1561SyntaxNode syntax = boundArrayAccess.Syntax; 1572SyntaxNode syntax = boundIndexerAccess.Syntax; 1593SyntaxNode syntax = boundNameOfOperator.Syntax; 1603SyntaxNode syntax = boundThrowExpression.Syntax; 1612SyntaxNode syntax = boundAddressOfOperator.Syntax; 1621SyntaxNode syntax = boundImplicitReceiver.Syntax; 1631SyntaxNode syntax = boundConditionalAccess.Syntax; 1640SyntaxNode syntax = boundConditionalReceiver.Syntax; 1650SyntaxNode syntax = boundFieldEqualsValue.Syntax; 1659SyntaxNode syntax = boundPropertyEqualsValue.Syntax; 1668SyntaxNode syntax = boundParameterEqualsValue.Syntax; 1677SyntaxNode syntax = boundBlock.Syntax; 1686SyntaxNode syntax = boundContinueStatement.Syntax; 1695SyntaxNode syntax = boundBreakStatement.Syntax; 1703SyntaxNode syntax = boundYieldBreakStatement.Syntax; 1712SyntaxNode syntax = boundGotoStatement.Syntax; 1719SyntaxNode syntax = boundNoOpStatement.Syntax; 1730SyntaxNode syntax = boundIfStatement.Syntax; 1746SyntaxNode syntax = boundWhileStatement.Syntax; 1760SyntaxNode syntax = boundDoStatement.Syntax; 1775SyntaxNode syntax = boundForStatement.Syntax; 1809getEnumeratorArguments: CreateArgumentOperations(enumeratorInfoOpt.GetEnumeratorInfo, boundForEachStatement.Expression.Syntax), 1810moveNextArguments: CreateArgumentOperations(enumeratorInfoOpt.MoveNextInfo, boundForEachStatement.Expression.Syntax), 1812? CreateDisposeArguments(enumeratorInfoOpt.PatternDisposeInfo, boundForEachStatement.Syntax) 1861var declaratorSyntax = boundForEachStatement.IterationVariableType.Syntax; 1878SyntaxNode syntax = boundForEachStatement.Syntax; 1889SyntaxNode syntax = boundTryStatement.Syntax; 1903SyntaxNode syntax = boundCatchBlock.Syntax; 1913SyntaxNode syntax = boundFixedStatement.Syntax; 1929disposeArguments: CreateDisposeArguments(boundUsingStatement.PatternDisposeInfoOpt, boundUsingStatement.Syntax)) 1931SyntaxNode syntax = boundUsingStatement.Syntax; 1939SyntaxNode syntax = boundThrowStatement.Syntax; 1948SyntaxNode syntax = boundReturnStatement.Syntax; 1956SyntaxNode syntax = boundYieldReturnStatement.Syntax; 1966legacyMode ? null : new SynthesizedLocal((_semanticModel.GetEnclosingSymbol(boundLockStatement.Syntax.SpanStart) as IMethodSymbol).GetSymbol(), 1969syntaxOpt: boundLockStatement.Argument.Syntax).GetPublicSymbol(); 1972SyntaxNode syntax = boundLockStatement.Syntax; 1980SyntaxNode syntax = boundBadStatement.Syntax; 1983bool isImplicit = boundBadStatement.WasCompilerGenerated || boundBadStatement.ChildBoundNodes.Any(static (e, boundBadStatement) => e?.Syntax == boundBadStatement.Syntax, boundBadStatement); 1990var node = boundLocalDeclaration.Syntax; 2044SyntaxNode declarationGroupSyntax = boundMultipleLocalDeclarations.Syntax; 2068disposeArguments: CreateDisposeArguments(usingDecl.PatternDisposeInfoOpt, usingDecl.Syntax)) 2081SyntaxNode syntax = boundLabelStatement.Syntax; 2090SyntaxNode syntax = boundLabeledStatement.Syntax; 2100bool isImplicit = boundExpressionStatement.WasCompilerGenerated || boundExpressionStatement.Syntax == boundExpressionStatement.Expression.Syntax; 2101SyntaxNode syntax = boundExpressionStatement.Syntax; 2108Debug.Assert(boundExpressionStatement.Syntax == sequence.Value.Syntax); 2117SyntaxNode syntax = boundTupleExpression.Syntax; 2147SyntaxNode syntax = boundInterpolatedString.Syntax; 2244builder.Add(new InterpolatedStringTextOperation(valueOperation, _semanticModel, part.Syntax, isImplicit)); 2252Debug.Assert(valueOperation.Syntax != part.Syntax); 2254builder.Add(new InterpolationOperation(valueOperation, alignmentOperation, formatOperation, _semanticModel, part.Syntax, isImplicit)); 2287SyntaxNode syntax = boundStringInsert.Syntax; 2295SyntaxNode syntax = boundNode.Syntax; 2314conversion.Syntax, 2325return new InterpolatedStringAdditionOperation(left, right, _semanticModel, current.Syntax, current.WasCompilerGenerated); 2347return new InterpolatedStringAppendOperation(@this.Create(part), operationKind, @this._semanticModel, part.Syntax, isImplicit: true); 2353interpolatedString.Syntax, 2366SyntaxNode syntax = placeholder.Syntax; 2393placeholder.Syntax, 2401SyntaxNode syntax = boundConstantPattern.Syntax; 2412SyntaxNode syntax = boundRelationalPattern.Syntax; 2431SyntaxNode syntax = boundDeclarationPattern.Syntax; 2454boundRecursivePattern.Syntax, 2473boundITuplePattern.Syntax, 2484syntax: boundTypePattern.Syntax, 2497boundNode.Syntax, 2511boundNode.Syntax, 2522boundNegatedPattern.Syntax, 2535boundBinaryPattern.Syntax, 2545SyntaxNode syntax = boundSwitchStatement.Syntax; 2556return new SwitchCaseOperation(clauses, body, locals, condition: null, _semanticModel, boundSwitchSection.Syntax, isImplicit: boundSwitchSection.WasCompilerGenerated); 2580boundSwitchExpression.Syntax, 2596boundSwitchExpressionArm.Syntax, 2602SyntaxNode syntax = boundSwitchLabel.Syntax; 2606if (boundSwitchLabel.Syntax.Kind() == SyntaxKind.DefaultSwitchLabel) 2630SyntaxNode syntax = boundIsPatternExpression.Syntax; 2638if (boundQueryClause.Syntax.Kind() != SyntaxKind.QueryExpression) 2645SyntaxNode syntax = boundQueryClause.Syntax; 2662boundNode.Syntax, 2677boundIndex.Syntax, 2692boundRange.Syntax, 2703boundNode.Syntax, 2711SyntaxNode subpatternSyntax = subpattern.Syntax; 2724var nameSyntax = member.Syntax; 2731nameSyntax = member.Syntax; 2789SyntaxNode 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; 209boundObjectInitializerMember.Syntax); 219boundIndexer.Syntax); 229objectCreation.Syntax); 239attribute.Syntax); 248boundCall.Syntax, 259boundCollectionElementInitializer.Syntax, 270boundFunctionPointerInvocation.Syntax, 378anonymousProperty.Syntax,

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

48base(unboundLambda.Syntax.GetReference()) 56_syntax = unboundLambda.Syntax;

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

261VerifyParamDefaultValueMatchesAttributeIfAny(_lazyDefaultSyntaxValue, parameterEqualsValue.Value.Syntax, diagnostics); 270parameterEqualsValue.Value.Syntax.Location);

413NullableWalker.AnalyzeIfNeeded(binders[i], boundAttribute, boundAttribute.Syntax, diagnostics.DiagnosticBag);

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

764var result = binder.CheckValueKind(expression.Syntax, expression, Binder.BindValueKind.Assignable, checkingReceiver: false, BindingDiagnosticBag.Discarded); 776return new BoundExpressionStatement(expression.Syntax, expression) { WasCompilerGenerated = true };

62var result = variable.ToBoundExpression(node.Syntax); 84var syntax = node.Syntax; 114var syntax = node.Syntax;

29CreateLocal(compilation, declaredLocals, builder, local, node.Syntax, diagnostics); 60return BoundBlock.SynthesizedNoLocals(node.Syntax, builder.ToImmutableAndFree()); 73var syntax = node.Syntax;

45return placeholder.RewriteLocal(_compilation, node.Syntax, _diagnostics); 49return ObjectIdLocalSymbol.RewriteLocal(_compilation, node.Syntax, local);

26var syntax = initializerInvocation.Syntax;

539var syntax = body.Syntax;

61var expr = InvokeGetMethod(method, variable.Syntax, local.Name); 82return InvokeGetMethod(method.Construct(local.Type), variable.Syntax, local.Name);

159var syntax = expr.Syntax; 194diagnostics.Add(expr.Syntax, useSiteInfo); 198expr.Syntax,

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

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

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