' 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 DeclarationContext
'-----------------------------------------------------------------------------
Imports InternalSyntaxFactory = Microsoft.CodeAnalysis.VisualBasic.Syntax.InternalSyntax.SyntaxFactory
 
Namespace Microsoft.CodeAnalysis.VisualBasic.Syntax.InternalSyntax
    Friend Class TypeBlockContext
        Inherits DeclarationContext
 
        Protected _inheritsDecls As CodeAnalysis.Syntax.InternalSyntax.SyntaxList(Of InheritsStatementSyntax)
        Private _implementsDecls As CodeAnalysis.Syntax.InternalSyntax.SyntaxList(Of ImplementsStatementSyntax)
        Protected _state As SyntaxKind
 
        Friend Sub New(contextKind As SyntaxKind, statement As StatementSyntax, prevContext As BlockContext)
            MyBase.New(contextKind, statement, prevContext)
 
            Debug.Assert(contextKind = SyntaxKind.ModuleBlock OrElse contextKind = SyntaxKind.ClassBlock OrElse
                              contextKind = SyntaxKind.StructureBlock OrElse contextKind = SyntaxKind.InterfaceBlock)
 
            Debug.Assert(BlockKind = SyntaxKind.ModuleBlock OrElse BlockKind = SyntaxKind.ClassBlock OrElse
                               BlockKind = SyntaxKind.StructureBlock OrElse BlockKind = SyntaxKind.InterfaceBlock)
 
            _state = SyntaxKind.None
        End Sub
 
        Friend Overrides Function ProcessSyntax(node As VisualBasicSyntaxNode) As BlockContext
 
            Do
                Select Case _state
                    Case SyntaxKind.None
                        Select Case node.Kind
                            Case SyntaxKind.InheritsStatement
                                _state = SyntaxKind.InheritsStatement
 
                            Case SyntaxKind.ImplementsStatement
                                _state = SyntaxKind.ImplementsStatement
 
                            Case Else
                                _state = SyntaxKind.ClassStatement
                        End Select
 
                    Case SyntaxKind.InheritsStatement
                        Select Case node.Kind
                            Case SyntaxKind.InheritsStatement
                                Add(node)
                                Exit Do
 
                            Case Else
                                _inheritsDecls = BaseDeclarations(Of InheritsStatementSyntax)()
                                _state = SyntaxKind.ImplementsStatement
                        End Select
 
                    Case SyntaxKind.ImplementsStatement
                        Select Case node.Kind
                            Case SyntaxKind.ImplementsStatement
                                Add(node)
                                Exit Do
 
                            Case Else
                                _implementsDecls = BaseDeclarations(Of ImplementsStatementSyntax)()
                                _state = SyntaxKind.ClassStatement ' done with base decls
                        End Select
 
                    Case Else
                        Return MyBase.ProcessSyntax(node)
 
                End Select
            Loop
 
            Return Me
        End Function
 
        Friend Overrides Function CreateBlockSyntax(endStmt As StatementSyntax) As VisualBasicSyntaxNode
 
            Dim beginBlockStmt As TypeStatementSyntax = Nothing
            Dim endBlockStmt As EndBlockStatementSyntax = DirectCast(endStmt, EndBlockStatementSyntax)
            GetBeginEndStatements(beginBlockStmt, endBlockStmt)
 
            If _state <> SyntaxKind.ClassStatement Then
                Select Case _state
                    Case SyntaxKind.InheritsStatement
                        _inheritsDecls = BaseDeclarations(Of InheritsStatementSyntax)()
 
                    Case SyntaxKind.ImplementsStatement
                        _implementsDecls = BaseDeclarations(Of ImplementsStatementSyntax)()
                End Select
                _state = SyntaxKind.ClassStatement
            End If
 
            Dim result = InternalSyntaxFactory.TypeBlock(BlockKind, beginBlockStmt,
                                          _inheritsDecls,
                                          _implementsDecls,
                                          Body(),
                                          endBlockStmt)
 
            FreeStatements()
 
            Return result
        End Function
 
    End Class
 
End Namespace