' Licensed to the .NET Foundation under one or more agreements.
' The .NET Foundation licenses this file to you under the MIT license.
' See the LICENSE file in the project root for more information.

'-----------------------------------------------------------------------------
' Contains the definition of the BlockContext
'-----------------------------------------------------------------------------
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
Imports InternalSyntaxFactory = Microsoft.CodeAnalysis.VisualBasic.Syntax.InternalSyntax.SyntaxFactory

Namespace Microsoft.CodeAnalysis.VisualBasic.Syntax.InternalSyntax

    Friend NotInheritable Class SingleLineLambdaContext
        Inherits MethodBlockContext

        Friend Sub New(statement As StatementSyntax, prevContext As BlockContext)
            MyBase.New(If(statement.Kind = SyntaxKind.FunctionLambdaHeader, SyntaxKind.SingleLineFunctionLambdaExpression, SyntaxKind.SingleLineSubLambdaExpression), statement, prevContext)

            Debug.Assert(statement.Kind = SyntaxKind.FunctionLambdaHeader OrElse statement.Kind = SyntaxKind.SubLambdaHeader)
            Debug.Assert(SyntaxFacts.IsSingleLineLambdaExpression(BlockKind))
        End Sub

        Friend Overrides ReadOnly Property IsLambda As Boolean
            Get
                Return True
            End Get
        End Property

        Friend Overrides Function CreateBlockSyntax(endStmt As StatementSyntax) As VisualBasicSyntaxNode
            Dim statements = Body()
            Dim statement As VisualBasicSyntaxNode
            Dim reportRequiresSingleStatement As Boolean

            If statements.Count = 0 Then
                statement = InternalSyntaxFactory.EmptyStatement(InternalSyntaxFactory.MissingEmptyToken)
                reportRequiresSingleStatement = True
            Else
                Debug.Assert(statements.Count = 1)
                statement = DirectCast(statements(0), StatementSyntax)
                reportRequiresSingleStatement = Not statement.ContainsDiagnostics() AndAlso Not IsSingleStatement(statement)
            End If

            ' Single line sub ignores the endStmt which may be nothing or the statement that was just added to the sub.
            Dim header = DirectCast(BeginStatement, LambdaHeaderSyntax)
            Dim lambdaExpr = SyntaxFactory.SingleLineLambdaExpression(BlockKind, header, statement)

            If reportRequiresSingleStatement Then
                lambdaExpr = Parser.ReportSyntaxError(lambdaExpr, ERRID.ERR_SubRequiresSingleStatement)
            ElseIf header.Kind = SyntaxKind.FunctionLambdaHeader AndAlso header.Modifiers.Any(SyntaxKind.IteratorKeyword) Then
                lambdaExpr = Parser.ReportSyntaxError(lambdaExpr, ERRID.ERR_BadIteratorExpressionLambda)
            End If

            FreeStatements()

            Return lambdaExpr
        End Function

        Friend Overrides Function EndBlock(endStmt As StatementSyntax) As BlockContext

            'Don't create the lambda block and don't pass it to the previous context.  The previous context is not the
            ' right place to store it because the lambda goes into an expression and not the surrounding statement block.

            Return PrevBlock
        End Function

        Friend Overrides Function ResyncAndProcessStatementTerminator(statement As StatementSyntax, lambdaContext As BlockContext) As BlockContext
            Return ProcessStatementTerminator(lambdaContext)
        End Function

        Friend Overrides Function ProcessStatementTerminator(lambdaContext As BlockContext) As BlockContext
            Dim token = Parser.CurrentToken
            Select Case token.Kind
                Case SyntaxKind.StatementTerminatorToken, SyntaxKind.EndOfFileToken
                    ' A single-line lambda is terminated at the end of the line.

                Case SyntaxKind.ColonToken
                    ' A single-line sub with multiple statements. Report ERR_SubRequiresSingleStatement
                    ' on the first statement and end the sub. If there are no statements, we'll report the
                    ' error, on the entire block, in CreateBlockSyntax instead.
                    If _statements.Count > 0 Then
                        _statements(0) = Parser.ReportSyntaxError(_statements(0), ERRID.ERR_SubRequiresSingleStatement)
                    End If
                    Return EndLambda()

            End Select

            Return PrevBlock
        End Function

        Friend Overrides ReadOnly Property IsSingleLine As Boolean
            Get
                Return True
            End Get
        End Property

        Private Shared Function IsSingleStatement(statement As VisualBasicSyntaxNode) As Boolean
            Select Case statement.Kind
                Case SyntaxKind.EmptyStatement,
                    SyntaxKind.MultiLineIfBlock,
                    SyntaxKind.SimpleDoLoopBlock,
                    SyntaxKind.DoWhileLoopBlock,
                    SyntaxKind.DoUntilLoopBlock,
                    SyntaxKind.DoLoopWhileBlock,
                    SyntaxKind.DoLoopUntilBlock,
                    SyntaxKind.ForBlock,
                    SyntaxKind.ForEachBlock,
                    SyntaxKind.SelectBlock,
                    SyntaxKind.WhileBlock,
                    SyntaxKind.WithBlock,
                    SyntaxKind.SyncLockBlock,
                    SyntaxKind.UsingBlock,
                    SyntaxKind.TryBlock
                    Return False
                Case Else
                    Return True
            End Select
        End Function

    End Class

End Namespace