vhdl_syntax 0.2.0

VHDL parser for lossless concrete syntax trees
Documentation
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.
//
// Copyright (c)  2025, Lukas Scheller lukasscheller@icloud.com
/// Parsing of object declarations (LRM ยง6.4.2)
use crate::parser::marker::CompletedMarker;
use crate::parser::Parser;
use crate::syntax::node_kind::NodeKind::*;
use crate::syntax::NodeKind;
use crate::tokens::token_kind::Keyword as Kw;
use crate::tokens::TokenKind::{self, *};

#[derive(Eq, PartialEq)]
enum Object {
    Constant,
    Signal,
    Variable, // also includes shared variable
}

impl Object {
    pub(crate) fn kind(&self) -> NodeKind {
        match self {
            Object::Constant => ConstantDeclaration,
            Object::Signal => SignalDeclaration,
            Object::Variable => VariableDeclaration,
        }
    }

    pub(crate) fn initial_token(&self) -> TokenKind {
        match self {
            Object::Constant => Keyword(Kw::Constant),
            Object::Signal => Keyword(Kw::Signal),
            Object::Variable => Keyword(Kw::Variable),
        }
    }
}

impl Parser {
    pub(crate) fn constant_declaration(&mut self) -> CompletedMarker {
        self.any_object_declaration(Object::Constant)
    }

    pub(crate) fn signal_declaration(&mut self) -> CompletedMarker {
        self.any_object_declaration(Object::Signal)
    }

    pub(crate) fn variable_declaration(&mut self) -> CompletedMarker {
        self.any_object_declaration(Object::Variable)
    }

    fn any_object_declaration(&mut self, object: Object) -> CompletedMarker {
        self.node(object.kind(), |p| {
            if object == Object::Variable {
                p.opt_token(Keyword(Kw::Shared));
            }
            p.expect_token(object.initial_token());
            p.identifier_list();
            p.expect_token(Colon);
            p.subtype_indication();
            p.opt_tokens([Keyword(Kw::Register), Keyword(Kw::Bus)]);
            if p.next_is(ColonEq) {
                p.node(InitialValue, |p| {
                    p.skip(); // :=
                    p.expression();
                });
            }
            p.expect_token(SemiColon);
        })
    }

    pub(crate) fn file_declaration(&mut self) -> CompletedMarker {
        self.node(FileDeclaration, |p| {
            p.expect_token(Keyword(Kw::File));
            p.identifier_list();
            p.expect_token(Colon);
            p.subtype_indication();
            p.opt_file_open_information();
            p.expect_token(SemiColon);
        })
    }

    fn opt_file_open_information(&mut self) -> bool {
        if !self.next_is(Keyword(Kw::Open)) && !self.next_is(Keyword(Kw::Is)) {
            return false;
        }

        self.node(FileOpenInformation, |p| {
            if p.next_is(Keyword(Kw::Open)) {
                p.node(FileOpenKind, |p| {
                    p.skip(); // Kw::Open
                    p.expression();
                });
            }
            p.expect_token(Keyword(Kw::Is));
            p.expression();
        });
        true
    }
}

#[cfg(test)]
mod tests {
    use crate::parser::{test_utils::to_test_text, Parser};

    #[test]
    fn constant_declaration() {
        insta::assert_snapshot!(to_test_text(
            Parser::constant_declaration,
            "constant C1: std_ulogic;"
        ));
        insta::assert_snapshot!(to_test_text(
            Parser::constant_declaration,
            "constant C1,C2,C3: std_ulogic := '0';"
        ));
    }

    #[test]
    fn signal_declaration() {
        insta::assert_snapshot!(to_test_text(Parser::signal_declaration, "signal s1: bit;"));
        insta::assert_snapshot!(to_test_text(
            Parser::signal_declaration,
            "signal s, ss, sss : natural := 1;"
        ));
        insta::assert_snapshot!(to_test_text(
            Parser::signal_declaration,
            "signal reg_s: bit register;"
        ));
        insta::assert_snapshot!(to_test_text(
            Parser::signal_declaration,
            "signal bus_s: bit bus := '0';"
        ));
    }

    #[test]
    fn variable_declaration() {
        insta::assert_snapshot!(to_test_text(
            Parser::variable_declaration,
            "variable v1: bit;"
        ));
        insta::assert_snapshot!(to_test_text(
            Parser::variable_declaration,
            "variable v, vv, vvv : natural := 1;"
        ));
        insta::assert_snapshot!(to_test_text(
            Parser::variable_declaration,
            "shared variable shared_v: natural;"
        ));
        insta::assert_snapshot!(to_test_text(
            Parser::variable_declaration,
            "shared variable shared_v, shared_vv: natural;"
        ));
    }

    #[test]
    fn file_declaration() {
        insta::assert_snapshot!(to_test_text(Parser::file_declaration, "file v1: bit;"));
        insta::assert_snapshot!(to_test_text(
            Parser::file_declaration,
            "file f, ff, fff : natural;"
        ));
        insta::assert_snapshot!(to_test_text(
            Parser::file_declaration,
            "file f_path: bit is \"./path_to_file.txt\";"
        ));
        insta::assert_snapshot!(to_test_text(
            Parser::file_declaration,
            "file f_path: bit open WRITE_MODE is \"./path_to_file.txt\";"
        ));
    }

    #[test]
    fn parses_optional_expression() {
        insta::assert_snapshot!(to_test_text(
            Parser::constant_declaration,
            "constant foo : natural := 0;"
        ));
    }

    // MARK: Error recovery

    #[test]
    fn signal_missing_colon() {
        assert_recovery_snapshot!("signal clk std_logic;", Parser::signal_declaration);
    }

    #[test]
    fn signal_missing_type() {
        assert_recovery_snapshot!("signal clk : ;", Parser::signal_declaration);
    }

    #[test]
    fn signal_missing_trailing_semicolon() {
        assert_recovery_snapshot!("signal clk : std_logic", Parser::signal_declaration);
    }

    #[test]
    fn constant_missing_default_expression() {
        assert_recovery_snapshot!(
            "constant width : integer := ;",
            Parser::constant_declaration
        );
    }

    #[test]
    fn variable_missing_identifier() {
        assert_recovery_snapshot!("variable : integer;", Parser::variable_declaration);
    }
}