1146Dim callsAreOmitted As Boolean = node.Method.CallsAreOmitted(node.Syntax, node.SyntaxTree) 1813hasCaseElse = hasCaseElse OrElse caseBlock.Syntax.Kind = SyntaxKind.CaseElseBlock

75If IsInsideRegion(branch.Branch.Syntax.Span) AndAlso Not _labelsInside.Contains(branch.Label) Then 84If node.Syntax IsNot Nothing AndAlso IsInsideRegion(node.Syntax.Span) Then 92If IsInside AndAlso pending.Branch IsNot Nothing AndAlso Not IsInsideRegion(pending.Branch.Syntax.Span) Then

141Me.diagnostics.Add(ERRID.ERR_BadYieldInTryHandler, branch.Branch.Syntax.GetLocation) 158Dim syntax = branch.Branch.Syntax

1572CheckAssigned(node.LocalSymbol, node.Syntax, rwContext) 1576CheckAssigned(node.LocalSymbol, node.Syntax, ReadWriteContext.None) 1586CheckAssigned(node.RangeVariable, node.Syntax, ReadWriteContext.None) 1601Dim variableIsUsedDirectlyAndIsAlwaysAssigned = DeclaredVariableIsAlwaysAssignedBeforeInitializer(node.Syntax.Parent, node.InitializerOpt, placeholder) 1606SetPlaceholderSubstitute(placeholder, New BoundLocal(node.Syntax, local, local.Type)) 1766CheckAssigned(MeParameter, node.Syntax) 1772CheckAssigned(node.ParameterSymbol, node.Syntax) 1781CheckAssigned(node, node.Syntax, ReadWriteContext.None) 1791CheckAssigned(node, node.Syntax, rwContext) 1936CheckAssignedFromArgumentWrite(arg, arg.Syntax) 1990CheckAssignedFunctionValue(functionLocal.LocalSymbol, node.Syntax) 1999CheckAssigned(MeParameter, node.Syntax) 2004CheckAssigned(MeParameter, node.Syntax) 2040DeclaredVariableIsAlwaysAssignedBeforeInitializer(node.Syntax, node.Initializer, placeholder) 2077Me.SetPlaceholderSubstitute(placeholder, New BoundLocal(localDecl.Syntax, localToUseAsSubstitute, localToUseAsSubstitute.Type))

68If stmt.Syntax IsNot Nothing AndAlso labelStmt.Syntax IsNot Nothing AndAlso Not IsInsideRegion(stmt.Syntax.Span) AndAlso IsInsideRegion(labelStmt.Syntax.Span) Then

47If stmt.Syntax IsNot Nothing AndAlso labelStmt.Syntax IsNot Nothing AndAlso IsInsideRegion(labelStmt.Syntax.Span) AndAlso Not IsInsideRegion(stmt.Syntax.Span) Then 50_entryPoints.Add(DirectCast(labelStmt.Syntax, LabelStatementSyntax))

53Dim syntax = node.Syntax 102If IsInsideRegion(pending.Branch.Syntax.Span) Then 122_branchesOutOf.Add(DirectCast(pending.Branch.Syntax, StatementSyntax))

110If (Me._regionPlace <> RegionPlace.Inside AndAlso fieldAccess.Syntax.Span.Contains(_region)) Then NoteReceiverRead(fieldAccess) 131Dim receiverSyntax = receiver.Syntax

83If IsInsideRegion(catchBlock.Syntax.Span) Then

81controlVariable.Syntax.GetLocation(), 115nextVariable.Syntax.GetLocation(),

68Dim syntax = block.Syntax 116Dim syntax = delegateCreation.Syntax 171Return New BoundBlock(block.Syntax, block.StatementListSyntax, block.Locals, boundStatements.ToImmutableAndFree(), block.HasErrors) 185Return New BoundBlock(block.Syntax, block.StatementListSyntax, block.Locals, boundStatements.ToImmutableAndFree(), block.HasErrors) 230boundStatements.Add(New BoundReturnStatement(submissionResult.Syntax, submissionResult, method.FunctionLocal, method.ExitLabel))

223CheckAssigned(local, node.Syntax)

565If expression.Syntax.SyntaxTree IsNot Nothing AndAlso 566Me.Compilation.ContainsSyntaxTree(expression.Syntax.SyntaxTree) Then 591Debug.Assert(Not expression.Syntax.SyntaxTree.IsEmbeddedSyntaxTree) 766ReportDiagnostic(diagBag, conv.Operand.Syntax, ERRID.ERR_RequiredAttributeConstConversion2, conv.Operand.Type, conv.Type) 780ReportDiagnostic(diagBag, conv.Operand.Syntax, ERRID.ERR_RequiredAttributeConstConversion2, conv.Operand.Type, conv.Type) 795ReportDiagnostic(diagBag, conv.Operand.Syntax, ERRID.ERR_RequiredAttributeConstConversion2, If(conv.Operand.Type, _binder.Compilation.GetSpecialType(SpecialType.System_Object)), conv.Type) 799If node.Syntax.Kind = SyntaxKind.PredefinedCastExpression Then 800Dim cast = DirectCast(node.Syntax, PredefinedCastExpressionSyntax) 819ReportDiagnostic(diagBag, node.Syntax, ERRID.ERR_RequiredConstExpr) 840ReportDiagnostic(diagBag, sourceType.Syntax, diagInfo) 864ReportDiagnostic(diag, initializerOpt.Syntax, ERRID.ERR_MissingValuesForArraysInApplAttrs)

95If argument.Syntax IsNot node Then 123ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_RestrictedConversion1, sourceType) 128WarnOnNarrowingConversionBetweenSealedClassAndAnInterface(conv, argument.Syntax, sourceType, targetType, diagnostics) 131ReportNoConversionError(argument.Syntax, sourceType, targetType, diagnostics) 137ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_IdentityDirectCastForFloat) 140ReportDiagnostic(diagnostics, argument.Syntax, ERRID.WRN_ObsoleteIdentityDirectCastForValueType) 208If argument.Syntax IsNot node Then 246ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_RestrictedConversion1, sourceType) 251WarnOnNarrowingConversionBetweenSealedClassAndAnInterface(conv, argument.Syntax, sourceType, targetType, diagnostics) 254ReportNoConversionError(argument.Syntax, sourceType, targetType, diagnostics) 411Return New BoundNullableIsTrueOperator(argument.Syntax, argument, booleanType).MakeCompilerGenerated() 435Debug.Assert(tree Is argument.Syntax) 443If isExplicit AndAlso argument.Syntax IsNot tree Then 457TypeOf argument.Syntax.Parent Is BinaryExpressionSyntax OrElse 458TypeOf argument.Syntax.Parent Is UnaryExpressionSyntax OrElse 459TypeOf argument.Syntax.Parent Is TupleExpressionSyntax OrElse 460(TypeOf argument.Syntax.Parent Is AssignmentStatementSyntax AndAlso argument.Syntax.Parent.Kind <> SyntaxKind.SimpleAssignmentStatement), 481diagnostics.Add(argument.Syntax, useSiteInfo) 502ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_RestrictedConversion1, sourceType) 507WarnOnNarrowingConversionBetweenSealedClassAndAnInterface(convKind.Key, argument.Syntax, sourceType, targetType, diagnostics) 515ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_StrictArgumentCopyBackNarrowing3, 518ReportDiagnostic(diagnostics, argument.Syntax, ERRID.WRN_ImplicitConversionCopyBack, 534If Not MakeVarianceConversionSuggestion(convKind.Key, argument.Syntax, sourceType, targetType, diagnostics, justWarn:=False) Then 546ReportDiagnostic(diagnostics, argument.Syntax, err, sourceType, targetType) 556If Not MakeVarianceConversionSuggestion(convKind.Key, argument.Syntax, sourceType, targetType, diagnostics, justWarn:=True) Then 564ReportDiagnostic(diagnostics, argument.Syntax, wrnId1, ErrorFactory.ErrorInfo(wrnId2, sourceType, targetType)) 581ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_ExpressionOverflow1, errorTargetType) 583ElseIf isExplicit OrElse Not MakeVarianceConversionSuggestion(convKind.Key, argument.Syntax, sourceType, targetType, diagnostics, justWarn:=False) Then 584ReportNoConversionError(argument.Syntax, sourceType, targetType, diagnostics, copybackConversionParamName) 1091Dim argumentSyntax = argument.Syntax 1197If ReclassifyExpression(enclosed, conversionSemantics, enclosed.Syntax, convKind, isExplicit, targetType, diagnostics) Then 1220ReportDiagnostic(diagnostics, addressOfExpression.Syntax, ERRID.ERR_AddressOfNotDelegate1, targetType) 1333ReportDiagnostic(diagnostics, unboundLambda.Syntax, ERRID.ERR_LambdaNotDelegate1, targetType) 1339ReportDiagnostic(diagnostics, unboundLambda.Syntax, ERRID.ERR_LambdaNotDelegate1, targetDelegateType) 1341ElseIf ReportDelegateInvokeUseSite(diagnostics, unboundLambda.Syntax, targetDelegateType, delegateInvoke) Then 1368unboundLambda.Syntax, 1420unboundLambda.Syntax, 1444Dim methodGroup = New BoundMethodGroup(unboundLambda.Syntax, 1466relaxationLambdaOpt = relaxationBinder.BuildDelegateRelaxationLambda(unboundLambda.Syntax, 1507ReportDiagnostic(diagnostics, lambda.Syntax, ERRID.ERR_LambdaNotCreatableDelegate1, targetType) 1510ReportDiagnostic(diagnostics, lambda.Syntax, ERRID.ERR_LambdaNotDelegate1, targetType) 1515ReportDiagnostic(diagnostics, lambda.Syntax, ERRID.ERR_LambdaNotDelegate1, targetDelegateType) 1516ElseIf Not ReportDelegateInvokeUseSite(diagnostics, lambda.Syntax, targetDelegateType, invoke) Then 1526ApplyImplicitConversion(lambda.Expression.Syntax, 1536ReportDiagnostic(diagnostics, lambda.Syntax, ERRID.ERR_LambdaBindingMismatch1, targetDelegateType) 1573location = DirectCast(lambda.Expression, BoundRangeVariableAssignment).Value.Syntax 1575location = lambda.Expression.Syntax 1584ApplyImplicitConversion(lambda.Expression.Syntax, delegateReturnType, lambda.Expression, 1657convertedArguments.Add(ApplyConversion(argument.Syntax, destType, argument, isExplicit, diagnostics)) 1661sourceTuple.Syntax, 1668result = New BoundConversion(sourceTuple.Syntax, result, convKind, checked:=False, explicitCastInCode:=isExplicit, type:=destination)

133If boundFirstArgument.Syntax IsNot node Then 225Dim syntaxTree = addressOfExpression.Syntax 271If addressOfExpression.Binder.CheckSharedSymbolAccess(addressOfExpression.Syntax, 289ReportDiagnostic(diagnostics, addressOfExpression.MethodGroup.Syntax, 302Dim addressOfSyntax As SyntaxNode = addressOfExpression.Syntax 303Dim addressOfExpressionSyntax = DirectCast(addressOfExpression.Syntax, UnaryExpressionSyntax) 321addressOfExpression.Binder.ReportDiagnosticsIfObsoleteOrNotSupported(diagnostics, fromMethod, addressOfExpression.MethodGroup.Syntax) 447Dim addressOfSyntax = addressOfExpression.Syntax 572Dim addressOfOperandSyntax = addressOfExpression.Syntax 599addressOfExpression.MethodGroup.Syntax, 629Dim addressOfOperandSyntax = addressOfExpression.Syntax 980Dim syntaxNode = addressOfExpression.Syntax 993receiver = AdjustReceiverTypeOrValue(receiver, receiver.Syntax, targetMethod.IsShared, diagnostics, resolvedTypeOrValueReceiver) 998Dim addressOfOperandSyntax = addressOfExpression.Syntax 1021boundLambda = BuildDelegateRelaxationLambda(syntaxNode, sourceMethodGroup.Syntax, receiver, targetMethod, 1036ReportDiagnostic(diagnostics, addressOfExpression.MethodGroup.Syntax, ERRID.ERR_NoPartialMethodInAddressOf1, target) 1103relaxationReceiverPlaceholder = New BoundRValuePlaceholder(actualReceiver.Syntax, actualReceiver.Type)

109Dim reclassified = ReclassifyArrayLiteralExpression(SyntaxKind.CTypeKeyword, arrayLiteral.Syntax, ConversionKind.Widening, False, arrayLiteral, arrayLiteral.InferredType, diagnostics) 303Return New BoundBadExpression(wrappedBadExpression.Syntax, resultKind, wrappedBadExpression.Symbols, wrappedBadExpression.ChildBoundNodes, wrappedBadExpression.Type, hasErrors:=True) 305Return New BoundBadExpression(wrappedExpression.Syntax, resultKind, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(wrappedExpression), wrappedExpression.Type, hasErrors:=True) 531expressionType = GetSpecialType(SpecialType.System_Object, expression.Syntax, diagnostics) 717ReportDiagnostic(diagnostics, group.TypeArgumentsOpt.Syntax, ERRID.ERR_MethodTypeArgsUnexpected) 951resultType = GetSpecialType(SpecialType.System_Nullable_T, expr.Syntax, diagnostics).Construct(resultType) 955ReportDiagnostic(diagnostics, access.Syntax, ERRID.ERR_CannotBeMadeNullable1, resultType) 981ReportDiagnostic(diagnostics, group.Syntax, ERRID.ERR_InvalidConstructorCall) 982Return New BoundBadVariable(expr.Syntax, expr, ErrorTypeSymbol.UnknownResultType, hasErrors:=True) 985expr = BindInvocationExpression(expr.Syntax, 986expr.Syntax, 987ExtractTypeCharacter(expr.Syntax), 992callerInfoOpt:=expr.Syntax) 1002ReportDiagnostic(diagnostics, expr.Syntax, GetTypeNotExpressionErrorId(type), type) 1003Return New BoundBadVariable(expr.Syntax, expr, ErrorTypeSymbol.UnknownResultType, hasErrors:=True) 1009ReportDiagnostic(diagnostics, expr.Syntax, ERRID.ERR_CannotCallEvent1, DirectCast(expr, BoundEventAccess).EventSymbol) 1010Return New BoundBadVariable(expr.Syntax, expr, ErrorTypeSymbol.UnknownResultType, hasErrors:=True) 1013ReportDiagnostic(diagnostics, expr.Syntax, ERRID.ERR_NamespaceNotExpression1, DirectCast(expr, BoundNamespaceExpression).NamespaceSymbol) 1014Return New BoundBadVariable(expr.Syntax, expr, ErrorTypeSymbol.UnknownResultType, hasErrors:=True) 1017ReportDiagnostic(diagnostics, expr.Syntax, ERRID.ERR_VoidValue, DirectCast(expr, BoundLabel).Label.Name) 1018Return New BoundBadVariable(expr.Syntax, expr, ErrorTypeSymbol.UnknownResultType, hasErrors:=True) 1121ReportDiagnostic(diagnostics, typeExpr.Syntax, ERRID.ERR_CantReferToMyGroupInsideGroupType1, classType) 1130result = New BoundPropertyAccess(typeExpr.Syntax, access.PropertySymbol, access.PropertyGroupOpt, access.AccessKind, 1141result = New BoundFieldAccess(typeExpr.Syntax, access.ReceiverOpt, access.FieldSymbol, access.IsLValue, 1146result = New BoundCall(typeExpr.Syntax, [call].Method, [call].MethodGroupOpt, [call].ReceiverOpt, [call].Arguments, 1227Return BadExpression(expr.Syntax, expr, ErrorTypeSymbol.UnknownResultType).MakeCompilerGenerated() 1234Dim syntax = expr.Syntax 1366ReportUseSite(diagnostics, expr.Syntax, getMethod) 1367ReportDiagnosticsIfObsoleteOrNotSupported(diagnostics, getMethod, expr.Syntax) 1413Return New BoundConversion(expr.Syntax, expr, ConversionKind.WideningNothingLiteral, False, False, expr.ConstantValueOpt, 1414GetSpecialType(SpecialType.System_Object, expr.Syntax, diagnostics), Nothing) 1433ReportDiagnostic(diagnostics, address.MethodGroup.Syntax, GetInaccessibleErrorInfo(address.MethodGroup.Methods(0))) 1435ReportDiagnostic(diagnostics, address.MethodGroup.Syntax, ERRID.ERR_NoViableOverloadCandidates1, 1458ReportDiagnostic(diagnostics, expr.Syntax, ERRID.ERR_VoidValue) 1459Return BadExpression(expr.Syntax, expr, ErrorTypeSymbol.UnknownResultType) 1480ReportDiagnostic(diagnostics, arrayLiteral.Syntax, ERRID.ERR_ArrayInitNoType) 1482ReportNoConversionError(arrayLiteral.Syntax, arrayLiteral.InferredType, destination, diagnostics, Nothing) 1486Dim argument As BoundExpression = ApplyImplicitConversion(arrayLiteral.Syntax, arrayLiteral.InferredType, arrayLiteral, BindingDiagnosticBag.Discarded) 1537bounds = CreateArrayBounds(arrayLiteral.Syntax, knownSizes, diagnostics) 1547Dim arrayCreation = New BoundArrayCreation(arrayLiteral.Syntax, bounds, arrayInitialization, arrayLiteral, conv, sourceType) 1558expr = CreatePredefinedConversion(arrayLiteral.Syntax, arrayCreation, conv, isExplicit, destination, diagnostics) 1584ReportDiagnostic(diagnostics, arrayLiteral.Syntax, ERRID.ERR_RestrictedType1, targetElementType) 1587ReportDiagnostic(diagnostics, arrayLiteral.Syntax, ERRID.ERR_ArrayInitNoType) 1593ReportDiagnostic(diagnostics, arrayLiteral.Syntax, ERRID.ERR_ArrayInitNoTypeObjectDisallowed) 1595ReportDiagnostic(diagnostics, arrayLiteral.Syntax, ERRID.ERR_ArrayInitTooManyTypesObjectDisallowed) 1599ReportDiagnostic(diagnostics, arrayLiteral.Syntax, ErrorFactory.ErrorInfo(ERRID.WRN_ObjectAssumed1, 1602ReportDiagnostic(diagnostics, arrayLiteral.Syntax, ErrorFactory.ErrorInfo(ERRID.WRN_ObjectAssumed1, 1619expr = ApplyImplicitConversion(expr.Syntax, elementType, expr, diagnostics) 1624arrayInitialization = New BoundArrayInitialization(arrayInitialization.Syntax, initializers.ToImmutableAndFree, Nothing) 1639arrayInitialization = New BoundArrayInitialization(arrayInitialization.Syntax, initializers, Nothing).MakeCompilerGenerated() 1643Return New BoundArrayInitialization(arrayInitialization.Syntax, initializers, Nothing) 1651Return ApplyImplicitConversion(tupleLiteral.Syntax, 1661Return ApplyImplicitConversion(arrayLiteral.Syntax, 1671Return ApplyImplicitConversion(lambda.Syntax, 1776ReportDiagnostic(diagnostics, expr.Syntax, err) 2136placeholder = New BoundRValuePlaceholder(testExpression.Syntax, testExpression.Type.GetNullableUnderlyingTypeOrSelf()) 2140convertedTestExpression = ApplyConversion(testExpression.Syntax, type, 3647If receiver IsNot Nothing AndAlso receiver.Kind = BoundKind.TypeExpression AndAlso IsReceiverOfNameOfArgument(receiver.Syntax) Then 3648receiver = New BoundTypeAsValueExpression(receiver.Syntax, DirectCast(receiver, BoundTypeExpression), receiver.Type).MakeCompilerGenerated() 3762left.Syntax, 3808Dim syntax = expr.Syntax 3826ReportDiagnostic(diagnostics, expr.Syntax, ERRID.ERR_QualNotObjectRecord1, expr.Type) 3833ReportDiagnostic(diagnostics, expr.Syntax, ERRID.ERR_DefaultMemberNotProperty1, expr.Type) 3895convertedArguments.Add(ApplyImplicitConversion(argument.Syntax, int32Type, argument, diagnostics)) 4642ReportDiagnostic(diagnostics, operand.Syntax, ERRID.ERR_CantAwaitAsyncSub1, method.Name) 4672Dim awaitableInstancePlaceholder = New BoundRValuePlaceholder(operand.Syntax, operand.Type).MakeCompilerGenerated() 4687awaiterInstancePlaceholder = New BoundLValuePlaceholder(operand.Syntax, getAwaiter.Type).MakeCompilerGenerated() 4725operand.Syntax, 4759awaiterInstancePlaceholder = New BoundLValuePlaceholder(operand.Syntax, getAwaiter.Type).MakeCompilerGenerated() 4774operand.Syntax, 4823operand.Syntax,

62Dim block As New BoundBlock(Me.BoundInitializers(0).Syntax, 216expression = ApplyImplicitConversion(expression.Syntax, submissionReturnType, expression, diagnostics) 217boundStatement = New BoundExpressionStatement(boundStatement.Syntax, expression, expression.HasErrors) 429boundInitExpression = ApplyImplicitConversion(boundInitExpression.Syntax, 529boundInitValue = New BoundBadExpression(boundInitValue.Syntax, 547boundInitValue = ApplyImplicitConversion(boundInitValue.Syntax, targetType, boundInitValue, initValueDiagnostics) 573boundInitValue = BadExpression(boundInitValue.Syntax, boundInitValue, targetType) 658boundInitValue = ApplyImplicitConversion(boundInitValue.Syntax, targetType, boundInitValue, diagnostics) 664boundInitValue = BadExpression(boundInitValue.Syntax, boundInitValue, targetType)

124allowConstructorCall:=True, callerInfoOpt:=group.Syntax) 130ReportDiagnostic(diagnostics, group.Syntax, ERRID.ERR_InvalidConstructorCall) 138allowConstructorCall:=True, callerInfoOpt:=group.Syntax) 143callExpr.Syntax, 296ReportDiagnostic(diagnostics, target.Syntax, ERRID.ERR_DelegateNoInvoke1, target.Type) 299ElseIf ReportDelegateInvokeUseSite(diagnostics, target.Syntax, targetType, delegateInvoke) Then 425callerInfoOpt:=group.Syntax) 435If receiverOpt?.Syntax Is withoutArgs.Syntax AndAlso Not receiverOpt.WasCompilerGenerated Then 443If receiverOpt?.Syntax Is withoutArgs.Syntax AndAlso Not receiverOpt.WasCompilerGenerated Then 489callerInfoOpt:=group.Syntax) 503If(node.Expression, group.Syntax), 509callerInfoOpt:=group.Syntax) 870receiver = AdjustReceiverTypeOrValue(receiver, receiver.Syntax, methodOrProperty.IsShared, diagnostics, resolvedTypeOrValueReceiver) 877ReportDiagnostic(diagnostics, group.Syntax, 887Dim errorLocation As SyntaxNode = lambda.Syntax 1008ReportDiagnostic(diagnostics, propertyAccess.Syntax, ERRID.WRN_RecursivePropertyCall, [property]) 1302If node.SyntaxTree Is groupOpt.Syntax.SyntaxTree AndAlso node.Span.Contains(groupOpt.Syntax.Span) Then 1303result = groupOpt.Syntax 1305If result Is node AndAlso (groupOpt.ReceiverOpt Is Nothing OrElse groupOpt.ReceiverOpt.Syntax Is result) Then 1395ReportDiagnostic(diagnostics, If(groupOpt IsNot Nothing, groupOpt.Syntax, node), GetInaccessibleErrorInfo(singleCandidate.UnderlyingSymbol)) 1398ReportDiagnostic(diagnostics, If(groupOpt IsNot Nothing, groupOpt.Syntax, node), ERRID.ERR_NoViableOverloadCandidates1, bestSymbols(0).Name) 1463ReportDiagnostic(diagnostics, mg.TypeArgumentsOpt.Syntax, 1467ReportDiagnostic(diagnostics, mg.TypeArgumentsOpt.Syntax, 1475ReportDiagnostic(diagnostics, mg.TypeArgumentsOpt.Syntax, 1479ReportDiagnostic(diagnostics, mg.TypeArgumentsOpt.Syntax, 1949If argument.Syntax.SyntaxTree Is diagnostic.Location.SourceTree AndAlso 1951If argument.Syntax.Span.Contains(diagnostic.Location.SourceSpan) Then 2065ReportDiagnostic(diagnostics, arguments(i).Syntax, ERRID.ERR_TooManyArgs) 2067ReportDiagnostic(diagnostics, arguments(i).Syntax, 2071ReportDiagnostic(diagnostics, arguments(i).Syntax, 2090ReportDiagnostic(diagnostics, arguments(i).Syntax, ERRID.ERR_OmittedParamArrayArgument) 2124ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(seenOutOfPositionNamedArgIndex).Syntax), 2134ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), ERRID.ERR_NamedParamNotFound1, argumentNames(i)) 2136ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), 2140ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), 2151ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), ERRID.ERR_NamedParamArrayArgument) 2161ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), ERRID.ERR_NamedArgUsedTwice1, argumentNames(i)) 2163ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), 2167ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), 2182ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), ERRID.ERR_NamedArgAlsoOmitted1, argumentNames(i)) 2184ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), 2188ReportDiagnostic(diagnostics, GetNamedArgumentIdentifier(arguments(i).Syntax), 2400ReportDiagnostic(diagnostics, paramArrayArgument.Syntax, ERRID.ERR_ParamArrayArgumentMismatch) 2500Dim boundTemp = New BoundRValuePlaceholder(argument.Syntax, targetType) 2506CreateConversionAndReportDiagnostic(argument.Syntax, boundTemp, conv, False, copyBackType, diagnostics, copybackConversionParamName:=param.Name) 2512CreateConversionAndReportDiagnostic(argument.Syntax, boundTemp, conv, False, copyBackType, diagnostics, copybackConversionParamName:=param.Name) 2514ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_ArgumentCopyBackNarrowing3, 2531ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_ReadOnlyInClosure) 2564CreateConversionAndReportDiagnostic(argument.Syntax, argument, conv, False, targetType, diagnostics) 2581CreateConversionAndReportDiagnostic(argument.Syntax, argument, conv, False, targetType, diagnostics) 2616ReportDiagnostic(diagnostics, argument.Syntax, ERRID.ERR_ArgumentNarrowing2, 2619ReportDiagnostic(diagnostics, argument.Syntax, err, 2734argument = ApplyImplicitConversion(argument.Syntax, targetType, argument, diagnostics) 2769ReportUseSite(diagnostics, argument.Syntax, useSiteInfo) 2856Dim inPlaceholder = New BoundByRefArgumentPlaceholder(argument.Syntax, isOutParameter, argument.Type, argument.HasErrors).MakeCompilerGenerated() 2857Dim inConversion = CreateConversionAndReportDiagnostic(argument.Syntax, 2862Dim outPlaceholder = New BoundRValuePlaceholder(argument.Syntax, targetType).MakeCompilerGenerated() 2871Dim outConversion = CreateConversionAndReportDiagnostic(argument.Syntax, outPlaceholder, conversionFrom, 2881Dim copyBackExpression = BindAssignment(argument.Syntax, argument, outConversion, diagnostics) 2897Return New BoundByRefArgumentWithCopyBack(argument.Syntax, argument, 2909argument.Syntax.Location, 2910DirectCast(argument.Syntax.SyntaxTree.Options, VisualBasicParseOptions).LanguageVersion, 2972argument = CreateConversionAndReportDiagnostic(argument.Syntax, argument, conversion, False, targetType, diagnostics) 3164argumentSyntax = reducedExtensionReceiverOpt.Syntax 3169argumentSyntax = arguments(argumentIndex).Syntax

218Dim lambdaSymbol As New SourceLambdaSymbol(source.Syntax, source, parameters, targetReturnType, Me) 314Return New BoundLambda(source.Syntax, lambdaSymbol, block, 455expression = bodyBinder.ApplyImplicitConversion(expression.Syntax, retType, expression, diagnostics, False) 461Dim boundReturn = New BoundReturnStatement(expression.Syntax, 639ReportDiagnostic(_diagnostics, node.Syntax, ERRID.ERR_BadAwaitInTryHandler) 756receiverOpt = New BoundFieldAccess(argument.Syntax, receiverOpt, fieldSymbol, 810parameterDescriptors(i) = New AnonymousTypeField(returnParamName, returnType, source.Syntax.GetLocation(), False) 812Dim typeDescriptor As New AnonymousTypeDescriptor(parameterDescriptors.AsImmutableOrNull(), source.Syntax.GetLocation(), True) 903Dim symbol = New SourceLambdaSymbol(source.Syntax, source, parameters, LambdaSymbol.ReturnTypeIsBeingInferred, Me) 920lambdaReturnType = GetWellKnownType(WellKnownType.System_Threading_Tasks_Task, source.Syntax, diagnostics) 925lambdaReturnType = GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T, source.Syntax, diagnostics). 926Construct(GetSpecialType(SpecialType.System_Object, source.Syntax, diagnostics)) 942lambdaReturnType = GetSpecialType(SpecialType.System_Object, source.Syntax, diagnostics) 953lambdaReturnType = InferDominantTypeOfExpressions(source.Syntax, returnExpressions, diagnostics, numCandidates) 993lambdaReturnType = GetWellKnownType(WellKnownType.System_Threading_Tasks_Task_T, source.Syntax, diagnostics).Construct(lambdaReturnType) 997lambdaReturnType = GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T, source.Syntax, diagnostics).Construct(lambdaReturnType) 1008Dim lambdaSyntax = TryCast(source.Syntax, LambdaExpressionSyntax) 1014Return source.Syntax

103memberSyntax = If(invocationSyntax.Expression, group.Syntax) 183argument = omitted.Update(GetSpecialType(SpecialType.System_Object, argument.Syntax, diagnostics)) 195argument = ApplyImplicitConversion(argument.Syntax, objectType, argument, diagnostics) 251ReportDiagnostic(diagnostics, arguments(i).Syntax, ERRID.ERR_NamedArgumentSpecificationBeforeFixedArgumentInLateboundInvocation)

80result = ApplyImplicitConversion(targetArgument.Syntax, 81GetSpecialType(SpecialType.System_Object, targetArgument.Syntax, diagnostics), 87ReportDiagnostic(diagnostics, targetArgument.Syntax, 96ReportDiagnostic(diagnostics, targetArgument.Syntax, 103result = ApplyImplicitConversion(targetArgument.Syntax, 104GetSpecialType(SpecialType.System_Object, targetArgument.Syntax, diagnostics), 109ReportDiagnostic(diagnostics, targetArgument.Syntax, 409ReportDiagnostic(diagnostics, left.Syntax, ErrorFactory.ErrorInfo(errorId, operatorTokenKind)) 413ReportDiagnostic(diagnostics, right.Syntax, ErrorFactory.ErrorInfo(errorId, operatorTokenKind)) 441left = ApplyConversion(left.Syntax, operandType, left, explicitSemanticForConcatArgument, diagnostics, 465right = ApplyImplicitConversion(right.Syntax, rightTargetType, right, diagnostics) 469right = ApplyConversion(right.Syntax, operandType, right, explicitSemanticForConcatArgument, diagnostics, 508ReportDiagnostic(diagnostics, right.Syntax, ErrorFactory.ErrorInfo(ERRID.ERR_ConstantStringTooLong)) 543Dim nothingStr = New BoundLiteral(left.Syntax, ConstantValue.Nothing, stringType).MakeCompilerGenerated() 545Return AnalyzeConversionAndCreateBinaryConditionalExpression(left.Syntax, 671leftPlaceholder = New BoundRValuePlaceholder(left.Syntax, operatorType).MakeCompilerGenerated() 771ReportDiagnostic(diagnostics, operand.Syntax, 791stringType = GetSpecialType(SpecialType.System_String, dbNullOperand.Syntax, diagnostics) 794dbNullOperand = New BoundConversion(dbNullOperand.Syntax, dbNullOperand, ConversionKind.Widening, 1025rightType = GetSpecialType(defaultRightSpecialType, right.Syntax, diagnostics) 1026right = ApplyImplicitConversion(right.Syntax, 1064leftType = GetSpecialType(defaultLeftSpecialType, left.Syntax, diagnostics) 1067left = ApplyImplicitConversion(left.Syntax, 1093rightType = GetSpecialType(SpecialType.System_String, right.Syntax, diagnostics) 1098right = ApplyImplicitConversion(right.Syntax,

587Dim fromClauseSyntax = DirectCast(source.Syntax.Parent, FromClauseSyntax) 622boundCallOrBadExpression = BindQueryOperatorCall(source.Syntax.Parent, source, 625source.Syntax.Span, 630Return New BoundQueryClause(source.Syntax.Parent, 786Debug.Assert(Not skipFirstVariable OrElse source.Syntax Is variables.First) 3320outerKey = BadExpression(outerKey.Syntax, outerKey, ErrorTypeSymbol.UnknownResultType).MakeCompilerGenerated() 3323innerKey = BadExpression(innerKey.Syntax, innerKey, ErrorTypeSymbol.UnknownResultType).MakeCompilerGenerated() 3514outerKey = outerKeyBinder.ApplyImplicitConversion(outerKey.Syntax, targetType, outerKey, diagnostics, False) 3515innerKey = innerKeyBinder.ApplyImplicitConversion(innerKey.Syntax, targetType, innerKey, diagnostics, False) 3562ReportDiagnostic(diagnostics, outerKey.Syntax, errorInfo) 3577ReportDiagnostic(diagnostics, innerKey.Syntax, errorInfo) 3715ReportDiagnostic(_diagnostics, node.Syntax, _errorInfo) 4301Return New BoundQueryClause(source.Syntax, 4353Dim asQueryable As BoundExpression = BindQueryOperatorCall(source.Syntax, source, StringConstants.AsQueryableMethod, 4355source.Syntax.Span, additionalDiagnostics) 4371Dim asEnumerable As BoundExpression = BindQueryOperatorCall(source.Syntax, source, StringConstants.AsEnumerableMethod, 4373source.Syntax.Span, additionalDiagnostics) 4390inferredType = GetSpecialType(SpecialType.System_Object, source.Syntax, additionalDiagnostics) 4392Dim cast As BoundExpression = BindQueryOperatorCall(source.Syntax, source, StringConstants.CastMethod, 4393New BoundTypeArguments(source.Syntax, 4396source.Syntax.Span, additionalDiagnostics)

390Dim booleanType = GetSpecialType(SpecialType.System_Boolean, selectExpression.Syntax, diagnostics) 395If caseBlock.Syntax.Kind <> SyntaxKind.CaseElseBlock AndAlso 396Not caseBlock.CaseStatement.Syntax.IsMissing Then 399Dim caseStatementSyntax = caseStatement.Syntax 441caseStatementCondition = ApplyImplicitConversion(caseStatementCondition.Syntax, booleanType, caseStatementCondition, diagnostics:=diagnostics, isOperandOfConditionalBranch:=True) 471Dim syntax = DirectCast(boundClause.Syntax, RelationalCaseClauseSyntax) 492conditionOpt = If(boundClause.ConditionOpt, BindBinaryOperator(node:=boundClause.Syntax, 505Dim syntax = boundClause.Syntax 513node:=boundClause.Syntax, 677ReportDiagnostic(diagnostics, rangeCaseClause.Syntax, ERRID.WRN_SelectCaseInvalidRange)

478Binder.ReportDiagnostic(diagnostics, node.Syntax, ERRID.ERR_TryAndOnErrorDoNotMix) 521_resumeWithoutLabel = DirectCast(node.Syntax, StatementSyntax) 526ReportDiagnostic(_diagnostics, node.Syntax, 541_resumeWithoutLabel = DirectCast(node.Syntax, StatementSyntax) 577ReportDiagnostic(_diagnostics, node.Syntax, ERRID.ERR_BadAwaitInTryHandler) 597If Not node.WasCompilerGenerated AndAlso node.Syntax.Kind = SyntaxKind.LabelStatement AndAlso 598DirectCast(node.Syntax, LabelStatementSyntax).LabelToken.Kind = SyntaxKind.IntegerLiteralToken Then 1165declarationInitializer = ApplyImplicitConversion(declarationInitializer.Syntax, type, declarationInitializer, diagnostics) 1943If ReportUseSite(diagnostics, op1.Syntax, setMethod) Then 1985op2 = ApplyImplicitConversion(op2.Syntax, targetType, op2, diagnostics) 2029placeholder = New BoundCompoundAssignmentTargetPlaceholder(left.Syntax, targetType).MakeCompilerGenerated() 2697ReportDiagnostic(diagnostics, boundInvocation.Syntax, ERRID.ERR_PropertyAccessIgnored) 2713ReportDiagnostic(diagnostics, boundInvocation.Syntax, ERRID.ERR_PropertyAccessIgnored) 2722GetSpecialType(SpecialType.System_Void, conditionalAccess.Syntax, diagnostics)) 3142initialValue = ApplyImplicitConversion(initialValue.Syntax, targetType, initialValue, diagnostics) 3143limit = ApplyImplicitConversion(limit.Syntax, targetType, limit, diagnostics) 3145stepValue = ApplyConversion(stepValue.Syntax, targetType, stepValue, 3409Dim collectionSyntax = collection.Syntax 3604ReportDiagnostic(diagnostics, controlVariable.Syntax, ERRID.ERR_LoopControlMustNotBeProperty) 3619ReportDiagnostic(diagnostics, controlVariable.Syntax, ERRID.ERR_LoopControlMustNotAwait) 3709Dim collectionSyntax = collection.Syntax 4058Dim collectionSyntax = collection.Syntax 4434Dim declarationSyntax = localDeclarations.Syntax 4476VerifyUsingVariableDeclarationAndBuildUsingInfo(localDeclaration.Syntax, 4703lockExpression.Syntax, 4783exceptionSource = BadExpression(exceptionSource.Syntax, exceptionSource, ErrorTypeSymbol.UnknownResultType).MakeCompilerGenerated() 5033ReportDiagnostic(diagnostics, arg.Syntax, ERRID.ERR_BadAsyncReturnOperand1, retType) 5039arg = ApplyImplicitConversion(arg.Syntax, retType, arg, diagnostics) 5134arg = ApplyImplicitConversion(arg.Syntax, retType, arg, diagnostics)

1305ReportDiagnostic(diagnostics, boundExpression.Syntax, ERRID.ERR_RequiredConstExpr) 1355ReportDiagnostic(diagnostics, boundExpression.Syntax, ERRID.ERR_RequiredConstExpr) 1406operand.Syntax, 1408If(operandType, GetSpecialType(SpecialType.System_Object, operand.Syntax, diagnostics)), 1448operand.Syntax, 1467Dim conversionToUnderlying As BoundExpression = ApplyConversion(operand.Syntax, conversionType.GetNullableUnderlyingType(), operand, isExplicit:=True, diagnostics:=BindingDiagnosticBag.Discarded) 1477operand.Syntax, 1509operand.Syntax,

367Return BindInvocationExpressionIfGroupNotNothing(expr.Syntax,

86Return Add(node.Syntax.Location, useSiteInfo)

150Return New Conversion(Conversions.ClassifyConversion(boundExpression, vbDestination, GetEnclosingBinder(boundExpression.Syntax), CompoundUseSiteInfo(Of AssemblySymbol).Discarded)) 947If boundQuery.LastOperator.Syntax Is node Then 1160node.Syntax Is _targetSyntax AndAlso 2194If _thisSyntaxNodeOnly IsNot Nothing AndAlso node.Syntax IsNot _thisSyntaxNodeOnly Then 2208_nodeCache.Add(node.Syntax, node) 2230_nodeCache.Add(binary.Syntax, binary) 2241_nodeCache.Add(binary.Syntax, binary) 2269If boundGroup.Syntax IsNot node.Syntax Then 2292If boundGroup.Syntax IsNot node.Syntax Then 2325Debug.Assert(Not _semanticModel._guardedQueryBindersMap.TryGetValue(node.Syntax, haveBindersInTheMap) OrElse haveBindersInTheMap.Equals(node.Binders)) 2328_semanticModel._guardedQueryBindersMap(node.Syntax) = node.Binders 2338Debug.Assert(Not _semanticModel._guardedQueryBindersMap.TryGetValue(node.Syntax, haveBindersInTheMap) OrElse haveBindersInTheMap.Equals(node.Binders)) 2340_semanticModel._guardedQueryBindersMap(node.Syntax) = node.Binders 2348Dim initialization = TryCast(node.Syntax, FieldInitializerSyntax) 2386If boundGroup.Syntax IsNot node.Syntax Then

93(Type.IsVoidType() AndAlso Syntax.Kind = SyntaxKind.MidAssignmentStatement) OrElse

631Return New BoundExpressionStatement(node.Syntax, node, node.HasErrors)

20Debug.Assert(TypeOf Me.Syntax Is LambdaExpressionSyntax) 22Dim kind As SyntaxKind = Me.Syntax.Kind 40TypeOf Syntax Is LambdaExpressionSyntax OrElse 41LambdaUtilities.IsLambdaBody(Syntax) OrElse 42Syntax.IsKind(SyntaxKind.AddressOfExpression) OrElse 43LambdaUtilities.IsNonUserCodeQueryLambda(Syntax) OrElse

21Return New BoundLValueToRValueWrapper(Me.Syntax, Me, Me.Type).MakeCompilerGenerated() ' This is a compiler generated node

14Me.New(source.Syntax, source, source.Type)

13Me.New([call].Syntax, [call], [call].Type)

162Dim syntax As SyntaxNode = node.Syntax

25Syntax.QueryClauseKeywordOrRangeVariableIdentifier.GetLocation(), 27Syntax.QueryClauseKeywordOrRangeVariableIdentifier.GetLocation(),

29Debug.Assert(TypeOf Me.Syntax Is LambdaExpressionSyntax) 30Dim kind As SyntaxKind = Me.Syntax.Kind 42Debug.Assert(TypeOf Me.Syntax Is LambdaExpressionSyntax) 43Dim kind As SyntaxKind = Me.Syntax.Kind

206Dim syntax = node.Syntax 221Dim syntax = node.Syntax 235Dim syntax = node.Syntax

144Dim value = AllocateTemp(expression.Type, expression.Syntax) 156Me.DefineLocal(local, sequence.Syntax) 419EmitSymbolToken(elementType, arrayAccess.Syntax) 421_builder.EmitArrayElementAddress(_module.Translate(DirectCast(arrayAccess.Expression.Type, ArrayTypeSymbol)), arrayAccess.Syntax, _diagnostics) 429EmitStaticFieldAddress(field, fieldAccess.Syntax) 486EmitBox(receiverType, receiver.Syntax) 513EmitSymbolToken(field, fieldAccess.Syntax)

44_builder.EmitArrayBlockInitializer(Me.GetRawData(initExprs), inits.Syntax, _diagnostics) 73EmitArrayElementStore(arrayType, init.Syntax) 171EmitArrayElementStore(arrayType, init.Syntax)

163EmitLoadDefaultValueOfTypeFromNothingLiteral(typeTo, used:=True, syntaxNode:=conversion.Syntax) 180EmitBox(typeFrom, conversion.Operand.Syntax) 182EmitSymbolToken(typeTo, conversion.Syntax) 185EmitBox(typeFrom, conversion.Operand.Syntax) 193EmitUnboxAny(typeTo, conversion.Syntax) 229EmitInitObj(typeTo, used:=True, syntaxNode:=conversion.Syntax) 234_diagnostics.Add(New VBDiagnostic(diagnosticInfo, conversion.Syntax.Location)) 237EmitNewObj(constructor, ImmutableArray(Of BoundExpression).Empty, used:=True, syntaxNode:=conversion.Syntax) 246EmitSymbolToken(typeTo, conversion.Syntax) 308EmitLoadDefaultValueOfTypeParameter(conversion.Type, used, conversion.Syntax) 315EmitUnboxAny(conversion.Type, conversion.Syntax) 335EmitBox(typeFrom, conversion.Operand.Syntax) 340EmitSymbolToken(typeTo, conversion.Syntax) 345EmitSymbolToken(typeTo, conversion.Syntax) 350EmitUnboxAny(typeTo, conversion.Syntax) 361EmitBox(typeFrom, conversion.Operand.Syntax) 365EmitSymbolToken(typeTo, conversion.Syntax) 369EmitBox(typeFrom, conversion.Operand.Syntax) 377EmitSymbolToken(typeTo, conversion.Syntax) 420EmitSymbolToken(typeTo, conversion.Syntax) 434EmitUnboxAny(typeTo, conversion.Syntax) 474EmitLoadDefaultValueOfTypeParameter(conversion.Type, used:=True, syntaxNode:=conversion.Syntax) 495EmitBox(typeFrom, conversion.Operand.Syntax) 499EmitSymbolToken(typeTo, conversion.Syntax) 503EmitSymbolToken(typeTo, conversion.Syntax) 514EmitBox(typeFrom, conversion.Operand.Syntax)

40EmitConstantExpression(expression.Type, constantValue, used, expression.Syntax) 216EmitLoadIndirect(expression.Type, expression.Syntax) 231EmitInitObj(receiverType, True, expression.Syntax) 232EmitBox(receiverType, expression.Syntax) 315EmitInitObj(receiverType, True, receiver.Syntax) 316EmitBox(receiverType, receiver.Syntax) 318EmitLoadIndirect(receiverType, receiver.Syntax) 320temp = AllocateTemp(receiverType, receiver.Syntax) 324EmitBox(receiverType, receiver.Syntax) 333EmitLoadIndirect(receiverType, receiver.Syntax) 334EmitBox(receiverType, receiver.Syntax) 343EmitBox(receiverType, receiver.Syntax) 406EmitInitObj(receiverType, True, expression.Syntax) 407EmitBox(receiverType, expression.Syntax) 423EmitDelegateCreation(expression.ReceiverOpt, invoke, expression.Type, used, expression.Syntax) 440EmitLoadIndirect(local.Type, local.Syntax) 459EmitBox(receiver.Type, receiver.Syntax) 498EmitSymbolToken(thisRef.Type, thisRef.Syntax) 513Me.DefineLocal(local, sequence.Syntax) 622EmitSymbolToken(elementType, arrayAccess.Expression.Syntax) 626_builder.EmitArrayElementLoad(_module.Translate(DirectCast(arrayAccess.Expression.Type, ArrayTypeSymbol)), arrayAccess.Expression.Syntax, _diagnostics) 648EmitStaticFieldLoad(field, used, fieldAccess.Syntax) 666EmitLoadIndirect(dupExpression.Type, dupExpression.Syntax) 698EmitSymbolToken(field, fieldAccess.Syntax) 723EmitSymbolToken(receiver.Type, receiver.Syntax) 732EmitSymbolToken(field, fieldAccess.Syntax) 806EmitLoadIndirect(parameterType, parameter.Syntax) 966Debug.Assert(Not Me._module.AllowOmissionOfConditionalCalls OrElse Not method.CallsAreOmitted([call].Syntax, [call].SyntaxTree)) 1043EmitBox(receiverType, receiver.Syntax) 1097EmitSymbolToken(receiver.Type, receiver.Syntax) 1102EmitSymbolToken(method, [call].Syntax) 1137EmitLoadIndirect(method.ReturnType, [call].Syntax) 1218EmitSymbolToken(typeTo, expression.Syntax) 1281EmitStaticCast(expr.Type, expr.Syntax) 1298EmitStaticCast(expr.Type, expr.Syntax) 1302EmitStaticCast(expr.Type, expr.Syntax) 1332EmitStaticCast(expr.Type, expr.Syntax) 1340EmitBox(expr.Type, expr.TestExpression.Syntax) 1354EmitStaticCast(expr.Type, expr.Syntax) 1357EmitStaticCast(expr.Type, expr.Syntax) 1487EmitSymbolToken(arrayType.ElementType, expression.Syntax) 1489_builder.EmitArrayCreation(_module.Translate(arrayType), expression.Syntax, _diagnostics) 1522EmitInitObj(expression.Type, used, expression.Syntax) 1525EmitNewObj(expression.ConstructorOpt, expression.Arguments, used, expression.Syntax) 1574EmitInitObj(target.Type, True, target.Syntax) 1583EmitSymbolToken(target.Type, target.Syntax) 1718Me.EmitSymbolToken(target.Type, target.Syntax) 1736Me.EmitSymbolToken(constructor, objCreation.Syntax) 1828Me.DefineLocal(local, sequence.Syntax) 1856temp = Me.AllocateTemp(assignmentOperator.Left.Type, assignmentOperator.Left.Syntax) 1892EmitLoadIndirect(capture.Type, capture.Syntax) 1905EmitStoreIndirect(boundLocal.LocalSymbol.Type, expression.Syntax) 1915EmitStoreIndirect(expression.Type, expression.Syntax) 1920EmitArrayElementStore(arrayType, expression.Syntax) 1942EmitStoreIndirect(expression.Type, expression.Syntax) 1959EmitSymbolToken(thisRef.Type, thisRef.Syntax) 2031EmitSymbolToken(field, fieldAccess.Syntax) 2042EmitStoreIndirect(parameter.ParameterSymbol.Type, parameter.Syntax) 2104EmitSymbolToken(type, boundTypeOfOperator.SourceType.Syntax) 2109EmitSymbolToken(getTypeMethod, boundTypeOfOperator.Syntax) 2115EmitSymbolToken(node.Field, node.Syntax) 2124EmitSymbolToken(node.Field.ContainingType, node.Syntax) 2130EmitSymbolToken(getField, node.Syntax) 2133EmitSymbolToken(node.Type, node.Syntax) 2147EmitSymbolToken(method, node.Syntax) 2154EmitSymbolToken(method.ContainingType, node.Syntax) 2160EmitSymbolToken(getMethod, node.Syntax) 2163EmitSymbolToken(node.Type, node.Syntax) 2193EmitSymbolToken(symbol, node.Syntax, encodeAsRawDefinitionToken:=True) 2213_builder.EmitToken(_module.GetModuleVersionId(_module.Translate(node.Type, node.Syntax, _diagnostics), node.Syntax, _diagnostics), node.Syntax, _diagnostics) 2232_builder.EmitToken(_module.GetInstrumentationPayloadRoot(node.AnalysisKind, _module.Translate(node.Type, node.Syntax, _diagnostics), node.Syntax, _diagnostics), node.Syntax, _diagnostics)

562EmitBox(comparandType, comparand.Syntax) 574EmitBox(comparandType, comparand.Syntax)

199exceptionType = Me._module.Translate(exceptionSource.Type, exceptionSource.Syntax, _diagnostics) 202exceptionType = Me._module.Translate(Me._module.Compilation.GetWellKnownType(WellKnownType.System_Exception), catchBlock.Syntax, _diagnostics) 230_builder.EmitToken(exceptionType, catchBlock.Syntax, _diagnostics) 254_builder.EmitToken(exceptionType, catchBlock.Syntax, _diagnostics) 257EmitSetProjectError(catchBlock.Syntax, catchBlock.ErrorLineNumberOpt) 281_builder.EmitToken(exceptionType, catchBlock.Syntax, _diagnostics) 296DefineLocal(localOpt, If(Not declNodes.IsEmpty, DirectCast(declNodes(0).GetSyntax(), VisualBasicSyntaxNode), catchBlock.Syntax)) 303EmitSetProjectError(catchBlock.Syntax, catchBlock.ErrorLineNumberOpt) 311EmitSymbolToken(exceptionSource.Type, exceptionSource.Syntax) 338Dim temp = AllocateTemp(exceptionSource.Type, exceptionSource.Syntax) 358Dim temp = AllocateTemp(exceptionSource.Type, exceptionSource.Syntax) 382EmitSetProjectError(catchBlock.Syntax, catchBlock.ErrorLineNumberOpt) 415EmitClearProjectError(catchBlock.Syntax) 803EmitBox(conditionType, condition.Syntax) 826Me.DefineLocal(local, sequence.Syntax) 854EmitClearProjectError(boundGotoStatement.Syntax) 915EmitBox(operandType, operand.Syntax) 1029Debug.Assert(caseBlock.Syntax.Kind = SyntaxKind.CaseElseBlock) 1062temp = AllocateTemp(exprType, selectExpression.Syntax) 1069EmitStringSwitchJumpTable(caseLabels, fallThroughLabel, GetLocal(DirectCast(selectExpression, BoundLocal)), selectExpression.Syntax) 1073temp = AllocateTemp(exprType, selectExpression.Syntax) 1076EmitStringSwitchJumpTable(caseLabels, fallThroughLabel, temp, selectExpression.Syntax) 1200Debug.Assert(caseStatement.Syntax IsNot Nothing) 1203EmitSequencePoint(caseStatement.Syntax) 1229Me.DefineLocal(local, If(declNodes.IsEmpty, scope.Syntax, declNodes(0).GetVisualBasicSyntax()))

122Return New BoundDup(node.Syntax, node.LocalSymbol.IsByRef, node.Type)

1270Dim syntax = block.Syntax 1506SynthesizedSubmissionConstructorSymbol.MakeSubmissionInitialization(block.Syntax, method, previousSubmissionFields, _compilation), 1528body = New BoundBlock(body.Syntax, Nothing, ImmutableArray(Of LocalSymbol).Empty, boundStatements.ToImmutableAndFree(), body.HasErrors).MakeCompilerGenerated()

928boundNodes.LowestBoundNodeOfSyntacticParent.Syntax.Kind = SyntaxKind.ObjectCreationExpression AndAlso 929DirectCast(boundNodes.LowestBoundNodeOfSyntacticParent.Syntax, ObjectCreationExpressionSyntax).Type Is lowestExpr.Syntax Then 992Dim parentSyntax As SyntaxNode = boundNodes.LowestBoundNodeOfSyntacticParent.Syntax 994parentSyntax Is boundNodes.LowestBoundNode.Syntax.Parent AndAlso 995((parentSyntax.Kind = SyntaxKind.ObjectCreationExpression AndAlso (DirectCast(parentSyntax, ObjectCreationExpressionSyntax).Type Is boundNodes.LowestBoundNode.Syntax))) Then 1034boundNodes.LowestBoundNodeOfSyntacticParent.Syntax.Kind = SyntaxKind.ObjectCreationExpression AndAlso 1035DirectCast(boundNodes.LowestBoundNodeOfSyntacticParent.Syntax, ObjectCreationExpressionSyntax).Type Is boundNodes.LowestBoundNode.Syntax AndAlso 1116Dim binder As Binder = If(binderOpt, GetEnclosingBinder(boundNodes.LowestBoundNode.Syntax.SpanStart)) 1142If lowestExpr.Kind = BoundKind.BadExpression AndAlso lowestExpr.Syntax.Kind = SyntaxKind.ObjectCreationExpression Then 1144Dim typeSyntax = DirectCast(lowestExpr.Syntax, ObjectCreationExpressionSyntax).Type 1147If child.Kind = BoundKind.MethodGroup AndAlso child.Syntax Is typeSyntax Then 1422Dim parentSyntax As SyntaxNode = boundNodeOfSyntacticParent.Syntax 1425parentSyntax Is lowestBoundNode.Syntax.Parent AndAlso 1427(DirectCast(parentSyntax, AttributeSyntax).Name Is lowestBoundNode.Syntax) Then 1470Debug.Assert(binderOpt IsNot Nothing OrElse IsInTree(lowestBoundNode.Syntax)) 1473Debug.Assert(lowestBoundNode.Syntax IsNot Nothing) 1478Dim binder As Binder = If(binderOpt, GetEnclosingBinder(lowestBoundNode.Syntax.SpanStart))

72Return Not useSiteDiagnostics.IsNullOrEmpty AndAlso diagnostics.Add(node.Syntax.GetLocation, useSiteDiagnostics)

269Dim result = New BoundTypeArguments(Me.Syntax, arguments, Me.HasErrors) 296Dim result = New BoundOmittedArgument(Me.Syntax, type, Me.HasErrors) 355Dim result = New BoundLValueToRValueWrapper(Me.Syntax, underlyingLValue, type, Me.HasErrors) 426Dim result = New BoundWithLValueExpressionPlaceholder(Me.Syntax, type, Me.HasErrors) 459Dim result = New BoundWithRValueExpressionPlaceholder(Me.Syntax, type, Me.HasErrors) 499Dim result = New BoundRValuePlaceholder(Me.Syntax, type, Me.HasErrors) 539Dim result = New BoundLValuePlaceholder(Me.Syntax, type, Me.HasErrors) 575Dim result = New BoundDup(Me.Syntax, isReference, type, Me.HasErrors) 631Dim result = New BoundBadExpression(Me.Syntax, resultKind, symbols, childBoundNodes, type, Me.HasErrors) 665Dim result = New BoundBadStatement(Me.Syntax, childBoundNodes, Me.HasErrors) 704Dim result = New BoundParenthesized(Me.Syntax, expression, type, Me.HasErrors) 746Dim result = New BoundBadVariable(Me.Syntax, expression, isLValue, type, Me.HasErrors) 803Dim result = New BoundArrayAccess(Me.Syntax, expression, indices, isLValue, type, Me.HasErrors) 838Dim result = New BoundArrayLength(Me.Syntax, expression, type, Me.HasErrors) 873Dim result = New BoundGetType(Me.Syntax, sourceType, type, Me.HasErrors) 917Dim result = New BoundFieldInfo(Me.Syntax, field, type, Me.HasErrors) 961Dim result = New BoundMethodInfo(Me.Syntax, method, type, Me.HasErrors) 1003Dim result = New BoundTypeExpression(Me.Syntax, unevaluatedReceiverOpt, aliasOpt, type, Me.HasErrors) 1045Dim result = New BoundTypeOrValueExpression(Me.Syntax, data, type, Me.HasErrors) 1100Dim result = New BoundNamespaceExpression(Me.Syntax, unevaluatedReceiverOpt, aliasOpt, namespaceSymbol, Me.HasErrors) 1144Dim result = New BoundMethodDefIndex(Me.Syntax, method, type, Me.HasErrors) 1177Dim result = New BoundMaximumMethodDefIndex(Me.Syntax, type, Me.HasErrors) 1228Dim result = New BoundInstrumentationPayloadRoot(Me.Syntax, analysisKind, isLValue, type, Me.HasErrors) 1270Dim result = New BoundModuleVersionId(Me.Syntax, isLValue, type, Me.HasErrors) 1303Dim result = New BoundModuleVersionIdString(Me.Syntax, type, Me.HasErrors) 1347Dim result = New BoundSourceDocumentIndex(Me.Syntax, document, type, Me.HasErrors) 1411Dim result = New BoundUnaryOperator(Me.Syntax, operatorKind, operand, checked, constantValueOpt, type, Me.HasErrors) 1459Dim result = New BoundUserDefinedUnaryOperator(Me.Syntax, operatorKind, underlyingExpression, type, Me.HasErrors) 1499Dim result = New BoundNullableIsTrueOperator(Me.Syntax, operand, type, Me.HasErrors) 1572Dim result = New BoundBinaryOperator(Me.Syntax, operatorKind, left, right, checked, constantValueOpt, type, Me.HasErrors) 1628Dim result = New BoundUserDefinedBinaryOperator(Me.Syntax, operatorKind, underlyingExpression, checked, type, Me.HasErrors) 1692Dim result = New BoundUserDefinedShortCircuitingOperator(Me.Syntax, leftOperand, leftOperandPlaceholder, leftTest, bitwiseOperator, type, Me.HasErrors) 1725Dim result = New BoundCompoundAssignmentTargetPlaceholder(Me.Syntax, type, Me.HasErrors) 1790Dim result = New BoundAssignmentOperator(Me.Syntax, left, leftOnTheRightOpt, right, suppressObjectClone, type, Me.HasErrors) 1846Dim result = New BoundReferenceAssignment(Me.Syntax, byRefLocal, lValue, isLValue, type, Me.HasErrors) 1897Dim result = New BoundAddressOfOperator(Me.Syntax, binder, withDependencies, methodGroup, Me.HasErrors) 1963Dim result = New BoundTernaryConditionalExpression(Me.Syntax, condition, whenTrue, whenFalse, constantValueOpt, type, Me.HasErrors) 2036Dim result = New BoundBinaryConditionalExpression(Me.Syntax, testExpression, convertedTestExpression, testExpressionPlaceholder, elseExpression, constantValueOpt, type, Me.HasErrors) 2135Dim result = New BoundConversion(Me.Syntax, operand, conversionKind, checked, explicitCastInCode, constantValueOpt, extendedInfoOpt, type, Me.HasErrors) 2190Dim result = New BoundRelaxationLambda(Me.Syntax, lambda, receiverPlaceholderOpt, Me.HasErrors) 2238Dim result = New BoundConvertedTupleElements(Me.Syntax, elementPlaceholders, convertedElements, Me.HasErrors) 2286Dim result = New BoundUserDefinedConversion(Me.Syntax, underlyingExpression, inOutConversionFlags, type, Me.HasErrors) 2358Dim result = New BoundDirectCast(Me.Syntax, operand, conversionKind, suppressVirtualCalls, constantValueOpt, relaxationLambdaOpt, type, Me.HasErrors) 2422Dim result = New BoundTryCast(Me.Syntax, operand, conversionKind, constantValueOpt, relaxationLambdaOpt, type, Me.HasErrors) 2474Dim result = New BoundTypeOf(Me.Syntax, operand, isTypeOfIsNotExpression, targetType, type, Me.HasErrors) 2518Dim result = New BoundSequencePoint(Me.Syntax, statementOpt, Me.HasErrors) 2552Dim result = New BoundSequencePointExpression(Me.Syntax, expression, type, Me.HasErrors) 2591Dim result = New BoundSequencePointWithSpan(Me.Syntax, statementOpt, span, Me.HasErrors) 2627Dim result = New BoundNoOpStatement(Me.Syntax, flavor, Me.HasErrors) 2710Dim result = New BoundMethodGroup(Me.Syntax, typeArgumentsOpt, methods, pendingExtensionMethodsOpt, resultKind, receiverOpt, qualificationKind, Me.HasErrors) 2752Dim result = New BoundPropertyGroup(Me.Syntax, properties, resultKind, receiverOpt, qualificationKind, Me.HasErrors) 2804Dim result = New BoundReturnStatement(Me.Syntax, expressionOpt, functionLocalOpt, exitLabelOpt, Me.HasErrors) 2843Dim result = New BoundYieldStatement(Me.Syntax, expression, Me.HasErrors) 2874Dim result = New BoundThrowStatement(Me.Syntax, expressionOpt, Me.HasErrors) 2908Dim result = New BoundRedimStatement(Me.Syntax, clauses, Me.HasErrors) 2972Dim result = New BoundRedimClause(Me.Syntax, operand, indices, arrayTypeOpt, preserve, Me.HasErrors) 3006Dim result = New BoundEraseStatement(Me.Syntax, clauses, Me.HasErrors) 3103Dim result = New BoundCall(Me.Syntax, method, methodGroupOpt, receiverOpt, arguments, defaultArguments, constantValueOpt, isLValue, suppressObjectClone, type, Me.HasErrors) 3171Dim result = New BoundAttribute(Me.Syntax, constructor, constructorArguments, constructorDefaultArguments, namedArguments, resultKind, type, Me.HasErrors) 3242Dim result = New BoundLateMemberAccess(Me.Syntax, nameOpt, containerTypeOpt, receiverOpt, typeArgumentsOpt, accessKind, type, Me.HasErrors) 3314Dim result = New BoundLateInvocation(Me.Syntax, member, argumentsOpt, argumentNamesOpt, accessKind, methodOrPropertyGroupOpt, type, Me.HasErrors) 3357Dim result = New BoundLateAddressOfOperator(Me.Syntax, binder, memberAccess, type, Me.HasErrors) 3427Dim result = New BoundTupleLiteral(Me.Syntax, inferredType, argumentNamesOpt, inferredNamesOpt, arguments, type, Me.HasErrors) 3462Dim result = New BoundConvertedTupleLiteral(Me.Syntax, naturalTypeOpt, arguments, type, Me.HasErrors) 3551Dim result = New BoundObjectCreationExpression(Me.Syntax, constructorOpt, methodGroupOpt, arguments, defaultArguments, initializerOpt, type, Me.HasErrors) 3585Dim result = New BoundNoPiaObjectCreationExpression(Me.Syntax, guidString, initializerOpt, type, Me.HasErrors) 3636Dim result = New BoundAnonymousTypeCreationExpression(Me.Syntax, binderOpt, declarations, arguments, type, Me.HasErrors) 3687Dim result = New BoundAnonymousTypePropertyAccess(Me.Syntax, binder, propertyIndex, type, Me.HasErrors) 3730Dim result = New BoundAnonymousTypeFieldInitializer(Me.Syntax, binder, value, type, Me.HasErrors) 3797Dim result = New BoundObjectInitializerExpression(Me.Syntax, createTemporaryLocalForInitialization, placeholderOpt, initializers, type, Me.HasErrors) 3828Dim result = New BoundCollectionInitializerExpression(Me.Syntax, placeholderOpt, initializers, type, Me.HasErrors) 3859Dim result = New BoundNewT(Me.Syntax, initializerOpt, type, Me.HasErrors) 3926Dim result = New BoundDelegateCreationExpression(Me.Syntax, receiverOpt, method, relaxationLambdaOpt, relaxationReceiverPlaceholderOpt, methodGroupOpt, type, Me.HasErrors) 3998Dim result = New BoundArrayCreation(Me.Syntax, isParamArrayArgument, bounds, initializerOpt, arrayLiteralOpt, arrayLiteralConversion, type, Me.HasErrors) 4075Dim result = New BoundArrayLiteral(Me.Syntax, hasDominantType, numberOfCandidates, inferredType, bounds, initializer, binder, Me.HasErrors) 4109Dim result = New BoundArrayInitialization(Me.Syntax, initializers, type, Me.HasErrors) 4181Dim result = New BoundFieldAccess(Me.Syntax, receiverOpt, fieldSymbol, isLValue, suppressVirtualCalls, constantsInProgressOpt, type, Me.HasErrors) 4278Dim result = New BoundPropertyAccess(Me.Syntax, propertySymbol, propertyGroupOpt, accessKind, isWriteable, isLValue, receiverOpt, arguments, defaultArguments, type, Me.HasErrors) 4321Dim result = New BoundEventAccess(Me.Syntax, receiverOpt, eventSymbol, type, Me.HasErrors) 4372Dim result = New BoundBlock(Me.Syntax, statementListSyntax, locals, statements, Me.HasErrors) 4415Dim result = New BoundStateMachineScope(Me.Syntax, fields, statement, Me.HasErrors) 4491Dim result = New BoundLocalDeclaration(Me.Syntax, localSymbol, declarationInitializerOpt, identifierInitializerOpt, initializedByAsNew, Me.HasErrors) 4543Dim result = New BoundAsNewLocalDeclarations(Me.Syntax, localDeclarations, initializer, binder, Me.HasErrors) 4585Dim result = New BoundDimStatement(Me.Syntax, localDeclarations, initializerOpt, Me.HasErrors) 4682Dim result = New BoundFieldInitializer(Me.Syntax, initializedFields, memberAccessExpressionOpt, initialValue, binderOpt, Me.HasErrors) 4717Dim result = New BoundPropertyInitializer(Me.Syntax, initializedProperties, memberAccessExpressionOpt, initialValue, binderOpt, Me.HasErrors) 4760Dim result = New BoundParameterEqualsValue(Me.Syntax, parameter, value, Me.HasErrors) 4794Dim result = New BoundGlobalStatementInitializer(Me.Syntax, statement, Me.HasErrors) 4851Dim result = New BoundSequence(Me.Syntax, locals, sideEffects, valueOpt, type, Me.HasErrors) 4885Dim result = New BoundExpressionStatement(Me.Syntax, expression, Me.HasErrors) 4936Dim result = New BoundIfStatement(Me.Syntax, condition, consequence, alternativeOpt, Me.HasErrors) 5004Dim result = New BoundSelectStatement(Me.Syntax, expressionStatement, exprPlaceholderOpt, caseBlocks, recommendSwitchTable, exitLabel, Me.HasErrors) 5047Dim result = New BoundCaseBlock(Me.Syntax, caseStatement, body, Me.HasErrors) 5089Dim result = New BoundCaseStatement(Me.Syntax, caseClauses, conditionOpt, Me.HasErrors) 5155Dim result = New BoundSimpleCaseClause(Me.Syntax, valueOpt, conditionOpt, Me.HasErrors) 5215Dim result = New BoundRangeCaseClause(Me.Syntax, lowerBoundOpt, upperBoundOpt, lowerBoundConditionOpt, upperBoundConditionOpt, Me.HasErrors) 5251Dim result = New BoundRelationalCaseClause(Me.Syntax, operatorKind, valueOpt, conditionOpt, Me.HasErrors) 5358Dim result = New BoundDoLoopStatement(Me.Syntax, topConditionOpt, bottomConditionOpt, topConditionIsUntil, bottomConditionIsUntil, body, continueLabel, exitLabel, Me.HasErrors) 5403Dim result = New BoundWhileStatement(Me.Syntax, condition, body, continueLabel, exitLabel, Me.HasErrors) 5534Dim result = New BoundForToUserDefinedOperators(Me.Syntax, leftOperandPlaceholder, rightOperandPlaceholder, addition, subtraction, lessThanOrEqual, greaterThanOrEqual, Me.HasErrors) 5606Dim result = New BoundForToStatement(Me.Syntax, initialValue, limitValue, stepValue, checked, operatorsOpt, declaredOrInferredLocalOpt, controlVariable, body, nextVariablesOpt, continueLabel, exitLabel, Me.HasErrors) 5653Dim result = New BoundForEachStatement(Me.Syntax, collection, enumeratorInfo, declaredOrInferredLocalOpt, controlVariable, body, nextVariablesOpt, continueLabel, exitLabel, Me.HasErrors) 5695Dim result = New BoundExitStatement(Me.Syntax, label, Me.HasErrors) 5737Dim result = New BoundContinueStatement(Me.Syntax, label, Me.HasErrors) 5796Dim result = New BoundTryStatement(Me.Syntax, tryBlock, catchBlocks, finallyBlockOpt, exitLabelOpt, Me.HasErrors) 5870Dim result = New BoundCatchBlock(Me.Syntax, localOpt, exceptionSourceOpt, errorLineNumberOpt, exceptionFilterOpt, body, isSynthesizedAsyncCatchAll, Me.HasErrors) 5919Dim result = New BoundLiteral(Me.Syntax, value, type, Me.HasErrors) 5952Dim result = New BoundMeReference(Me.Syntax, type, Me.HasErrors) 5992Dim result = New BoundValueTypeMeReference(Me.Syntax, type, Me.HasErrors) 6025Dim result = New BoundMyBaseReference(Me.Syntax, type, Me.HasErrors) 6058Dim result = New BoundMyClassReference(Me.Syntax, type, Me.HasErrors) 6102Dim result = New BoundPreviousSubmissionReference(Me.Syntax, sourceType, type, Me.HasErrors) 6135Dim result = New BoundHostObjectMemberReference(Me.Syntax, type, Me.HasErrors) 6195Dim result = New BoundLocal(Me.Syntax, localSymbol, isLValue, type, Me.HasErrors) 6259Dim result = New BoundPseudoVariable(Me.Syntax, localSymbol, isLValue, emitExpressions, type, Me.HasErrors) 6321Dim result = New BoundParameter(Me.Syntax, parameterSymbol, isLValue, suppressVirtualCalls, type, Me.HasErrors) 6363Dim result = New BoundByRefArgumentPlaceholder(Me.Syntax, isOut, type, Me.HasErrors) 6438Dim result = New BoundByRefArgumentWithCopyBack(Me.Syntax, originalArgument, inConversion, inPlaceholder, outConversion, outPlaceholder, type, Me.HasErrors) 6486Dim result = New BoundLateBoundArgumentSupportingAssignmentWithCapture(Me.Syntax, originalArgument, localSymbol, type, Me.HasErrors) 6528Dim result = New BoundLabelStatement(Me.Syntax, label, Me.HasErrors) 6570Dim result = New BoundLabel(Me.Syntax, label, type, Me.HasErrors) 6612Dim result = New BoundGotoStatement(Me.Syntax, label, labelExpressionOpt, Me.HasErrors) 6646Dim result = New BoundStatementList(Me.Syntax, statements, Me.HasErrors) 6697Dim result = New BoundConditionalGoto(Me.Syntax, condition, jumpIfTrue, label, Me.HasErrors) 6749Dim result = New BoundWithStatement(Me.Syntax, originalExpression, body, binder, Me.HasErrors) 6838Dim result = New UnboundLambda(Me.Syntax, binder, flags, parameters, returnType, bindingCache, Me.HasErrors) 6918Dim result = New BoundLambda(Me.Syntax, lambdaSymbol, body, diagnostics, lambdaBinderOpt, delegateRelaxation, methodConversionKind, Me.HasErrors) 6953Dim result = New BoundQueryExpression(Me.Syntax, lastOperator, type, Me.HasErrors) 7007Dim result = New BoundQuerySource(Me.Syntax, expression, type, Me.HasErrors) 7042Dim result = New BoundToQueryableCollectionConversion(Me.Syntax, conversionCall, type, Me.HasErrors) 7145Dim result = New BoundQueryableSource(Me.Syntax, source, rangeVariableOpt, rangeVariables, compoundVariableType, binders, type, Me.HasErrors) 7183Dim result = New BoundQueryClause(Me.Syntax, underlyingExpression, rangeVariables, compoundVariableType, binders, type, Me.HasErrors) 7218Dim result = New BoundOrdering(Me.Syntax, underlyingExpression, type, Me.HasErrors) 7278Dim result = New BoundQueryLambda(Me.Syntax, lambdaSymbol, rangeVariables, expression, exprIsOperandOfConditionalBranch, Me.HasErrors) 7322Dim result = New BoundRangeVariableAssignment(Me.Syntax, rangeVariable, value, type, Me.HasErrors) 7386Dim result = New GroupTypeInferenceLambda(Me.Syntax, binder, parameters, compilation, Me.HasErrors) 7440Dim result = New BoundAggregateClause(Me.Syntax, capturedGroupOpt, groupPlaceholderOpt, underlyingExpression, rangeVariables, compoundVariableType, binders, type, Me.HasErrors) 7475Dim result = New BoundGroupAggregation(Me.Syntax, group, type, Me.HasErrors) 7519Dim result = New BoundRangeVariable(Me.Syntax, rangeVariable, type, Me.HasErrors) 7575Dim result = New BoundAddHandlerStatement(Me.Syntax, eventAccess, handler, Me.HasErrors) 7602Dim result = New BoundRemoveHandlerStatement(Me.Syntax, eventAccess, handler, Me.HasErrors) 7645Dim result = New BoundRaiseEventStatement(Me.Syntax, eventSymbol, eventInvocation, Me.HasErrors) 7713Dim result = New BoundUsingStatement(Me.Syntax, resourceList, resourceExpressionOpt, body, usingInfo, locals, Me.HasErrors) 7756Dim result = New BoundSyncLockStatement(Me.Syntax, lockExpression, body, Me.HasErrors) 7809Dim result = New BoundXmlName(Me.Syntax, xmlNamespace, localName, objectCreation, type, Me.HasErrors) 7853Dim result = New BoundXmlNamespace(Me.Syntax, xmlNamespace, objectCreation, type, Me.HasErrors) 7906Dim result = New BoundXmlDocument(Me.Syntax, declaration, childNodes, rewriterInfo, type, Me.HasErrors) 7965Dim result = New BoundXmlDeclaration(Me.Syntax, version, encoding, standalone, objectCreation, type, Me.HasErrors) 8018Dim result = New BoundXmlProcessingInstruction(Me.Syntax, target, data, objectCreation, type, Me.HasErrors) 8062Dim result = New BoundXmlComment(Me.Syntax, value, objectCreation, type, Me.HasErrors) 8128Dim result = New BoundXmlAttribute(Me.Syntax, name, value, matchesImport, objectCreation, type, Me.HasErrors) 8181Dim result = New BoundXmlElement(Me.Syntax, argument, childNodes, rewriterInfo, type, Me.HasErrors) 8216Dim result = New BoundXmlMemberAccess(Me.Syntax, memberAccess, type, Me.HasErrors) 8251Dim result = New BoundXmlEmbeddedExpression(Me.Syntax, expression, type, Me.HasErrors) 8295Dim result = New BoundXmlCData(Me.Syntax, value, objectCreation, type, Me.HasErrors) 8347Dim result = New BoundResumeStatement(Me.Syntax, resumeKind, labelOpt, labelExpressionOpt, Me.HasErrors) 8399Dim result = New BoundOnErrorStatement(Me.Syntax, onErrorKind, labelOpt, labelExpressionOpt, Me.HasErrors) 8470Dim result = New BoundUnstructuredExceptionHandlingStatement(Me.Syntax, containsOnError, containsResume, resumeWithoutLabelOpt, trackLineNumber, body, Me.HasErrors) 8519Dim result = New BoundUnstructuredExceptionHandlingCatchFilter(Me.Syntax, activeHandlerLocal, resumeTargetLocal, type, Me.HasErrors) 8567Dim result = New BoundUnstructuredExceptionOnErrorSwitch(Me.Syntax, value, jumps, Me.HasErrors) 8633Dim result = New BoundUnstructuredExceptionResumeSwitch(Me.Syntax, resumeTargetTemporary, resumeLabel, resumeNextLabel, jumps, Me.HasErrors) 8718Dim result = New BoundAwaitOperator(Me.Syntax, operand, awaitableInstancePlaceholder, getAwaiter, awaiterInstancePlaceholder, isCompleted, getResult, type, Me.HasErrors) 8783Dim result = New BoundSpillSequence(Me.Syntax, locals, spillFields, statements, valueOpt, type, Me.HasErrors) 8885Dim result = New BoundMidResult(Me.Syntax, original, start, lengthOpt, source, type, Me.HasErrors) 8937Dim result = New BoundConditionalAccess(Me.Syntax, receiver, placeholder, accessExpression, type, Me.HasErrors) 8986Dim result = New BoundConditionalAccessReceiverPlaceholder(Me.Syntax, placeholderId, type, Me.HasErrors) 9059Dim result = New BoundLoweredConditionalAccess(Me.Syntax, receiverOrCondition, captureReceiver, placeholderId, whenNotNull, whenNullOpt, type, Me.HasErrors) 9108Dim result = New BoundComplexConditionalAccessReceiver(Me.Syntax, valueTypeReceiver, referenceTypeReceiver, type, Me.HasErrors) 9156Dim result = New BoundNameOfOperator(Me.Syntax, argument, constantValueOpt, type, Me.HasErrors) 9196Dim result = New BoundTypeAsValueExpression(Me.Syntax, expression, type, Me.HasErrors) 9245Dim result = New BoundInterpolatedStringExpression(Me.Syntax, contents, binder, type, Me.HasErrors) 9295Dim result = New BoundInterpolation(Me.Syntax, expression, alignmentOpt, formatStringOpt, Me.HasErrors)

33Debug.Assert(node.Syntax.IsKind(SyntaxKind.AwaitExpression)) 35Dim awaiterTemp As LocalSymbol = Me.F.SynthesizedLocal(awaiterType, kind:=SynthesizedLocalKind.Awaiter, syntax:=node.Syntax)

197Dim block As MethodBlockSyntax = TryCast(body.Syntax, MethodBlockSyntax)

76Binder.ReportDiagnostic(Me._diagnostics, node.Syntax, ERRID.ERR_CannotLiftByRefParamQuery1, parameterSymbol.Name) 78Binder.ReportDiagnostic(Me._diagnostics, node.Syntax, ERRID.ERR_CannotLiftByRefParamLambda1, parameterSymbol.Name) 90Binder.ReportDiagnostic(Me._diagnostics, node.Syntax, errorId) 100Binder.ReportDiagnostic(Me._diagnostics, node.Syntax, errorId) 146Dim errorSyntax As SyntaxNode = node.Syntax 149If expr.Syntax IsNot errorSyntax Then 150errorSyntax = expr.Syntax

402Me._diagnostics.Add(New VBDiagnostic(ErrorFactory.ErrorInfo(code), node.Syntax.GetLocation()))

108Dim r As New ExpressionLambdaRewriter(currentMethod, compilationState, typeMap, node.LambdaSymbol.ContainingBinder, node.Syntax, recursionDepth, diagnostics) 181Me.Diagnostics.Add(New VBDiagnostic(ErrorFactory.ErrorInfo(code, args), node.Syntax.GetLocation())) 194_factory.Syntax = node.Syntax 459receiverOpt = New BoundMeReference(receiverOpt.Syntax, method.ContainingType) 687node.Syntax,

654Return New BoundConversion(oldArg.Syntax, oldArg, ConversionKind.NarrowingNullable, False, False, parameterType)

137Dim syntax As SyntaxNode = expression.Syntax

50If Not HasValidMappedLineSpan(methodBody.Syntax) Then 62methodBody.Syntax, 68methodBody.Syntax, 121_methodPayload = methodBodyFactory.SynthesizedLocal(_payloadType, kind:=SynthesizedLocalKind.InstrumentationPayload, syntax:=methodBody.Syntax) 127Dim bodySyntax As SyntaxNode = methodBody.Syntax 272_methodBody.Syntax, 430Dim statementFactory As New SyntheticBoundNodeFactory(_methodBodyFactory.TopLevelMethod, _method, original.Syntax, _methodBodyFactory.CompilationState, _diagnostics) 480Return DirectCast(statement, BoundIfStatement).Condition.Syntax 482Return DirectCast(statement, BoundWhileStatement).Condition.Syntax 484Return DirectCast(statement, BoundForToStatement).InitialValue.Syntax 486Return DirectCast(statement, BoundForEachStatement).Collection.Syntax 488Return DirectCast(statement, BoundDoLoopStatement).ConditionOpt.Syntax 491Return If(usingStatement.ResourceExpressionOpt, DirectCast(usingStatement, BoundNode)).Syntax 493Return DirectCast(statement, BoundSyncLockStatement).LockExpression.Syntax 495Return DirectCast(statement, BoundSelectStatement).ExpressionStatement.Expression.Syntax 499Return initializer.Syntax 502Dim equalsValue = TryCast(statement.Syntax, EqualsValueSyntax) 506Dim asNew = TryCast(statement.Syntax, AsNewClauseSyntax) 512Return statement.Syntax

33Return New BoundSequencePoint(original.Syntax, rewritten) 98Return New BoundSequencePointExpression(original.Syntax, rewritten, rewritten.Type) 109Dim aggregateClause = DirectCast(original.Syntax.Parent.Parent, AggregateClauseSyntax) 135Debug.Assert(original.Syntax.Parent.IsKind(SyntaxKind.ExpressionRangeVariable)) 137createSequencePoint = original.Syntax 138sequencePointSpan = TextSpan.FromBounds(original.Syntax.SpanStart, original.Syntax.Span.End) 154Return New BoundSequencePoint(DirectCast(original.Syntax, DoLoopBlockSyntax).LoopStatement, MyBase.InstrumentDoLoopEpilogue(original, epilogueOpt)) 160Return New BoundSequencePoint(DirectCast(original.Syntax, SyncLockBlockSyntax).SyncLockStatement, MyBase.CreateSyncLockStatementPrologue(original)) 164Return New BoundSequencePoint(original.LockExpression.Syntax, MyBase.InstrumentSyncLockObjectCapture(original, rewritten)) 169Return New BoundSequencePoint(DirectCast(original.Syntax, SyncLockBlockSyntax).EndSyncLockStatement, MyBase.CreateSyncLockExitDueToExceptionEpilogue(original)) 175Return New BoundSequencePoint(DirectCast(original.Syntax, SyncLockBlockSyntax).EndSyncLockStatement, MyBase.CreateSyncLockExitNormallyEpilogue(original)) 179Return New BoundSequencePoint(DirectCast(original.Syntax, WhileBlockSyntax).EndWhileStatement, MyBase.InstrumentWhileEpilogue(original, epilogueOpt)) 183Return New BoundSequencePoint(DirectCast(original.Syntax, WhileBlockSyntax).WhileStatement, 188Return New BoundSequencePoint(DirectCast(original.Syntax, DoLoopBlockSyntax).DoStatement, 200Select Case original.Syntax.Kind 202Dim asMultiline = DirectCast(original.Syntax, MultiLineIfBlockSyntax) 205Dim asElseIfBlock = DirectCast(original.Syntax, ElseIfBlockSyntax) 208Dim asSingleLine = DirectCast(original.Syntax, SingleLineIfStatementSyntax) 217Return New BoundSequencePoint(DirectCast(original.Syntax, MultiLineIfBlockSyntax).EndIfStatement, 225Select Case original.Syntax.Kind 227syntax = DirectCast(original.Syntax, MultiLineIfBlockSyntax).EndIfStatement 229syntax = DirectCast(original.Syntax.Parent, MultiLineIfBlockSyntax).EndIfStatement 239Return New BoundSequencePoint(DirectCast(original.AlternativeOpt.Syntax.Parent, MultiLineIfBlockSyntax).EndIfStatement, 246Select Case original.AlternativeOpt.Syntax.Kind 248prologue = New BoundSequencePoint(DirectCast(original.AlternativeOpt.Syntax, ElseBlockSyntax).ElseStatement, prologue) 250prologue = New BoundSequencePointWithSpan(original.AlternativeOpt.Syntax, prologue, 251DirectCast(original.AlternativeOpt.Syntax, SingleLineElseClauseSyntax).ElseKeyword.Span) 286rewrittenFilter = New BoundSequencePointExpression(DirectCast(original.Syntax, CatchBlockSyntax).CatchStatement, 297Return New BoundSequencePoint(original.ExpressionStatement.Syntax, MyBase.CreateSelectStatementPrologue(original)) 306Return New BoundSequencePoint(original.CaseStatement.Syntax, MyBase.InstrumentCaseBlockConditionalGoto(original, condGoto)) 310Return New BoundSequencePoint(original.CaseStatement.Syntax, MyBase.InstrumentCaseElseBlock(original, rewritten)) 315Return New BoundSequencePoint(DirectCast(original.Syntax, SelectBlockSyntax).EndSelectStatement, MyBase.InstrumentSelectStatementEpilogue(original, epilogueOpt)) 319Return New BoundSequencePoint(DirectCast(original.Syntax, CatchBlockSyntax).CatchStatement, MyBase.CreateCatchBlockPrologue(original)) 323Return New BoundSequencePoint(DirectCast(original.FinallyBlockOpt.Syntax, FinallyBlockSyntax).FinallyStatement, MyBase.CreateFinallyBlockPrologue(original)) 327Return New BoundSequencePoint(DirectCast(original.Syntax, TryBlockSyntax).TryStatement, MyBase.CreateTryBlockPrologue(original)) 333Return New BoundStatementList(original.Syntax, 336New BoundSequencePoint(DirectCast(original.Syntax, TryBlockSyntax).EndTryStatement, Nothing) 345rewritten = MarkInitializerSequencePoint(rewritten, original.Syntax, symbolIndex) 353Return New BoundSequencePoint(DirectCast(original.Syntax, ForEachBlockSyntax).ForEachStatement, 359Dim nextStmt = DirectCast(original.Syntax, ForEachBlockSyntax).NextStatement 362epilogueOpt = New BoundSequencePoint(DirectCast(original.Syntax, ForEachBlockSyntax).NextStatement, epilogueOpt) 370Return New BoundSequencePoint(DirectCast(original.Syntax, ForBlockSyntax).ForStatement, MyBase.InstrumentForLoopInitialization(original, initialization)) 375Dim nextStmt = DirectCast(original.Syntax, ForBlockSyntax).NextStatement 378increment = New BoundSequencePoint(DirectCast(original.Syntax, ForBlockSyntax).NextStatement, increment) 385Return MarkInitializerSequencePoint(MyBase.InstrumentLocalInitialization(original, rewritten), original.Syntax) 403syntaxForSequencePoint = localDeclaration.Syntax.Parent 406syntaxForSequencePoint = localDeclaration.Syntax 419Return New BoundSequencePoint(DirectCast(original.Syntax, UsingBlockSyntax).EndUsingStatement, MyBase.CreateUsingStatementDisposePrologue(original)) 423Return New BoundSequencePoint(DirectCast(original.Syntax, WithBlockSyntax).WithStatement, MyBase.CreateWithStatementPrologue(original)) 427Return New BoundSequencePoint(DirectCast(original.Syntax, WithBlockSyntax).EndWithStatement, MyBase.CreateWithStatementEpilogue(original))

13Debug.Assert(containingCatchWithFilter.ExceptionFilterOpt.Syntax.Parent.IsKind(SyntaxKind.CatchFilterClause)) 15Return AddConditionSequencePoint(condition, containingCatchWithFilter.ExceptionFilterOpt.Syntax.Parent, currentMethodOrLambda, local, shareLocal:=False) 20Return AddConditionSequencePoint(condition, containingStatement.Syntax, currentMethodOrLambda, local, shareLocal:=False) 29Return AddConditionSequencePoint(condition, containingStatement.Syntax, currentMethodOrLambda, lazyConditionalBranchLocal, shareLocal:=True) 41Dim conditionSyntax = condition.Syntax 88Dim asMethod = TryCast(node.Syntax, MethodBlockBaseSyntax) 109Dim asLambda = TryCast(node.Syntax, LambdaExpressionSyntax)

75original.Syntax Is original.ExpressionOpt.Syntax)) 124Debug.Assert(DirectCast(original.Syntax, DoLoopBlockSyntax).LoopStatement IsNot Nothing) 133Debug.Assert(original.Syntax.Kind = SyntaxKind.SyncLockBlock) 139Debug.Assert(original.Syntax.Kind = SyntaxKind.SyncLockBlock) 148Debug.Assert(original.Syntax.Kind = SyntaxKind.SyncLockBlock) 157Debug.Assert(original.Syntax.Kind = SyntaxKind.SyncLockBlock) 166Debug.Assert(original.Syntax.Kind = SyntaxKind.WhileBlock) 172Debug.Assert(original.Syntax.Kind = SyntaxKind.WhileBlock) 181Debug.Assert(TypeOf original.Syntax Is DoLoopBlockSyntax) 187Debug.Assert(original.Syntax.Kind = SyntaxKind.ForEachBlock) 193Debug.Assert(original.Syntax.Kind = SyntaxKind.MultiLineIfBlock OrElse original.Syntax.Kind = SyntaxKind.ElseIfBlock OrElse original.Syntax.Kind = SyntaxKind.SingleLineIfStatement) 199Debug.Assert(original.Syntax.Kind = SyntaxKind.MultiLineIfBlock) 208Debug.Assert(original.Syntax.Kind = SyntaxKind.MultiLineIfBlock OrElse original.Syntax.Kind = SyntaxKind.ElseIfBlock OrElse original.Syntax.Kind = SyntaxKind.SingleLineIfStatement) 217Debug.Assert(original.AlternativeOpt.Syntax.Kind = SyntaxKind.ElseBlock) 218Debug.Assert(original.AlternativeOpt.Syntax.Parent.Kind = SyntaxKind.MultiLineIfBlock) 227Debug.Assert(original.AlternativeOpt.Syntax.Kind = SyntaxKind.ElseBlock OrElse original.AlternativeOpt.Syntax.Kind = SyntaxKind.SingleLineElseClause) 263Debug.Assert(original.Syntax.Kind = SyntaxKind.CatchBlock) 265Debug.Assert(original.ExceptionFilterOpt.Syntax.Parent.IsKind(SyntaxKind.CatchFilterClause)) 276Debug.Assert(original.Syntax.Kind = SyntaxKind.CatchBlock) 286Debug.Assert(original.Syntax.Kind = SyntaxKind.TryBlock) 288Debug.Assert(original.FinallyBlockOpt.Syntax.Kind = SyntaxKind.FinallyBlock) 297Debug.Assert(original.Syntax.Kind = SyntaxKind.TryBlock) 303Debug.Assert(original.Syntax.Kind = SyntaxKind.TryBlock) 336Debug.Assert(original.Syntax.Kind = SyntaxKind.SelectBlock) 342Debug.Assert(original.Syntax.IsKind(SyntaxKind.AsNewClause) OrElse ' Dim a As New C(); Dim a,b As New C(); Property P As New C() 343original.Syntax.IsKind(SyntaxKind.ModifiedIdentifier) OrElse ' Dim a(1) As Integer 344original.Syntax.IsKind(SyntaxKind.EqualsValue)) ' Dim a = 1; Property P As Integer = 1 350Debug.Assert(original.Syntax.Kind = SyntaxKind.ForEachBlock) 360Debug.Assert(original.Syntax.Kind = SyntaxKind.ForEachBlock) 366Debug.Assert(original.Syntax.Kind = SyntaxKind.ForBlock) 372Debug.Assert(original.Syntax.Kind = SyntaxKind.ForBlock) 378Debug.Assert(original.Syntax.Kind = SyntaxKind.ModifiedIdentifier) 379Debug.Assert(original.Syntax.Parent.Kind = SyntaxKind.VariableDeclarator) 388Debug.Assert(original.Syntax.Kind = SyntaxKind.UsingBlock) 394Debug.Assert(original.Syntax.Kind = SyntaxKind.UsingBlock) 403Debug.Assert(original.Syntax.Kind = SyntaxKind.UsingBlock) 412Debug.Assert(original.Syntax.Kind = SyntaxKind.WithBlock) 421Debug.Assert(original.Syntax.Kind = SyntaxKind.WithBlock)

195AddResumableState(node.Syntax, stateNumber, resumeLabel) 198node.Syntax,

467ReferenceVariable(Me._method.MeParameter, node.Syntax) 472ReferenceVariable(Me._method.MeParameter, node.Syntax) 477ReferenceVariable(Me._method.MeParameter, node.Syntax) 482ReferenceVariable(node.ParameterSymbol, node.Syntax) 487ReferenceVariable(node.LocalSymbol, node.Syntax)

263Dim syntax = scope.Syntax 316_lazyStaticLambdaFrame = New LambdaFrame(_topLevelMethod, lambda.Syntax, methodId, closureId, copyConstructor:=False, isStatic:=True, isDelegateRelaxationFrame:=False) 332Dim syntax = lambda.Syntax 396Dim frame As BoundExpression = FramePointer(origExpression.Syntax, proxy.ContainingType) 398Return New BoundFieldAccess(origExpression.Syntax, 509Dim syntaxNode As SyntaxNode = node.Syntax 678Return FramePointer(node.Syntax, TryCast(node.Type, NamedTypeSymbol)) 684New BoundMyClassReference(node.Syntax, node.Type), 685FramePointer(node.Syntax, TryCast(_topLevelMethod.ContainingType, NamedTypeSymbol)))) 691New BoundMyBaseReference(node.Syntax, node.Type), 692FramePointer(node.Syntax, TryCast(_topLevelMethod.ContainingType, NamedTypeSymbol)))) 706newStatements.Add(New BoundExpressionStatement(expr.Syntax, expr)) 723Return New BoundBlock(node.Syntax, 827rewrittenExceptionSource.Syntax, 881Dim lambdaSyntax = lambda.Syntax 1065lambdaId = GetLambdaId(node.Syntax, closureKind, closureOrdinal) 1131receiver = FrameOfType(node.Syntax, constructedFrame) 1134receiver = New BoundFieldAccess(node.Syntax, Nothing, field, isLValue:=False, type:=field.Type) 1148node.Syntax, 1165InLoopOrLambda(node.Syntax, lambdaScope.Syntax) 1193Dim F = New SyntheticBoundNodeFactory(Me._topLevelMethod, Me._currentMethod, node.Syntax, CompilationState, Diagnostics) 1343Select Case node.Syntax.Kind 1345Me.Diagnostics.Add(ERRID.ERR_CannotGotoNonScopeBlocksWithClosure, node.Syntax.GetLocation(), 1346node.Syntax.ToString(), String.Empty, label.Name) 1348Me.Diagnostics.Add(ERRID.ERR_CannotGotoNonScopeBlocksWithClosure, node.Syntax.GetLocation(), "Goto ", label.Name, label.Name) 1352node = New BoundGotoStatement(node.Syntax, node.Label, node.LabelExpressionOpt, True)

57MyBase.New(lambdaNode.Syntax, 63Me._locations = ImmutableArray.Create(lambdaNode.Syntax.GetLocation())

200sideEffects(i) = New BoundExpressionStatement(init.Syntax, init) 204Return New BoundBlock(node.Syntax, Nothing, locals.AsImmutable, sideEffects.AsImmutableOrNull) 301node.Syntax.Kind <> SyntaxKind.GroupAggregation AndAlso 302((node.Syntax.Kind = SyntaxKind.SimpleAsClause AndAlso node.Syntax.Parent.Kind = SyntaxKind.CollectionRangeVariable) OrElse 303TypeOf node.Syntax Is ExpressionSyntax) 381Return Me.Instrument AndAlso rewritten IsNot Nothing AndAlso (Not original.WasCompilerGenerated) AndAlso original.Syntax IsNot Nothing 387Return Me.Instrument AndAlso (Not original.WasCompilerGenerated) AndAlso original.Syntax IsNot Nothing 410Return New BoundStatementList(statement.Syntax, consequenceWithEnd.AsImmutableOrNull) 437Return New BoundStatementList(statement.Syntax, ImmutableArray.Create(prologueOpt, statement)) 446block.Syntax, 655diagnostics.Add(New VBDiagnostic(diagnostic, node.Syntax.GetLocation())) 659Return diagnostics.Add(useSiteInfo, node.Syntax.GetLocation()) 720Dim localAccess = New BoundLocal(value.Syntax, local, local.Type) 723value.Syntax, 762Dim syntax = value.Syntax 833Dim nodeFactory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 855rewritten = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, rewritten, canThrow:=True) 866Dim nodeFactory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 886If Not TryGetWellknownMember(Of MethodSymbol)(Nothing, WellKnownMember.System_Type__GetTypeFromHandle, node.Syntax) Then 887Return New BoundGetType(result.Syntax, result.SourceType, result.Type, hasErrors:=True)

51result = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, result, canThrow:=True) 83Dim syntax As SyntaxNode = node.Syntax 227expr = New BoundCall(node.Syntax, 236Return New BoundExpressionStatement(node.Syntax, expr) 267Dim factory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 288_emitModule.EmbeddedTypesManagerOpt.EmbedEventIfNeedTo([event].GetCciAdapter(), node.Syntax, _diagnostics.DiagnosticBag, isUsedForComAwareEventBinding:=True) 295Return New BoundBadExpression(node.Syntax,

44Dim boundLocal = New BoundLocal(newArguments(index).Syntax, 48newArguments(index) = New BoundAssignmentOperator(newArguments(index).Syntax, boundLocal, newArguments(index), True, local.Type) 55node.Syntax, 62node.Syntax, 82Return New BoundLocal(node.Syntax, local, False, Me.VisitType(local.Type))

53Debug.Assert(node.Syntax IsNot Nothing) 54Debug.Assert(node.Syntax.Kind = SyntaxKind.VariableDeclarator) 56Dim varDecl = DirectCast(node.Syntax, VariableDeclaratorSyntax) 88VisitExpressionNode(New BoundLocal(localDeclaration.Syntax, 112Return New BoundStatementList(node.Syntax, builder.ToImmutableAndFree())

103result = New BoundSequence(node.Syntax, 109result = New BoundSequence(node.Syntax, 219Dim field = New BoundFieldAccess(setNode.Syntax, 227Return New BoundAssignmentOperator(node.Syntax, 235Return RewriteReceiverArgumentsAndGenerateAccessorCall(node.Syntax, 285result = LateSet(node.Syntax, 296result = LateSet(node.Syntax, 311result = LateIndexSet(node.Syntax, 319result = New BoundSequence(node.Syntax, 451result = New BoundCall(expression.Syntax, getObjectValueMethod, Nothing, Nothing, 485Dim midCall = New BoundCall(node.Syntax, 490If(midResult.LengthOpt, New BoundLiteral(node.Syntax, ConstantValue.Create(&H7FFFFFFF), midResult.Start.Type)), 511Dim localRef = New BoundLocal(node.Syntax, temp, node.Type) 512Dim placeholder = New BoundCompoundAssignmentTargetPlaceholder(node.Syntax, node.Type) 514Return New BoundSequence(node.Syntax, 516ImmutableArray.Create(Of BoundExpression)(New BoundAssignmentOperator(node.Syntax, 520RewriteTrivialMidAssignment(New BoundAssignmentOperator(node.Syntax,

58Dim tempAccess As New BoundLocal(node.Syntax, temp, True, temp.Type) 61New BoundAssignmentOperator(node.Syntax, 76Return New BoundSequence(node.Syntax, 79MakeTernaryConditionalExpression(node.Syntax, 205Return New BoundFieldAccess(boundCall.Syntax, 219Return New BoundFieldAccess(propertyAccess.Syntax, 490Dim compare = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 493result = New BoundBinaryOperator(node.Syntax, 496New BoundLiteral(node.Syntax, ConstantValue.Create(0I), memberSymbol.ReturnType), 529Dim compare = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 532result = New BoundBinaryOperator(node.Syntax, 535New BoundLiteral(node.Syntax, ConstantValue.Create(0I), memberSymbol.ReturnType), 593left = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 598right = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 608Dim op = New BoundBinaryOperator(node.Syntax, node.OperatorKind And BinaryOperatorKind.OpMask, left, right, False, left.Type) 611result = New BoundDirectCast(node.Syntax, op, ConversionKind.WideningValue, node.Type, Nothing) 641result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 669result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 702Dim compare = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 705New BoundLiteral(node.Syntax, ConstantValue.Create(compareText), memberSymbol.Parameters(2).Type)), 709result = New BoundBinaryOperator(node.Syntax, (node.OperatorKind And BinaryOperatorKind.OpMask), 710compare, New BoundLiteral(node.Syntax, ConstantValue.Create(0I), memberSymbol.ReturnType), 734result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 737New BoundLiteral(node.Syntax, ConstantValue.Create(compareText), memberSymbol.Parameters(2).Type)), 743result = New BoundConversion(node.Syntax, DirectCast(result, BoundExpression), ConversionKind.NarrowingBoolean, node.Checked, False, node.Type) 767result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 770New BoundLiteral(node.Syntax, ConstantValue.Create(If(compareText, 1I, 0I)), memberSymbol.Parameters(2).Type)), 792result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 919Dim operatorHasValue As BoundExpression = MakeBooleanBinaryExpression(node.Syntax, 928value = MakeTernaryConditionalExpression(node.Syntax, 931NullableNull(node.Syntax, node.Type)) 935value = New BoundSequence(node.Syntax, 999booleanResult = MakeBooleanBinaryExpression(node.Syntax, 1001MakeBooleanBinaryExpression(node.Syntax, 1003New BoundUnaryOperator(node.Syntax, 1009MakeBooleanBinaryExpression(node.Syntax, 1017booleanResult = New BoundSequence(node.Syntax, 1043Dim result = New BoundLiteral(node.Syntax, ConstantValue.False, node.Type.GetNullableUnderlyingType()) 1044Return New BoundSequence(node.Syntax, ImmutableArray(Of LocalSymbol).Empty, 1056Return New BoundNullableIsTrueOperator(operand.Syntax, operand, operand.Type.GetNullableUnderlyingType()) 1099Dim syntax = notNullOperand.Syntax 1102Return MakeTernaryConditionalExpression(node.Syntax, 1122Dim syntax = notNullOperand.Syntax 1135MakeTernaryConditionalExpression(node.Syntax, 1142result = New BoundSequence(node.Syntax, 1199Dim ConstValue As BoundExpression = NullableOfBooleanValue(node.Syntax, isOr, nullableOfBoolean) 1202Dim value As BoundExpression = MakeTernaryConditionalExpression(node.Syntax, 1239value = MakeTernaryConditionalExpression(node.Syntax, 1242NullableNull(node.Syntax, nullableOfBoolean)) 1266value = MakeTernaryConditionalExpression(node.Syntax, 1267MakeBooleanBinaryExpression(node.Syntax, 1272New BoundUnaryOperator(node.Syntax, 1277NullableOfBooleanValue(node.Syntax, isOr, nullableOfBoolean), 1301value = New BoundSequence(node.Syntax, 1330Return New BoundLiteral(operand.Syntax, 1337Return MakeSequence(operand, New BoundLiteral(operand.Syntax, 1358result = New BoundUnaryOperator(result.Syntax, 1399Dim whenHasNoValue = NullableNull(node.Syntax, resultType) 1447condition = MakeBooleanBinaryExpression(node.Syntax, BinaryOperatorKind.And, leftHasValueExpression, rightHasValueExpression) 1478Dim result As BoundExpression = MakeTernaryConditionalExpression(node.Syntax, 1485result = New BoundSequence(node.Syntax, 1507Return MakeBinaryExpression(originalOperator.Syntax,

65Return New BoundBlock(node.Syntax, node.StatementListSyntax, If(synthesizedLocal Is Nothing, node.Locals, node.Locals.Add(synthesizedLocal)), builder.ToImmutableAndFree())

25Return New BoundConversion(node.Syntax, 103Return New BoundSequence(node.Syntax, 109Return New BoundSequence(node.Syntax, 239Dim boundTemp = New BoundLocal(rewrittenArgument.Syntax, temp, temp.Type) 240Dim storeVal As BoundExpression = New BoundAssignmentOperator(rewrittenArgument.Syntax, 246Return New BoundSequence(rewrittenArgument.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(storeVal), boundTemp, rewrittenArgument.Type) 326Dim boundTemp = New BoundLocal(argument.Syntax, temp, temp.Type) 328Dim storeVal As BoundExpression = New BoundAssignmentOperator(argument.Syntax, boundTemp, inputValue, True, argument.Type) 336VisitAssignmentOperator(New BoundAssignmentOperator(argument.Syntax, secondUse, argument.OutConversion, False)), 346copyBack = LateSet(secondUse.Syntax, 357copyBack = LateSet(invocation.Syntax, 372copyBack = LateIndexSet(invocation.Syntax, 382Return New BoundSequence(argument.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(storeVal), boundTemp, argument.Type)

48Dim factory = New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 105newPlaceHolder = New BoundConditionalAccessReceiverPlaceholder(node.Placeholder.Syntax, newPlaceholderId, node.Placeholder.Type) 131whenNull = If(node.Type.IsNullableType(), NullableNull(node.Syntax, node.Type), factory.Null(node.Type)) 143result = New BoundLoweredConditionalAccess(node.Syntax, receiverOrCondition, captureReceiver, newPlaceholderId, whenNotNull, whenNull, node.Type) 155result = New BoundSequence(node.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray(Of BoundExpression).Empty, Nothing, node.Type) 160result = New BoundSequence(node.Syntax, ImmutableArray.Create(temp), ImmutableArray.Create(assignment, result), Nothing, result.Type) 162result = New BoundSequence(node.Syntax, ImmutableArray.Create(temp), ImmutableArray.Create(assignment), result, result.Type)

74placeholderSubstitute = New BoundLocal(rewrittenTestExpression.Syntax, 97New BoundAssignmentOperator(rewrittenTestExpression.Syntax, 98left:=New BoundLocal(rewrittenTestExpression.Syntax, 111New BoundTernaryConditionalExpression(node.Syntax, 122Return New BoundSequence(result.Syntax, 141rewrittenWhenTrue = New BoundConversion(rewrittenTestExpression.Syntax, 153New BoundConversion(rewrittenTestExpression.Syntax, 274Dim result As BoundExpression = MakeTernaryConditionalExpression(node.Syntax, condition, whenTrue, rewrittenRight) 278result = New BoundSequence(node.Syntax,

28Return If(node.Kind = BoundKind.Literal, node, New BoundLiteral(node.Syntax, constantValue, node.Type, hasErrors:=constantValue.IsBad)) 69Return New BoundFieldAccess(node.Syntax, Nothing, fieldSymbol, isLValue:=False, type:=fieldSymbol.Type) 94node.Syntax, 97{New BoundLiteral(node.Syntax, ConstantValue.Create(value), decCtorInt64.Parameters(0).Type)}), 123node.Syntax, 126New BoundLiteral(node.Syntax, ConstantValue.Create(UncheckedCInt(low)), decCtor.Parameters(0).Type), 127New BoundLiteral(node.Syntax, ConstantValue.Create(UncheckedCInt(mid)), decCtor.Parameters(1).Type), 128New BoundLiteral(node.Syntax, ConstantValue.Create(UncheckedCInt(high)), decCtor.Parameters(2).Type), 129New BoundLiteral(node.Syntax, ConstantValue.Create(isNegative), decCtor.Parameters(3).Type), 130New BoundLiteral(node.Syntax, ConstantValue.Create(scale), decCtor.Parameters(4).Type)), 156Return New BoundFieldAccess(node.Syntax, Nothing, dtMinValue, isLValue:=False, type:=dtMinValue.Type) 172node.Syntax, 175{New BoundLiteral(node.Syntax, ConstantValue.Create(dt.Ticks), dtCtorInt64.Parameters(0).Type)}),

15Dim boundGoto As BoundStatement = New BoundGotoStatement(node.Syntax, node.Label, Nothing) 18boundGoto = Concat(RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(node.Syntax), boundGoto)

168Dim syntax = node.Syntax 320Dim F As New SyntheticBoundNodeFactory(Me._topMethod, Me._currentMethodOrLambda, node.Syntax, Me._compilationState, Me._diagnostics) 340Dim convertedValue = New BoundDelegateCreationExpression(node.Syntax, F.Local(savedOriginalValue, False), 351Dim convertedValue = New BoundDelegateCreationExpression(node.Syntax, node.Operand, 406Return NullableNull(rewrittenOperand.Syntax, resultType) 442Return New BoundDirectCast(node.Syntax, 443MakeNullLiteral(rewrittenOperand.Syntax, resultType), 455Return New BoundDirectCast(node.Syntax, 492Return NullableNull(result.Syntax, resultType) 500NullableNull(result.Syntax, resultType)) 548operand = RewriteConstant(New BoundLiteral(node.Syntax, constantResult, unwrappedResultType), constantResult) 554operand = MakeTupleConversion(node.Syntax, operand, unwrappedResultType, DirectCast(node.ExtendedInfoOpt, BoundConvertedTupleElements)) 557operand = TransformRewrittenConversion(New BoundConversion(node.Syntax, 575operand = MakeTernaryConditionalExpression(node.Syntax, 578NullableNull(operand.Syntax, resultType)) 582operand = New BoundSequence(operand.Syntax, 644Return New BoundDirectCast(node.Syntax, 645MakeNullLiteral(rewrittenOperand.Syntax, resultType), 657Return New BoundDirectCast(node.Syntax, 670Return New BoundDirectCast(node.Syntax, 716Dim whenHasNoValue As BoundExpression = NullableNull(node.Syntax, resultType) 778Dim result As BoundExpression = MakeTernaryConditionalExpression(node.Syntax, condition, whenHasValue, whenHasNoValue) 782result = New BoundSequence(node.Syntax, 890operand = New BoundDirectCast(operand.Syntax, 897result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 915Return New BoundDirectCast(node.Syntax, node.Operand, node.ConversionKind, node.Type, Nothing) 965operand = New BoundDirectCast(operand.Syntax, 975result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 987result = New BoundConversion(node.Syntax, DirectCast(result, BoundExpression), 1060operand = New BoundConversion(node.Syntax, operand, conv, node.Checked, node.ExplicitCastInCode, 1068node.Syntax, 1075result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 1120result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 1132result = New BoundConversion(node.Syntax, DirectCast(result, BoundExpression), 1199operand = New BoundConversion(node.Syntax, operand, conv, node.Checked, node.ExplicitCastInCode, 1207node.Syntax, 1214result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 1257result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 1269result = New BoundConversion(node.Syntax, DirectCast(result, BoundExpression), 1287Return New BoundConversion(node.Syntax, callOperand.Arguments(0), node.ConversionKind, node.Checked, node.ExplicitCastInCode, node.Type) 1306operand = New BoundConversion(node.Syntax, operand, ConversionKind.WideningNumeric, node.Checked, node.ExplicitCastInCode, 1310Dim callMathRound = New BoundCall(node.Syntax, mathRound, Nothing, Nothing, 1315result = New BoundConversion(node.Syntax, callMathRound, node.ConversionKind, 1425returnValue = New BoundDirectCast(node.Syntax, DirectCast(Visit(operand), BoundExpression), node.ConversionKind, typeTo, Nothing)

30captureTemp = New SynthesizedLocal(Me._currentMethodOrLambda, placeholderOpt.Type, SynthesizedLocalKind.DelegateRelaxationReceiver, syntaxOpt:=placeholderOpt.Syntax) 31Dim actualReceiver = New BoundLocal(placeholderOpt.Syntax, captureTemp, captureTemp.Type).MakeRValue 43relaxationLambda.Syntax, 54Dim capture = New BoundAssignmentOperator(receiverToCapture.Syntax, 55New BoundLocal(receiverToCapture.Syntax, 62result.Syntax,

29Return New BoundStatementList(node.Syntax, inits.ToImmutableAndFree)

38loopResumeLabel = RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(node.Syntax) 39conditionResumeTarget = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, canThrow:=True) 47afterBodyResumeLabel = RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(node.Syntax) 50Dim syntax = DirectCast(node.Syntax, DoLoopBlockSyntax) 66Dim syntax = DirectCast(node.Syntax, DoLoopBlockSyntax) 93conditionResumeTarget = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, canThrow:=True) 123ifConditionGotoStart = New BoundStatementList(ifConditionGotoStart.Syntax, conditionResumeTarget.Add(ifConditionGotoStart)) 127Return New BoundStatementList(node.Syntax, ImmutableArray.Create( 137Return New BoundStatementList(node.Syntax, ImmutableArray.Create( 140New BoundLabelStatement(node.Syntax, node.ContinueLabel), 142New BoundLabelStatement(node.Syntax, node.ExitLabel) 150Dim syntax = DirectCast(node.Syntax, DoLoopBlockSyntax) 208New BoundLabelStatement(node.Syntax, node.ContinueLabel), 209New BoundGotoStatement(node.Syntax, startLabel, Nothing), 210New BoundLabelStatement(node.Syntax, node.ExitLabel)

13Return Visit(New BoundExpressionStatement(clause.Syntax, clause)) 20statements.Add(DirectCast(Visit(New BoundExpressionStatement(clause.Syntax, clause)), BoundStatement)) 23Return New BoundStatementList(node.Syntax, statements.ToImmutableAndFree())

15Dim boundGoto As BoundStatement = New BoundGotoStatement(node.Syntax, node.Label, Nothing) 18boundGoto = Concat(RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(node.Syntax), boundGoto)

24rewritten = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, rewritten, canThrow:=True) 41Return DirectCast(expression, BoundCall).Method.CallsAreOmitted(expression.Syntax, expression.SyntaxTree)

19Return MakeTupleFieldAccess(node.Syntax, node.FieldSymbol, rewrittenReceiver, node.ConstantValueOpt, node.IsLValue)

38Dim syntax = node.Syntax 149Return New BoundStatementList(node.Syntax, rewrittenStatements.ToImmutableAndFree())

94Dim tempForControlVariable = New BoundLocal(node.Syntax, tempLocal, node.ControlVariable.Type) 143Return New BoundBlock(node.Syntax, 188Dim syntaxNode = DirectCast(node.Syntax, ForEachBlockSyntax) 230boundCollectionAssignment = New BoundStatementList(boundCollectionAssignment.Syntax, loopResumeTarget.Add(boundCollectionAssignment)) 433Dim statementSyntax = forEachStatement.Syntax 541Dim syntaxNode = DirectCast(node.Syntax, ForEachBlockSyntax) 578boundEnumeratorAssignment = New BoundStatementList(boundEnumeratorAssignment.Syntax, loopResumeTarget.Add(boundEnumeratorAssignment)) 639Dim disposalStatement = GenerateDisposeCallForForeachAndUsing(node.Syntax,

52Dim blockSyntax = DirectCast(forStatement.Syntax, ForBlockSyntax) 97cacheAssignments.Add(New BoundAssignmentOperator(forStatement.OperatorsOpt.Syntax, 98New BoundLocal(forStatement.OperatorsOpt.Syntax, 128Dim literal As BoundExpression = New BoundLiteral(rewrittenStep.Syntax, ConstantValue.Default(literalUnderlyingType.SpecialType), stepValue.Type) 136New BoundBinaryOperator(rewrittenStep.Syntax, 145isUp = MakeBooleanBinaryExpression(isUp.Syntax, 154cacheAssignments.Add(New BoundAssignmentOperator(isUp.Syntax, 155New BoundLocal(isUp.Syntax, 167rewrittenInitialValue = New BoundSequence(rewrittenInitialValue.Syntax, 177rewrittenInitialValue.Syntax, 179rewrittenInitialValue.Syntax, 188rewrittenInitializer = New BoundStatementList(rewrittenInitializer.Syntax, loopResumeTarget.Add(rewrittenInitializer)) 391Dim blockSyntax = DirectCast(forStatement.Syntax, ForBlockSyntax) 439rewrittenLimit.Syntax, 448rewrittenInitCondition = New BoundBadExpression(rewrittenLimit.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, 494rewrittenLimit.Syntax, 503rewrittenLoopCondition = New BoundBadExpression(rewrittenLimit.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, 579hasValues = MakeBooleanBinaryExpression(controlVariable.Syntax, 589New BoundBinaryOperator(stepValue.Syntax, 597newValue = MakeTernaryConditionalExpression(newValue.Syntax, 600NullableNull(controlVariable.Syntax, controlVariable.Type)) 615stepValue.Syntax, 617stepValue.Syntax, 635Dim shiftConst = New BoundLiteral(value.Syntax, ConstantValue.Create(bits), int32Type) 637New BoundBinaryOperator(value.Syntax, BinaryOperatorKind.RightShift, [step], shiftConst, False, [step].Type)) 639Return TransformRewrittenBinaryOperator(New BoundBinaryOperator(value.Syntax, BinaryOperatorKind.Xor, shiftedStep, value, False, value.Type)) 665Dim result = MakeTernaryConditionalExpression(operatorsOpt.Syntax, 666New BoundLocal(operatorsOpt.Syntax, 684New BoundBinaryOperator(limit.Syntax, 706New BoundBinaryOperator(limit.Syntax, 721New BoundBinaryOperator(stepValue.Syntax, 735ctrlLimitHasValue = MakeBooleanBinaryExpression(controlVariable.Syntax, 747New BoundBinaryOperator(limit.Syntax, 755New BoundBinaryOperator(limit.Syntax, 762Dim isUp As BoundExpression = New BoundLocal(limit.Syntax, 767condition = MakeTernaryConditionalExpression(limit.Syntax, 778condition = MakeBooleanBinaryExpression(condition.Syntax,

26rewritten = Concat(RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(node.Syntax), rewritten)

17Dim syntax = node.Syntax

12Dim syntax = node.Syntax 46resumeTarget = RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(newConsequence.Syntax) 62newConsequence = Concat(newConsequence, RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(newConsequence.Syntax)) 70Dim asElse = TryCast(node.AlternativeOpt.Syntax, ElseBlockSyntax) 75resumeTarget = RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(newAlternative.Syntax) 83Dim asElse = TryCast(node.AlternativeOpt.Syntax, SingleLineElseClauseSyntax) 101node.Syntax, 141condGoto = New BoundStatementList(condGoto.Syntax, unstructuredExceptionHandlingResumeTarget.Add(condGoto)) 146Select Case instrumentationTargetOpt.Syntax.Kind 154Throw ExceptionUtilities.UnexpectedValue(instrumentationTargetOpt.Syntax.Kind) 157If instrumentationTargetOpt.Syntax.Kind = SyntaxKind.MultiLineIfBlock Then 186condGoto = New BoundStatementList(condGoto.Syntax, unstructuredExceptionHandlingResumeTarget.Add(condGoto)) 190Select Case instrumentationTargetOpt.Syntax.Kind 198Throw ExceptionUtilities.UnexpectedValue(instrumentationTargetOpt.Syntax.Kind)

20Dim factory = New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 82binder.GetWellKnownType(WellKnownType.System_Runtime_CompilerServices_FormattableStringFactory, conversion.Syntax, _diagnostics), 85New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics)) 113Dim methodGroup = New BoundMethodGroup(node.Syntax, Nothing, lookup.Symbols.ToDowncastedImmutable(Of MethodSymbol), lookup.Kind, Nothing, QualificationKind.QualifiedViaTypeName).MakeCompilerGenerated() 166Dim result As BoundExpression = binder.MakeRValue(binder.BindInvocationExpression(node.Syntax, 167node.Syntax, 177result = binder.ApplyImplicitConversion(node.Syntax, targetType, result, _diagnostics).MakeCompilerGenerated()

21Not node.WasCompilerGenerated AndAlso node.Syntax.Kind = SyntaxKind.LabelStatement Then 22Dim labelSyntax = DirectCast(node.Syntax, LabelStatementSyntax) 29Dim trackLineNumber As BoundStatement = New BoundAssignmentOperator(node.Syntax, 30New BoundLocal(node.Syntax, _currentLineTemporary, _currentLineTemporary.Type), 31New BoundLiteral(node.Syntax, ConstantValue.Create(lineNumber), _currentLineTemporary.Type), 36trackLineNumber = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, trackLineNumber, canThrow:=False) 39statement = New BoundStatementList(node.Syntax, ImmutableArray.Create(statement, trackLineNumber))

22Dim lambda = BuildDelegateRelaxationLambda(node.Syntax, targetType, node.MemberAccess, node.Binder, Me._diagnostics)

344Dim syntax = assignmentTarget.Syntax 475Dim syntax = node.Syntax 492Dim arguments As BoundExpression = LateMakeArgumentArrayArgument(node.Syntax, argExpressions, node.ArgumentNamesOpt, lateIndexGetMethod.Parameters(1).Type) 677Dim syntax = memberAccess.Syntax 900argument = New BoundAssignmentOperator(argumentWithCapture.Syntax, 901New BoundLocal(argumentWithCapture.Syntax,

84result = New BoundSequence(memberAccess.Syntax,

48AddPlaceholderReplacement(placeholder, VisitExpressionNode(New BoundLocal(node.Syntax, localSymbol, localSymbol.Type))) 92result = New BoundExpressionStatement(rewrittenInitializer.Syntax, rewrittenInitializer) 96rewrittenInitializer.Syntax, 98rewrittenInitializer.Syntax, 101node.Syntax, 120result = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, result, canThrow:=True) 158Return New BoundFieldAccess(node.Syntax, 161New BoundMeReference(node.Syntax, _topMethod.ContainingType)), 172Dim syntax = rewrittenInitialization.Syntax

20Dim ctor = GetNullableMethod(expr.Syntax, nullableType, SpecialMember.System_Nullable_T__ctor) 23Return New BoundObjectCreationExpression(expr.Syntax, 30Return New BoundBadExpression(expr.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), nullableType, hasErrors:=True) 67hasValueExpr = New BoundLiteral(operand.Syntax, ConstantValue.True, Me.GetSpecialType(SpecialType.System_Boolean)) 119Dim localAccess = New BoundLocal(operand.Syntax, temp, True, temp.Type) 120init = New BoundAssignmentOperator(operand.Syntax, localAccess, operand, True, operand.Type) 186New BoundLiteral(expr.Syntax, ConstantValue.False, expr.Type.GetNullableUnderlyingType())) 191Dim getValueOrDefaultMethod = GetNullableMethod(expr.Syntax, expr.Type, SpecialMember.System_Nullable_T_GetValueOrDefault) 194Return New BoundCall(expr.Syntax, 205Return New BoundBadExpression(expr.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), expr.Type.GetNullableUnderlyingType(), hasErrors:=True) 220Dim getValueMethod As MethodSymbol = GetNullableMethod(expr.Syntax, expr.Type, SpecialMember.System_Nullable_T_get_Value) 223Return New BoundCall(expr.Syntax, 234Return New BoundBadExpression(expr.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), expr.Type.GetNullableUnderlyingType(), hasErrors:=True) 248Dim hasValueMethod As MethodSymbol = GetNullableMethod(expr.Syntax, expr.Type, SpecialMember.System_Nullable_T_get_HasValue) 251Return New BoundCall(expr.Syntax, 262Return New BoundBadExpression(expr.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), 291Return NullableNull(candidateNullExpression.Syntax, type) 491Return MakeSequence(second.Syntax, first, second)

46result = New BoundDirectCast(node.Syntax, result, conv, node.Type, Nothing) 67Dim factory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 74newGuid = New BoundBadExpression(node.Syntax, LookupResultKind.NotCreatable, ImmutableArray(Of Symbol).Empty, ImmutableArray(Of BoundExpression).Empty, ErrorTypeSymbol.UnknownResultType, hasErrors:=True) 83callGetTypeFromCLSID = New BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray(Of Symbol).Empty, ImmutableArray(Of BoundExpression).Empty, ErrorTypeSymbol.UnknownResultType, hasErrors:=True) 92rewrittenObjectCreation = New BoundDirectCast(node.Syntax, factory.Call(Nothing, createInstance, callGetTypeFromCLSID), conversion, node.Type) 94rewrittenObjectCreation = New BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray(Of Symbol).Empty, ImmutableArray(Of BoundExpression).Empty, node.Type, hasErrors:=True) 133Dim syntax = node.Syntax 188Dim syntaxNode = node.Syntax 201newPlaceholder = New BoundWithLValueExpressionPlaceholder(node.PlaceholderOpt.Syntax, node.PlaceholderOpt.Type) 301Dim syntaxNode = node.Syntax

18If Not TryGetWellknownMember(missingField, WellKnownMember.System_Reflection_Missing__Value, node.Syntax) Then 22Dim fieldAccess = New BoundFieldAccess(node.Syntax, Nothing, missingField, isLValue:=False, type:=missingField.Type) 28Return New BoundDirectCast(node.Syntax, fieldAccess, conversion, node.Type)

19Dim syntax = node.Syntax

25Return New BoundArrayLength(node.Syntax, VisitExpressionNode(receiverOpt), node.Type) 49Return RewriteReceiverArgumentsAndGenerateAccessorCall(node.Syntax,

99Dim paramRef As New BoundParameter(node.Syntax, 111PopulateRangeVariableMapForAnonymousType(node.Syntax, paramRef.MakeCompilerGenerated(), nodeRangeVariables, firstUnmappedRangeVariable, rangeVariableMap, inExpressionLambda) 185Return New BoundReturnStatement(originalNode.Syntax, 199Dim lambdaBody = New BoundBlock(originalNode.Syntax, 204Dim result As BoundLambda = New BoundLambda(originalNode.Syntax, 239New BoundLocal(node.Syntax, groupLocal, False, groupLocal.Type)) 241Dim result = New BoundSequence(node.Syntax, 244New BoundAssignmentOperator(node.Syntax, 245New BoundLocal(node.Syntax, groupLocal, True, groupLocal.Type),

13Dim syntax = node.Syntax 101result = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, result, canThrow:=True)

32Return New BoundStatementList(node.Syntax, statements.AsImmutableOrNull())

21Dim valueBeingAssigned As BoundExpression = New BoundArrayCreation(node.Syntax, 29If node.Preserve AndAlso TryGetWellknownMember(copyArrayUtilityMethod, WellKnownMember.Microsoft_VisualBasic_CompilerServices_Utils__CopyArray, node.Syntax) Then 54arrayValueAccess = New BoundDirectCast(node.Syntax, arrayValueAccess, 58valueBeingAssigned = New BoundDirectCast(node.Syntax, valueBeingAssigned, 63valueBeingAssigned = New BoundCall(node.Syntax, 70valueBeingAssigned = New BoundDirectCast(node.Syntax, valueBeingAssigned, 83Dim assignmentOperator As BoundExpression = New BoundAssignmentOperator(node.Syntax, assignmentTarget, 89assignmentOperator = New BoundSequence(node.Syntax, 102Return Visit(New BoundExpressionStatement(node.Syntax, assignmentOperator))

23rewritten = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, rewritten, canThrow:=node.ExpressionOpt IsNot Nothing) 67Dim boundFunctionLocal = New BoundLocal(node.Syntax, functionLocal, functionLocal.Type) 69Dim syntaxNode As SyntaxNode = node.Syntax 89Return New BoundGotoStatement(node.Syntax, node.ExitLabelOpt, Nothing)

59Return RewriteSelectStatement(node, node.Syntax, node.ExpressionStatement, node.ExprPlaceholderOpt, node.CaseBlocks, node.RecommendSwitchTable, node.ExitLabel) 185Dim privateImplClass = _emitModule.GetPrivateImplClass(node.Syntax, _diagnostics.DiagnosticBag) 208Dim selectExprStmtSyntax = selectExpressionStmt.Syntax 237Dim boundTemp = New BoundLocal(rewrittenSelectExpression.Syntax, tempLocal, selectExprType) 278rewrittenBody = AppendToBlock(rewrittenBody, RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(curCaseBlock.Syntax)) 285Debug.Assert(curCaseBlock.Syntax.Kind = SyntaxKind.CaseElseBlock) 298Debug.Assert(curCaseBlock.Syntax.Kind = SyntaxKind.CaseBlock) 306syntaxNode:=curCaseBlock.Syntax, 325Debug.Assert(node.Syntax.Kind = SyntaxKind.CaseStatement) 328RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, canThrow:=True), 333Debug.Assert(node.Syntax.Kind = SyntaxKind.CaseElseStatement) 391rewrittenBody = AppendToBlock(rewrittenBody, RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(node.Syntax))

40Dim syntax = node.Syntax

19Dim syntaxNode = DirectCast(node.Syntax, SyncLockBlockSyntax) 40visitedLockExpression = TransformRewrittenConversion(New BoundConversion(node.LockExpression.Syntax, 113Dim boundMonitorEnterCallStatement As BoundStatement = GenerateMonitorEnter(node.LockExpression.Syntax, boundLockObjectLocal, boundLockTakenLocal, tempLockTakenAssignment)

23Debug.Assert(node.Syntax.Kind = SyntaxKind.ErrorStatement, "Must be an Error statement.") 24Dim nodeFactory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 29expressionOpt = New BoundCall(node.Syntax, createProjectError, Nothing, Nothing, 39rewritten = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, rewritten, canThrow:=True)

22Dim rewritten As BoundStatement = RewriteTryStatement(node.Syntax, rewrittenTryBlock, rewrittenCatchBlocks, rewrittenFinally, node.ExitLabelOpt) 25Dim syntax = TryCast(node.Syntax, TryBlockSyntax) 117Dim syntax = TryCast(node.Syntax, FinallyBlockSyntax) 132Dim syntax = TryCast(node.Syntax, TryBlockSyntax) 149Dim syntax = TryCast(node.Syntax, CatchBlockSyntax) 173errorLineNumber = New BoundLocal(node.Syntax, _currentLineTemporary, isLValue:=False, type:=_currentLineTemporary.Type)

31Return MakeTupleCreationExpression(node.Syntax, DirectCast(node.Type, NamedTypeSymbol), rewrittenArguments)

32Return New BoundLiteral(node.Syntax, ConstantValue.False, node.Type) 131result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 155result = New BoundCall(node.Syntax, memberSymbol, Nothing, Nothing, 195Dim value As BoundExpression = MakeTernaryConditionalExpression(node.Syntax, 202value = New BoundSequence(node.Syntax, 241Dim whenHasNoValue = NullableNull(node.Syntax, resultType) 293Dim result As BoundExpression = MakeTernaryConditionalExpression(node.Syntax, 300result = New BoundSequence(node.Syntax, 319New BoundUnaryOperator(originalOperator.Syntax,

41Dim nodeFactory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 143Dim nodeFactory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 171RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, False, statements) 191statements.Add(New BoundUnstructuredExceptionResumeSwitch(node.Syntax, 234statements.Add(New BoundUnstructuredExceptionOnErrorSwitch(node.Syntax, 257node.Syntax, 260node.Syntax, 264New BoundLocal(node.Syntax, _currentLineTemporary, isLValue:=False, type:=_currentLineTemporary.Type), 266New BoundUnstructuredExceptionHandlingCatchFilter(node.Syntax, 283statements.Add(nodeFactory.Throw(New BoundCall(node.Syntax, createProjectError, Nothing, Nothing, 296statements.Add(RewriteIfStatement(node.Syntax, 301New BoundCall(node.Syntax, clearProjectError, Nothing, Nothing, ImmutableArray(Of BoundExpression).Empty, Nothing, clearProjectError.ReturnType).ToStatement(), 326Dim nodeFactory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 331RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, False, statements) 338statements.Add(New BoundCall(node.Syntax, clearProjectError, Nothing, Nothing, ImmutableArray(Of BoundExpression).Empty, Nothing, clearProjectError.ReturnType).ToStatement) 374Dim rewritten As BoundStatement = New BoundStatementList(node.Syntax, statements.ToImmutableAndFree()) 384Dim nodeFactory As New SyntheticBoundNodeFactory(_topMethod, _currentMethodOrLambda, node.Syntax, _compilationState, _diagnostics) 390RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, True, statements) 397statements.Add(New BoundCall(node.Syntax, clearProjectError, Nothing, Nothing, ImmutableArray(Of BoundExpression).Empty, Nothing, clearProjectError.ReturnType).ToStatement) 406statements.Add(RewriteIfStatement(node.Syntax, 411nodeFactory.Throw(New BoundCall(node.Syntax, createProjectError, Nothing, Nothing, 426RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, False, statements) 440Dim rewritten As BoundStatement = New BoundStatementList(node.Syntax, statements.ToImmutableAndFree()) 479If Not (TypeOf statement.Syntax Is StatementSyntax) Then 480If statement.Syntax.Parent IsNot Nothing AndAlso statement.Syntax.Parent.Kind = SyntaxKind.EraseStatement Then 481Debug.Assert(TypeOf statement.Syntax Is ExpressionSyntax) 483Select Case statement.Syntax.Kind 496statement.Syntax.Parent Is Nothing OrElse 497statement.Syntax.Parent.Kind <> SyntaxKind.VariableDeclarator OrElse 498statement.Syntax.Parent.Parent Is Nothing OrElse 499statement.Syntax.Parent.Parent.Kind <> SyntaxKind.LocalDeclarationStatement Then 505Not (TypeOf statement.Syntax.Parent Is ReDimStatementSyntax) Then 515If TypeOf statement.Syntax Is DeclarationStatementSyntax Then 521If Not (TypeOf statement.Syntax Is ExecutableStatementSyntax) Then 524Debug.Assert(statement.Syntax.Kind = SyntaxKind.ElseIfBlock AndAlso 525statement.Syntax.Parent IsNot Nothing AndAlso 526statement.Syntax.Parent.Kind = SyntaxKind.MultiLineIfBlock AndAlso 527_unstructuredExceptionHandlingResumableStatements.ContainsKey(statement.Syntax.Parent)) 530Debug.Assert((statement.Syntax.Kind = SyntaxKind.CaseBlock OrElse statement.Syntax.Kind = SyntaxKind.CaseElseBlock) AndAlso 531statement.Syntax.Parent IsNot Nothing AndAlso 532statement.Syntax.Parent.Kind = SyntaxKind.SelectBlock AndAlso 533_unstructuredExceptionHandlingResumableStatements.ContainsKey(statement.Syntax.Parent)) 536Debug.Assert(statement.Syntax.Kind = SyntaxKind.ModifiedIdentifier AndAlso 537statement.Syntax.Parent IsNot Nothing AndAlso 538statement.Syntax.Parent.Kind = SyntaxKind.VariableDeclarator AndAlso 539statement.Syntax.Parent.Parent IsNot Nothing AndAlso 540statement.Syntax.Parent.Parent.Kind = SyntaxKind.LocalDeclarationStatement) 543Debug.Assert((statement.Syntax.Kind = SyntaxKind.RedimClause AndAlso 544TypeOf statement.Syntax.Parent Is ReDimStatementSyntax) OrElse 545(TypeOf statement.Syntax Is ExpressionSyntax AndAlso 546TypeOf statement.Syntax.Parent Is EraseStatementSyntax)) 549Debug.Assert(TypeOf statement.Syntax Is ExecutableStatementSyntax) 555_unstructuredExceptionHandlingResumableStatements.Add(statement.Syntax, statement)

76Dim blockSyntax = DirectCast(node.Syntax, UsingBlockSyntax) 99localDeclaration.Syntax, 114localDeclaration.Syntax, 150statements = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, canThrow:=True).Concat(statements) 153currentBody = New BoundBlock(node.Syntax,

23loopResumeLabel = RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(node.Syntax) 24conditionResumeTarget = RegisterUnstructuredExceptionHandlingResumeTarget(node.Syntax, canThrow:=True) 32afterBodyResumeLabel = RegisterUnstructuredExceptionHandlingNonThrowingResumeTarget(node.Syntax) 58Dim statementSyntax = statement.Syntax 98ifConditionGotoStart = New BoundStatementList(ifConditionGotoStart.Syntax, conditionResumeTargetOpt.Add(ifConditionGotoStart))

27Dim statementSyntax = DirectCast(node.Syntax, WithBlockSyntax).WithStatement 62Dim syntax As SyntaxNode = node.Syntax

91Dim syntax = expr.Syntax 204Dim syntax = objCreation.Syntax 256objCreation.Syntax, 259objCreation.Syntax, 263objCreation.Syntax, rewrittenCallArguments.AsImmutableOrNull, arrayType),

172Return New BoundParameter(node.Syntax, replacementParameter, node.IsLValue, replacementParameter.Type, node.HasErrors) 195Return New BoundLocal(node.Syntax, replacementLocal, node.IsLValue, replacementLocal.Type, node.HasErrors) 383If nodeStatements.Length > 0 AndAlso nodeStatements(0).Syntax IsNot Nothing Then 409newStatements.Add(New BoundExpressionStatement(expr.Syntax, expr))

51CodeCoverageInstrumenter.TryCreate(method, body, New SyntheticBoundNodeFactory(method, method, body.Syntax, compilationState, diagnostics), diagnostics, debugDocumentProvider, Instrumenter.NoOp), 119Return New BoundBlock(body.Syntax, body.StatementListSyntax, body.Locals, body.Statements, hasErrors:=True)

236Me.F.Syntax = node.Syntax 341Me._tryBlockSyntaxForNextFinalizerState = node.Syntax

63Me.F = New SyntheticBoundNodeFactory(method, method, method.ContainingType, body.Syntax, compilationState, diagnostics) 379Return Binder.GetSpecialType(F.Compilation, type, Me.Body.Syntax, bag) 383Return Binder.GetWellKnownType(F.Compilation, type, Me.Body.Syntax, bag) 387Return Binder.GetSpecialTypeMember(F.Compilation.Assembly, member, Me.Body.Syntax, bag) 391Return Binder.GetWellKnownTypeMember(F.Compilation, member, Me.Body.Syntax, bag) 404Binder.ReportDiagnostic(bag, Body.Syntax, ERRID.ERR_NoGetProperty1, CustomSymbolDisplayFormatter.QualifiedName(symbol)) 409Binder.ReportUseSite(bag, Body.Syntax, useSiteInfo)

1052Return New BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.Not, expression, False, expression.Type)

88receiver = New Result(New BoundSequence(capture.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(capture), boundTemp, boundTemp.Type), 95receiver = New Result(New BoundSequence(capture.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(capture), boundTemp, boundTemp.Type), 147referToTemp = New BoundLocal(value.Syntax, temp, type) 149Dim capture = (New BoundAssignmentOperator(value.Syntax, referToTemp, value, suppressObjectClone:=True, type:=type)).MakeCompilerGenerated() 186Dim second = New BoundLiteral(value.Syntax, constantValue, value.Type) 254Dim first = New BoundReferenceAssignment(lvalue.Syntax, 255New BoundLocal(lvalue.Syntax, temp, temp.Type).MakeCompilerGenerated(), 258Dim second = New BoundLocal(lvalue.Syntax, temp, isLValue:=True, type:=lvalue.Type).MakeCompilerGenerated() 322receiver = New Result(New BoundSequence(capture.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(capture), boundTemp, boundTemp.Type), 409firstArgsArray(i) = New BoundLateBoundArgumentSupportingAssignmentWithCapture(boundArgument.Syntax, 413secondArgsArray(i) = New BoundLocal(boundArgument.Syntax, temp, isLValue:=False, type:=temp.Type)

91Dim boundLocal = New BoundLocal(value.Syntax, local, isLValue:=True, type:=type).MakeCompilerGenerated() 96value = New BoundLValueToRValueWrapper(value.Syntax, value, value.Type).MakeCompilerGenerated() 103value.Syntax, boundLocal, value, suppressObjectClone:=True, type:=type).MakeCompilerGenerated()) 116Dim boundLocal = New BoundLocal(value.Syntax, local, isLValue:=True, type:=type).MakeCompilerGenerated() 120value.Syntax, boundLocal, value, True, type:=type).MakeCompilerGenerated())

322Return New NoneOperation(children, _semanticModel, boundNode.Syntax, type, constantValue, isImplicit) 366Return New NoneOperation(children, _semanticModel, boundAssignmentOperator.Syntax, type:=Nothing, constantValue, isImplicit) 374Dim syntax As SyntaxNode = boundAssignmentOperator.Syntax 383Dim syntax As SyntaxNode = boundMeReference.Syntax 391Dim syntax As SyntaxNode = boundMyBaseReference.Syntax 399Dim syntax As SyntaxNode = boundMyClassReference.Syntax 406Dim syntax As SyntaxNode = boundLiteral.Syntax 415Dim syntax As SyntaxNode = boundAwaitOperator.Syntax 423Dim syntax As SyntaxNode = boundNameOfOperator.Syntax 433Dim syntax As SyntaxNode = boundLambda.Syntax 451Dim syntax As SyntaxNode = boundCall.Syntax 458Dim syntax As SyntaxNode = boundOmittedArgument.Syntax 466Dim syntax As SyntaxNode = boundParenthesized.Syntax 476Dim syntax As SyntaxNode = boundArrayAccess.Syntax 502Dim syntax As SyntaxNode = boundUnaryOperator.Syntax 515Dim syntax As SyntaxNode = boundUserDefinedUnaryOperator.Syntax 568Dim syntax As SyntaxNode = currentBinary.Syntax 587Dim syntax As SyntaxNode = boundUserDefinedBinaryOperator.Syntax 599Dim syntax As SyntaxNode = boundBinaryConditionalExpression.Syntax 628Dim syntax As SyntaxNode = boundUserDefinedShortCircuitingOperator.Syntax 649Dim syntax As SyntaxNode = boundBadExpression.Syntax 655Dim isImplicit = boundBadExpression.WasCompilerGenerated OrElse boundBadExpression.ChildBoundNodes.Any(Function(e) e?.Syntax Is boundBadExpression.Syntax) 666Dim syntax As SyntaxNode = boundTypeArguments.Syntax 679Dim invalidOperation = OperationFactory.CreateInvalidOperation(_semanticModel, boundAttribute.Syntax, GetIOperationChildren(boundAttribute), isImplicit:=True) 680Return New AttributeOperation(invalidOperation, _semanticModel, boundAttribute.Syntax, isAttributeImplicit) 686initializer = New ObjectOrCollectionInitializerOperation(namedArguments, _semanticModel, boundAttribute.Syntax, boundAttribute.Type, isImplicit:=True) 689Dim objectCreationOperation = New ObjectCreationOperation(boundAttribute.Constructor, initializer, DeriveArguments(boundAttribute), _semanticModel, boundAttribute.Syntax, boundAttribute.Type, boundAttribute.ConstantValueOpt, isImplicit:=True) 690Return New AttributeOperation(objectCreationOperation, _semanticModel, boundAttribute.Syntax, isAttributeImplicit) 702Dim syntax As SyntaxNode = boundConversion.Syntax 723Dim syntax As SyntaxNode = boundConversionOrCast.Syntax 727If boundOperand.Syntax Is boundConversionOrCast.Syntax Then 750Dim syntax As SyntaxNode = boundDelegateCreationExpression.Syntax 771Dim syntax As SyntaxNode = boundDelegateCreationExpression.Syntax 781Dim syntax As SyntaxNode = boundTernaryConditionalExpression.Syntax 793Dim syntax As SyntaxNode = boundTypeOf.Syntax 801Dim syntax As SyntaxNode = boundGetType.Syntax 812Dim syntax As SyntaxNode = boundLateInvocation.Syntax 824Dim syntax As SyntaxNode = boundObjectCreationExpression.Syntax 833Dim syntax As SyntaxNode = boundObjectInitializerExpression.Syntax 841Dim syntax As SyntaxNode = boundCollectionInitializerExpression.Syntax 849Dim syntax As SyntaxNode = boundNewT.Syntax 857Dim syntax As SyntaxNode = creation.Syntax 866Dim syntax As SyntaxNode = boundArrayCreation.Syntax 874Dim syntax As SyntaxNode = boundArrayInitialization.Syntax 886Dim syntax As SyntaxNode = boundPropertyAccess.Syntax 894Dim syntax As SyntaxNode = boundWithLValueExpressionPlaceholder.Syntax 902Dim syntax As SyntaxNode = boundWithRValueExpressionPlaceholder.Syntax 912Dim syntax As SyntaxNode = boundEventAccess.Syntax 923Dim syntax As SyntaxNode = boundFieldAccess.Syntax 934Dim syntax As SyntaxNode = boundConditionalAccess.Syntax 941Dim syntax As SyntaxNode = boundConditionalAccessReceiverPlaceholder.Syntax 949Dim syntax As SyntaxNode = boundParameter.Syntax 958Dim syntax As SyntaxNode = boundLocal.Syntax 984Dim syntax As SyntaxNode = boundLateMemberAccess.Syntax 993Dim syntax As SyntaxNode = boundFieldInitializer.Syntax 1001Dim syntax As SyntaxNode = boundPropertyInitializer.Syntax 1009Dim syntax As SyntaxNode = boundParameterEqualsValue.Syntax 1022Dim syntax As SyntaxNode = boundRValuePlaceholder.Syntax 1064Dim syntax As SyntaxNode = boundIfStatement.Syntax 1077Dim syntax As SyntaxNode = boundSelectStatement.Syntax 1086If caseStatement.CaseClauses.IsEmpty AndAlso caseStatement.Syntax.Kind() = SyntaxKind.CaseElseStatement Then 1091caseStatement.Syntax, 1110Dim syntax As SyntaxNode = boundCaseBlock.Syntax 1118Dim syntax As SyntaxNode = boundSimpleCaseClause.Syntax 1127Dim syntax As SyntaxNode = boundRangeCaseClause.Syntax 1135Dim syntax As SyntaxNode = boundRelationalCaseClause.Syntax 1150Dim syntax As SyntaxNode = boundDoLoopStatement.Syntax 1169Dim syntax As SyntaxNode = boundForToStatement.Syntax 1172New SynthesizedLocal(DirectCast(_semanticModel.GetEnclosingSymbol(boundForToStatement.Syntax.SpanStart), Symbol), boundForToStatement.ControlVariable.Type, 1173SynthesizedLocalKind.ForInitialValue, boundForToStatement.Syntax), 1248Dim syntax As SyntaxNode = boundForEachStatement.Syntax 1257New VariableDeclaratorOperation(localOpt, initializer:=Nothing, ignoredArguments:=ImmutableArray(Of IOperation).Empty, semanticModel:=_semanticModel, syntax:=controlVariable.Syntax, isImplicit:=boundForStatement.WasCompilerGenerated), 1266Dim syntax As SyntaxNode = boundTryStatement.Syntax 1275Return New VariableDeclaratorOperation(boundCatchBlock.LocalOpt, initializer:=Nothing, ignoredArguments:=ImmutableArray(Of IOperation).Empty, semanticModel:=_semanticModel, syntax:=boundCatchBlock.ExceptionSourceOpt.Syntax, isImplicit:=False) 1289Dim syntax As SyntaxNode = boundCatchBlock.Syntax 1297Dim syntax As SyntaxNode = boundBlock.Syntax 1303Dim syntax As SyntaxNode = boundBadStatement.Syntax 1309If child?.Syntax Is boundBadStatement.Syntax Then 1323Dim syntax As SyntaxNode = boundReturnStatement.Syntax 1335Dim syntax As SyntaxNode = boundThrowStatement.Syntax 1350Dim syntax As SyntaxNode = boundWhileStatement.Syntax 1357Dim syntax As SyntaxNode = boundDimStatement.Syntax 1365Dim syntax As SyntaxNode = boundLocalDeclaration.Syntax 1373Dim syntax As SyntaxNode = boundYieldStatement.Syntax 1381Dim syntax As SyntaxNode = boundLabelStatement.Syntax 1389Dim syntax As SyntaxNode = boundGotoStatement.Syntax 1397Dim syntax As SyntaxNode = boundContinueStatement.Syntax 1405Dim syntax As SyntaxNode = boundExitStatement.Syntax 1414New SynthesizedLocal(DirectCast(_semanticModel.GetEnclosingSymbol(boundSyncLockStatement.Syntax.SpanStart), Symbol), 1417syntaxOpt:=boundSyncLockStatement.LockExpression.Syntax)) 1420Dim syntax As SyntaxNode = boundSyncLockStatement.Syntax 1426Dim syntax As SyntaxNode = boundNoOpStatement.Syntax 1434Dim syntax As SyntaxNode = boundStopStatement.Syntax 1440Dim syntax As SyntaxNode = boundEndStatement.Syntax 1448Dim syntax As SyntaxNode = boundWithStatement.Syntax 1455Return GetUsingStatementDeclaration(boundUsingStatement.ResourceList, DirectCast(boundUsingStatement.Syntax, UsingBlockSyntax).UsingStatement) 1465Dim syntax As SyntaxNode = boundUsingStatement.Syntax 1472Dim syntax As SyntaxNode = boundExpressionStatement.Syntax 1480Dim eventReferenceSyntax = If(receiverOpt?.Syntax, 1481If(TryCast(boundRaiseEventStatement.Syntax, RaiseEventStatementSyntax)?.Name, 1482boundRaiseEventStatement.Syntax)) 1507Dim syntax As SyntaxNode = boundRaiseEventStatement.Syntax 1528Dim syntax As SyntaxNode = boundAddHandlerStatement.Syntax 1535Dim syntax As SyntaxNode = boundRemoveHandlerStatement.Syntax 1552Dim syntax As SyntaxNode = boundTupleExpression.Syntax 1560Dim syntax As SyntaxNode = boundInterpolatedString.Syntax 1583Dim syntax As SyntaxNode = boundInterpolation.Syntax 1590Dim syntax As SyntaxNode = boundLiteral.Syntax 1597Dim syntax As SyntaxNode = boundAnonymousTypeCreationExpression.Syntax 1605Dim instance As IOperation = CreateAnonymousTypePropertyAccessImplicitReceiverOperation([property], boundAnonymousTypePropertyAccess.Syntax.FirstAncestorOrSelf(Of AnonymousObjectCreationExpressionSyntax)) 1607Dim syntax As SyntaxNode = boundAnonymousTypePropertyAccess.Syntax 1626Dim syntax As SyntaxNode = boundQueryExpression.Syntax 1643Dim syntax As SyntaxNode = boundAggregateClause.Syntax 1650Dim syntax As SyntaxNode = boundNullableIsTrueOperator.Syntax 1678Dim preserve As Boolean = boundRedimStatement.Syntax.Kind = SyntaxKind.ReDimPreserveStatement 1684Dim syntax As SyntaxNode = boundRedimStatement.Syntax 1692Dim syntax As SyntaxNode = boundRedimClause.Syntax

90Dim syntax As SyntaxNode = boundAssignment.Syntax 152Return OperationFactory.CreateInvalidOperation(_semanticModel, [operator].UnderlyingExpression.Syntax, ImmutableArray(Of IOperation).Empty, isImplicit) 212Dim isImplicit As Boolean = argument.WasCompilerGenerated AndAlso argument.Syntax.Kind <> SyntaxKind.OmittedArgument 256Dim syntax = If(valueNode.Syntax.Kind = SyntaxKind.OmittedArgument, valueNode.Syntax, TryCast(valueNode.Syntax?.Parent, ArgumentSyntax)) 298Return OperationFactory.CreateInvalidOperation(_semanticModel, parent.Syntax, ImmutableArray(Of IOperation).Empty, isImplicit) 330Dim instance As IInstanceReferenceOperation = CreateAnonymousTypePropertyAccessImplicitReceiverOperation([property], expression.Syntax) 348Dim syntax As SyntaxNode = If(value.Syntax?.Parent, expression.Syntax) 395declaration.Syntax.IsKind(SyntaxKind.ModifiedIdentifier) Then 396Debug.Assert(declaration.Syntax.Parent.IsKind(SyntaxKind.VariableDeclarator)) 397Return declaration.Syntax.Parent 399Return declaration.Syntax 417Debug.Assert(last.Syntax.IsKind(SyntaxKind.ModifiedIdentifier)) 418Dim declaratorSyntax = DirectCast(last.Syntax.Parent, VariableDeclaratorSyntax) 427initializerSyntax = last.InitializerOpt.Syntax 437Dim initializerSyntax As AsClauseSyntax = DirectCast(asNewDeclarations.Syntax, VariableDeclaratorSyntax).AsClause 458Dim syntax = boundLocalDeclaration.Syntax 465Return New VariableDeclaratorOperation(boundLocalDeclaration.LocalSymbol, initializer, ignoredArguments, _semanticModel, boundLocalDeclaration.Syntax, isImplicit:=boundLocalDeclaration.WasCompilerGenerated) 480Return New EventAssignmentOperation(eventReference, handlerValue, adds, _semanticModel, statement.Syntax, type:=Nothing, isImplicit:=True) 501If IsDelegateCreation(boundConversion.Syntax, boundOperand, boundConversion.Type) Then 520boundOperand.Syntax, 531If nestedConversion.Syntax Is nestedOperand.Syntax AndAlso 538ElseIf boundOperand.Syntax.IsKind(SyntaxKind.AddressOfExpression) AndAlso 540IsDelegateCreation(topLevelConversion.Syntax, boundOperand, boundOperand.Type) Then 598Dim validAddressOfConversionSyntax = operand.Syntax.Kind() = SyntaxKind.AddressOfExpression AndAlso 604conversionSyntax Is operand.Syntax))

60expression = New BoundParameter(node.Syntax, parameter.ParameterSymbol, parameter.IsLValue, parameter.SuppressVirtualCalls, parameter.Type, parameter.HasErrors) 63expression = New BoundPropertyAccess(node.Syntax, access.PropertySymbol, access.PropertyGroupOpt, access.AccessKind, 91node = New BoundParameter(node.Syntax, node.ParameterSymbol, node.IsLValue, node.SuppressVirtualCalls, node.Type, node.HasErrors)

3239Dim methodGroup = New BoundMethodGroup(argument1.Syntax, Nothing, ImmutableArray(Of MethodSymbol).Empty, LookupResultKind.Good, Nothing, QualificationKind.Unqualified)

3080defaultArgument = binder.GetArgumentForParameterDefaultValue(param, If(argument, methodOrPropertyGroup).Syntax, defaultValueDiagnostics, callerInfoOpt, parameterToArgumentMap, arguments, receiverOpt) 3394IsWithinAppliedAttributeName(methodOrPropertyGroup.Syntax) AndAlso

232argumentLocation = DirectCast(IncomingEdges(0), ArgumentNode).Expression.Syntax 582Expression.Syntax, 1006Dim fakeArgument As New BoundRValuePlaceholder(Me.DelegateReturnTypeReferenceBoundNode.Syntax, 1222argNode.Expression.Syntax, 1967argument.Syntax, 2025argument.Syntax, 2105argument.Syntax, 2253argument.Syntax,

1124diagnostics.Add(ERRID.WRN_TupleLiteralNameMismatch, literal.Arguments(i).Syntax.Parent.Location, sourceName, destination)

532binder.AdjustAssignmentTarget(value.Syntax, value, diagnostics, isError)

59Dim syntax = node.Syntax 80Return RewriteParameter(node.Syntax, node.ParameterSymbol, node) 84Return Me.GetRewrittenMeParameter(node.Syntax, node) 92Dim syntax = node.Syntax 115Return Me.GetRewrittenMeParameter(node.Syntax, node) 121Return Me.GetRewrittenMeParameter(node.Syntax, node) 126ReportMissingMe(node.Syntax)

21Dim syntax = block.Syntax

37Return ObjectIdLocalSymbol.RewriteLocal(_compilation, _container, node.Syntax, local, node.IsLValue) 41Return placeholder.RewriteLocal(_compilation, _container, node.Syntax, node.IsLValue, diagnostics)

469Dim syntax As SyntaxNode = body.Syntax

78Dim expr = InvokeGetMethod(method, variable.Syntax, local.Name) 98Return InvokeGetMethod(method.Construct(local.Type), variable.Syntax, local.Name)

121Dim syntax = expr.Syntax

1543Dim initValueSyntax = boundFieldInit.InitialValue.Syntax 1544If boundInit.Syntax.Kind <> SyntaxKind.AsNewClause Then 1545Assert.Same(initValueSyntax.Parent, boundInit.Syntax)