blues_lsp/syntax/preprocessor/

vpp.rs

use std::{borrow::Borrow, cell::Cell, ops::Range, path::PathBuf};

use arcstr::{Substr, literal_substr};

use crate::{
    bsc::args::BscArgs,
    project::Project,
    syntax::{
        TextChunk,
        buildctx::BuildCtx,
        diagnostic::Severity,
        location::{
            BUILTIN_ORIGIN, CLI_ORIGIN, FilePos, FileSpan, LineColCounter, Origin, OriginId,
            OriginReason, OriginTable, Pos, ROOT_ORIGIN, Span,
        },
        streams::{CharStream, ChunkWriter, TextCharStream},
        util::{bsv_horizontal_whitespace, bsv_ident, bsv_whitespace, vpp_malformed_param},
    },
    util::{
        ext::{
            arcstr::{EMPTY_SUBSTR, SubStrExt},
            cell::CellUpdateExt,
        },
        path::maybe_canonicalize,
    },
};

use super::Preprocessor;

#[derive(Debug)]
struct VppMacroDef {
    name: Substr,
    num_args: u32,
    parts: Vec<VppMacroPart>,
}

#[derive(Debug)]
enum VppMacroPart {
    Arg(usize, Span),
    Chunk(TextChunk),
    Concat(Pos),
}

#[derive(Debug)]
enum VppDefStmtKind {
    Def(VppMacroDef),
    Undef(Substr),
    UndefAll,
}

#[derive(Debug)]
struct VppDefStmt {
    span: Span,
    kind: VppDefStmtKind,
}

#[derive(Debug)]
pub struct VppDefs {
    items: Vec<VppDefStmt>,
}

impl VppDefs {
    fn populate(cli: &BscArgs) -> Self {
        let mut items = Vec::new();

        items.push(VppDefStmt {
            span: Span {
                origin: BUILTIN_ORIGIN,
                text_span: FileSpan::default(),
            },
            kind: VppDefStmtKind::Def(VppMacroDef {
                name: "bluespec".into(),
                num_args: 0,
                parts: Vec::new(),
            }),
        });

        items.push(VppDefStmt {
            span: Span {
                origin: BUILTIN_ORIGIN,
                text_span: FileSpan::default(),
            },
            kind: VppDefStmtKind::Def(VppMacroDef {
                name: "BLUESPEC".into(),
                num_args: 0,
                parts: Vec::new(),
            }),
        });

        for (name, val) in &cli.defines {
            let parts = if val.is_empty() {
                Vec::new()
            } else {
                vec![VppMacroPart::Chunk(TextChunk {
                    pos: Pos {
                        origin: CLI_ORIGIN,
                        text_pos: FilePos::default(),
                    },
                    text: val.into(),
                })]
            };

            items.push(VppDefStmt {
                span: Span {
                    origin: CLI_ORIGIN,
                    text_span: FileSpan::default(),
                },
                kind: VppDefStmtKind::Def(VppMacroDef {
                    name: name.into(),
                    num_args: 0,
                    parts,
                }),
            });
        }

        Self { items }
    }

    fn get(&self, name: &str) -> Option<(&Span, &VppMacroDef)> {
        for item in self.items.iter().rev() {
            match &item.kind {
                VppDefStmtKind::Def(def) if def.name == name => return Some((&item.span, def)),
                VppDefStmtKind::Undef(undef) if undef == name => return None,
                VppDefStmtKind::UndefAll => return None,
                _ => (),
            }
        }
        None
    }

    fn define(&mut self, def: VppMacroDef, span: Span) {
        self.items.push(VppDefStmt {
            span,
            kind: VppDefStmtKind::Def(def),
        });
    }

    fn undef(&mut self, name: Substr, span: Span) {
        self.items.push(VppDefStmt {
            span,
            kind: VppDefStmtKind::Undef(name),
        });
    }

    fn undef_all(&mut self, span: Span) {
        self.items.push(VppDefStmt {
            span,
            kind: VppDefStmtKind::UndefAll,
        });
    }
}

pub struct VppSpan {
    pub span: FileSpan,
    pub kind: VppSpanKind,
}

pub enum VppSpanKind {
    Escape,

    Include,
    IncludePath,

    Line,
    LineArgs,

    Define,
    DefineName,
    DefineParam,
    DefineBodyParam,
    DefineBodyConcat,
    DefineBodyEscape,
    DefineBodyComment,

    Undef,
    UndefName,

    ResetAll,

    Conditional,
    ConditionalArgTrue,
    ConditionalArgFalse,
    ConditionalDisabled,

    MacroCall,
}

pub struct VppPreprocessor<'ctx> {
    proj: &'ctx Project,
    ctx: &'ctx mut BuildCtx,
    pub spans: Vec<VppSpan>,

    defs: VppDefs,
}

impl<'ctx> VppPreprocessor<'ctx> {
    pub fn new(proj: &'ctx Project, ctx: &'ctx mut BuildCtx) -> Self {
        let defs = VppDefs::populate(&proj.get_pkg(ctx.pkg).cli);

        Self {
            proj,
            ctx,
            spans: Vec::new(),
            defs,
        }
    }

    // We know this will run to completion so we can take `inp` by value
    fn run<'a>(&mut self, mut inp: impl CharStream<'a>, out: &mut Vec<TextChunk>) {
        while let Some(c) = inp.peek() {
            match c {
                '`' => self.handle_directive(&mut inp, out),
                _ => self.handle_plain_text(&mut inp, out),
            }
        }
    }

    fn emit_str(&mut self, out: &mut Vec<TextChunk>, text: Substr, pos: Pos) {
        out.push(TextChunk { pos, text });
    }

    fn diag(&mut self, range: Range<Pos>, severity: Severity, message: String) {
        self.ctx.diagnostics.push(
            Span::cross_origin(range.start, range.end, &self.ctx.origins),
            severity,
            "VPP",
            message,
        );
    }

    fn span(&mut self, range: Range<Pos>, kind: VppSpanKind) {
        if range.start == range.end {
            return;
        }
        // TODO: Probably shouldn't allow cross-origin here?
        let span = Span::cross_origin(range.start, range.end, &self.ctx.origins);
        if span.origin != ROOT_ORIGIN {
            // Not visible in source file, skip.
            return;
        }
        self.spans.push(VppSpan {
            span: span.text_span,
            kind,
        });
    }

    fn handle_directive<'a>(&mut self, inp: &mut impl CharStream<'a>, out: &mut Vec<TextChunk>) {
        let pos = inp.pos();
        inp.expect('`');

        // character escape sequences (`" and `/)
        match inp.peek() {
            Some('"') => {
                inp.expect_any();
                self.span(pos..inp.pos(), VppSpanKind::Escape);
                self.emit_str(out, literal_substr!("\""), pos);
                return;
            }
            Some('\\') => {
                inp.expect_any();
                self.span(pos..inp.pos(), VppSpanKind::Escape);
                self.emit_str(out, literal_substr!("\\"), pos);
                return;
            }
            Some('`') => {
                inp.expect_any();
                self.diag(
                    pos..inp.pos(),
                    Severity::Error,
                    "macro catenation operators may only be used inside a macro definition.".into(),
                );
                return;
            }
            _ => (),
        }

        let directive = inp.read_while(bsv_ident);

        if directive.is_empty() {
            self.diag(
                pos..inp.pos(),
                Severity::Error,
                "missing preprocessor directive after '`'".into(),
            );
            return;
        }

        match directive.borrow() {
            "include" => self.handle_include(inp, out, pos),
            "line" => self.handle_line(inp, pos),
            "define" => self.handle_define(inp, pos),
            "undef" => self.handle_undef(inp, pos),
            "resetall" => self.handle_resetall(inp, pos),
            "ifdef" => self.handle_conditional(inp, out, pos, false),
            "ifndef" => self.handle_conditional(inp, out, pos, true),
            "elsif" => self.diag(
                pos..inp.pos(),
                Severity::Error,
                "unexpected '`elsif' directive".into(),
            ),
            "else" => self.diag(
                pos..inp.pos(),
                Severity::Error,
                "unexpected '`else' directive".into(),
            ),
            "endif" => self.diag(
                pos..inp.pos(),
                Severity::Error,
                "unexpected '`endif' directive".into(),
            ),
            _name => self.handle_expansion(inp, out, pos, &directive),
        }
    }

    fn handle_include<'a>(
        &mut self,
        inp: &mut impl CharStream<'a>,
        out: &mut Vec<TextChunk>,
        pos: Pos,
    ) {
        self.span(pos..inp.pos(), VppSpanKind::Include);

        // Skip whitespace:
        //         V
        // `include MACRO_NAME
        let ws = inp.skip_while(bsv_whitespace);
        if ws == 0 {
            self.diag(
                pos..inp.pos(),
                Severity::Error,
                "'`inlcude' directive must be followed by whitespace".into(),
            );
        }

        let closing_delim = match inp.peek() {
            Some('"') => '"',
            Some('<') => '>',
            Some('`') => {
                // TODO: macro expansion inside path specifier
                // eg.: `include `SOME_PATH
                let pos = inp.pos();
                inp.read_while(bsv_ident);
                self.diag(
                    pos..inp.pos(),
                    Severity::Error,
                    "macro expansion inside '`include' arguments is currently not supported in blues-lsp"
                        .into(),
                );
                return;
            }
            _ => {
                self.diag(
                    pos..inp.pos(),
                    Severity::Error,
                    "'`inlcude' directive is missing filename field".into(),
                );
                return;
            }
        };
        let open_delim_start = inp.pos();
        inp.next();
        let open_delim_range = open_delim_start..inp.pos();

        let path_start = inp.pos();
        let path = inp.read_while(|c| c != closing_delim);
        let path_range = path_start..inp.pos();

        let close_delim = inp.next();
        self.span(open_delim_start..inp.pos(), VppSpanKind::IncludePath);
        if close_delim != Some(closing_delim) {
            // TODO: a better error recovery?
            // This will only fail on EOF, meaning `include will scan the entire file as
            // a filepath, which is not ideal...
            // Ideally, we would just bail on newline, but that's not what bsc does.
            self.diag(
                open_delim_range,
                Severity::Error,
                format!(
                    "missing '{closing_delim}' closing delimeter for '`include' filename argument"
                ),
            );
            return;
        }

        let Some(path) = self.resolve_include_path(&path) else {
            self.diag(
                path_range,
                Severity::Error,
                format!("include file '{}' not found", path),
            );
            return;
        };

        let file = self.proj.lookup_file(&path);
        let file = self.proj.file_contents(file, self.ctx.pkg);

        let span = Span::cross_origin(pos, inp.pos(), &self.ctx.origins);
        let include_origin = self.ctx.origins.add(Origin {
            origin: span.origin,
            span: span.text_span,
            file: file.clone(),
            reason: OriginReason::Include,
        });

        let chunks = file.chunks(include_origin);
        let chars = TextCharStream::new(chunks.iter());

        self.run(chars, out);
    }

    fn resolve_include_path(&mut self, path: &str) -> Option<PathBuf> {
        // TODO: review against bsc

        let path = PathBuf::from(path);

        if path.is_absolute() {
            return Some(path);
        }

        let pkg = self.proj.get_pkg(self.ctx.pkg);

        for dir in pkg.cli.include_dirs_all() {
            let path = dir.join(&path);

            if path.is_file() {
                return Some(maybe_canonicalize(&path));
            }
        }

        None
    }

    fn handle_line<'a>(&mut self, inp: &mut impl CharStream<'a>, pos: Pos) {
        self.span(pos..inp.pos(), VppSpanKind::Line);
        let args_start = inp.pos();
        // 'line directives...
        // Just do the bare minimum to skip them and move on.
        // TODO: We could lint their arguments...
        match inp.peek() {
            Some('(') => {
                inp.skip_while(|c| c != ')');
                if inp.peek() == Some(')') {
                    inp.next();
                } else {
                    self.diag(
                        pos..inp.pos(),
                        Severity::Error,
                        "'`line' arguments are missing a closing ')'".into(),
                    );
                }
            }
            Some(c) if bsv_whitespace(c) => {
                inp.skip_while(|c| c != '\n');
                if inp.peek() == Some('\n') {
                    inp.next();
                }
            }
            _ => {
                self.diag(
                    pos..inp.pos(),
                    Severity::Error,
                    "'`line' must be directly followed by '(' or whitespace".into(),
                );
            }
        }
        self.span(args_start..inp.pos(), VppSpanKind::LineArgs);
    }

    fn handle_undef<'a>(&mut self, inp: &mut impl CharStream<'a>, pos: Pos) {
        self.span(pos..inp.pos(), VppSpanKind::Undef);
        inp.skip_while(bsv_whitespace);

        let name_start = inp.pos();
        let name = inp.read_while(bsv_ident);
        self.span(name_start..inp.pos(), VppSpanKind::UndefName);

        if name.is_empty() {
            self.diag(
                pos..inp.pos(),
                Severity::Error,
                "'`undef' directive is missing a macro name".into(),
            );
            return;
        }
        let span = Span::cross_origin(pos, inp.pos(), &self.ctx.origins);
        self.defs.undef(name, span);
    }

    fn handle_resetall<'a>(&mut self, inp: &impl CharStream<'a>, pos: Pos) {
        self.span(pos..inp.pos(), VppSpanKind::ResetAll);
        let span = Span::cross_origin(pos, inp.pos(), &self.ctx.origins);
        self.defs.undef_all(span);
    }

    fn handle_define<'a>(&mut self, inp: &mut impl CharStream<'a>, pos: Pos) {
        self.span(pos..inp.pos(), VppSpanKind::Define);
        // Skip whitespace:
        //        V
        // `define MACRO_NAME
        inp.skip_while(bsv_whitespace);

        // Read identifier:
        //         .--------.
        // `define MACRO_NAME
        let id_start = inp.pos();
        let id = inp.read_while(bsv_ident);
        let id_range = id_start..inp.pos();
        self.span(id_range.clone(), VppSpanKind::DefineName);
        if id.is_empty() {
            self.diag(
                pos..inp.pos(),
                Severity::Error,
                "'`define' directive is missing a name".into(),
            );
        }

        // https://github.com/B-Lang-org/bsc/blob/a798d8a94d54197d2b4755afdbb460cdc559c151/src/comp/SystemVerilogPreprocess.lhs#L229
        #[rustfmt::skip]
        const RESERVED_KWS: &[&str] = &[
            "celldefine", "default_nettype", "define", "else", "elsif", "endcelldefine",
            "endif", "ifdef", "ifndef", "include", "line", "nounconnected_drive", "resetall",
            "timescale", "unconnected_drive", "undef", "bluespec", "BLUESPEC"
        ];

        if RESERVED_KWS.iter().any(|kw| *kw == id.as_str()) {
            self.diag(
                id_range,
                Severity::Error,
                format!("reserved keyword '{id}' cannot be used as a macro name"),
            );
        }

        // TODO: also validate first character of name

        // Skip whitespace after ID:
        //                   V                         V
        // `define MACRO_NAME ()  |  `define MACRO_NAME BODY
        inp.skip_while(bsv_horizontal_whitespace);

        // Parse param names:
        let params: Vec<Substr> = match inp.peek() {
            // `define MACRO_NAME(a, b, c) BODY
            Some('(') => {
                // Consume leading '('
                let open_delim_start = inp.pos();
                inp.expect_any();
                let open_delim_range = open_delim_start..inp.pos();
                let params = self.read_param_list(inp);

                match inp.peek() {
                    Some(')') => inp.expect_any(),
                    None => {
                        self.diag(
                            open_delim_range,
                            Severity::Error,
                            "macro parameter list is missing a closing ')'".into(),
                        );
                    }
                    _ => unreachable!("read_define_params should only terminate on  ')' or EOF"),
                }

                params
            }
            // `define MACRO_NAME BODY
            _ => Vec::new(),
        };

        let parts = self.read_macro_body(inp, &params);

        let span = Span::cross_origin(pos, inp.pos(), &self.ctx.origins);

        self.defs.define(
            VppMacroDef {
                name: id,
                num_args: params.len() as u32,
                parts,
            },
            span,
        );
    }

    fn read_param_list<'a>(&mut self, inp: &mut impl CharStream<'a>) -> Vec<Substr> {
        // Immediate ')' - empty param list
        if let Some(')') = inp.peek() {
            return Vec::new();
        }

        let mut params = Vec::new();
        let mut empty_field = true;

        while let Some(c) = inp.peek() {
            match c {
                ',' | ')' => {
                    if empty_field {
                        self.diag(
                            inp.pos()..inp.pos(),
                            Severity::Warning,
                            "empty macro parameter fields are not counted as additional parameters"
                                .into(),
                        );
                    }

                    if c == ',' {
                        empty_field = true;
                        inp.expect_any();
                    } else if c == ')' {
                        break;
                    }
                }
                _ => {
                    empty_field = false;
                    params.push(self.read_param(inp))
                }
            }
        }

        params
    }

    fn read_param<'a>(&mut self, inp: &mut impl CharStream<'a>) -> Substr {
        let field_start = inp.pos();
        inp.skip_while(bsv_whitespace);
        let name_start = inp.pos();
        let mut name_end = None;

        let mut has_id_chars = false;
        let mut has_non_id_chars = false;
        let mut has_omited_chars = false;
        let mut name = EMPTY_SUBSTR;

        while let Some(c) = inp.peek() {
            match c {
                ',' | ')' => break,
                '\\' => {
                    has_omited_chars = true;
                    inp.expect_any();
                }
                c if bsv_whitespace(c) => {
                    name_end = Some(inp.pos());
                    inp.skip_while(bsv_whitespace);
                    if !matches!(inp.peek(), None | Some(',') | Some(')')) {
                        name_end = None;
                        has_omited_chars = true;
                    }
                }
                c if bsv_ident(c) => {
                    has_id_chars = true;

                    if has_id_chars && has_non_id_chars {
                        inp.skip_while(bsv_ident);
                    } else {
                        name.append(inp.read_while(bsv_ident))
                    }
                }
                _ => {
                    has_non_id_chars = true;

                    if has_id_chars && has_non_id_chars {
                        inp.skip_while(vpp_malformed_param);
                    } else {
                        name.append(inp.read_while(vpp_malformed_param))
                    }
                }
            }
        }

        let name_end = name_end.unwrap_or(inp.pos());

        let name_range = name_start..name_end;
        self.span(name_range.clone(), VppSpanKind::DefineParam);

        if has_omited_chars {
            self.diag(
                name_range.clone(),
                Severity::Warning,
                format!(
                    "whitespace and '\\' characters are ommited from parameter names.
This parameter name will be seen as '{name}' by the preprocessor."
                ),
            );
        }
        if has_non_id_chars {
            self.diag(
                name_range,
                Severity::Warning,
                format!("macro parameter '{name}' contains non-id characters"),
            );
        }
        if name.is_empty() {
            self.diag(
                field_start..inp.pos(),
                Severity::Warning,
                "empty macro parameter name".to_string(),
            );
        }

        if has_id_chars && has_non_id_chars {
            // If we have both, we know it won't bind to anything
            EMPTY_SUBSTR
        } else {
            name
        }
    }

    fn read_macro_body<'a>(
        &mut self,
        inp: &mut impl CharStream<'a>,
        params: &[Substr],
    ) -> Vec<VppMacroPart> {
        let output = Cell::new(Vec::new());
        let mut sub = inp
            .chunk_state()
            .writer(|c| output.update(|v: &mut Vec<VppMacroPart>| v.push(VppMacroPart::Chunk(c))));

        // TODO: this should be split into smaller functions...
        while let Some(c) = sub.peek() {
            match c {
                // Possible start of comment
                '/' => {
                    let start = sub.pos();
                    let mut la = sub.chars().clone();
                    la.next();

                    match la.peek() {
                        Some('/') => {
                            sub.skip();
                            if !self.scan_line_comment(&mut sub.skipped(), true) {
                                continue;
                            }
                            self.span(start..sub.pos(), VppSpanKind::DefineBodyComment);
                            if let Some('\n') = sub.peek() {
                                sub.advance();
                            }
                        }
                        Some('*') => {
                            sub.skip();
                            self.scan_block_comment(&mut sub.skipped());
                            self.span(start..sub.pos(), VppSpanKind::DefineBodyComment);
                        }
                        _ => sub.advance(),
                    }
                }

                // Possible escaped newline
                '\\' => {
                    let start = sub.pos();
                    let mut la = sub.chars().clone();
                    la.next();

                    while let Some('\r') = sub.peek() {
                        la.next();
                    }
                    let Some('\n') = la.peek() else {
                        sub.advance();
                        continue;
                    };

                    sub.skip();
                    self.span(start..sub.pos(), VppSpanKind::DefineBodyEscape);
                    // TODO: bsc handling of this is a bit weird,
                    // weird line endings could do with a lint.
                    while let Some('\r') = sub.peek() {
                        sub.skip();
                    }
                    sub.check('\n');
                    sub.advance();
                }

                // Terminating newline
                '\n' => {
                    sub.advance();
                    break;
                }

                // Possible arg expansions
                c if bsv_ident(c) => {
                    if !self.handle_possible_arg_inst(&mut sub, params, &output, bsv_ident) {
                        // Include ident chars in output if not a param
                        sub.advance_while(bsv_ident);
                    }
                }
                c if vpp_malformed_param(c) => {
                    if self.handle_possible_arg_inst(&mut sub, params, &output, vpp_malformed_param)
                    {
                        continue;
                    }
                    // If not a param, check for existance of ``
                    while let Some(c) = sub.peek() {
                        if !vpp_malformed_param(c) {
                            break;
                        }
                        if c != '`' {
                            sub.advance();
                            continue;
                        }
                        let mut la = sub.chars().clone();
                        la.next();
                        if let Some('`') = la.peek() {
                            sub.flush();
                            let pos = sub.pos();
                            output.update(|v| v.push(VppMacroPart::Concat(pos)));
                            sub.check('`');
                            sub.skip();
                            sub.check('`');
                            sub.skip();
                            self.span(pos..sub.pos(), VppSpanKind::DefineBodyConcat);
                        } else {
                            sub.advance();
                        }
                    }
                }

                // General case, advance one char
                _ => sub.advance(),
            }
        }

        sub.flush();
        output.into_inner()
    }

    fn handle_possible_arg_inst<'a>(
        &mut self,
        sub: &mut impl ChunkWriter<'a>,
        params: &[Substr],
        output: &Cell<Vec<VppMacroPart>>,
        name_pred: impl Fn(char) -> bool,
    ) -> bool {
        let mut la = sub.chars().clone();
        let name = la.read_while(&name_pred);
        // Find a matching param name
        if let Some((i, _)) = params.iter().enumerate().find(|e| e.1 == &name) {
            // Param found, push it to macro body
            sub.flush();
            let start = sub.pos();
            // Omit name use from plain output
            sub.skip_while(&name_pred);
            self.span(start..sub.pos(), VppSpanKind::DefineBodyParam);
            output.update(|v| {
                v.push(VppMacroPart::Arg(
                    i,
                    Span::cross_origin(start, sub.pos(), &self.ctx.origins),
                ))
            });
            true
        } else {
            // Param not found, leave it to user
            false
        }
    }

    fn handle_conditional<'a>(
        &mut self,
        inp: &mut impl CharStream<'a>,
        out: &mut Vec<TextChunk>,
        pos: Pos,
        inverted: bool,
    ) {
        self.span(pos..inp.pos(), VppSpanKind::Conditional);
        inp.skip_while(bsv_whitespace);

        let name_start = inp.pos();
        let name = inp.read_while(bsv_ident);
        let mut condition = if name.is_empty() {
            self.diag(
                pos..inp.pos(),
                Severity::Error,
                "'`ifdef'/'`ifdef' directive is missing a macro name".into(),
            );
            false
        } else {
            self.defs.get(&name).is_some()
        };
        self.span(
            name_start..inp.pos(),
            if condition {
                VppSpanKind::ConditionalArgTrue
            } else {
                VppSpanKind::ConditionalArgFalse
            },
        );

        if inverted {
            condition = !condition;
        }

        // Have we passed an `else
        let mut post_else = false;
        // Have we found a positive branch
        let mut found = false;

        let mut body = Vec::new();

        while inp.peek().is_some() {
            let body_start = inp.pos();
            self.scan_conditional_body(inp, &mut body);
            if condition && !found {
                self.run(TextCharStream::new(body.iter()), out);
                found = true;
            } else {
                self.span(body_start..inp.pos(), VppSpanKind::ConditionalDisabled);
            }
            body.clear();

            if inp.peek().is_none() {
                break;
            }

            let directive_start = inp.pos();
            inp.expect('`');
            let directive = inp.read_while(bsv_ident);
            let directive_range = directive_start..inp.pos();
            self.span(directive_range.clone(), VppSpanKind::Conditional);

            match directive.as_str() {
                "elseif" => {
                    if post_else {
                        self.diag(
                            directive_range,
                            Severity::Error,
                            "'`elseif' following a '`else' directive".into(),
                        );
                    }

                    inp.skip_while(bsv_whitespace);
                    let name_start = inp.pos();
                    let name = inp.read_while(bsv_ident);

                    if name.is_empty() {
                        self.diag(
                            pos..inp.pos(),
                            Severity::Error,
                            "'`elseif' directive is missing a macro name".into(),
                        );
                        condition = false;
                    } else {
                        condition = self.defs.get(&name).is_some();
                    }
                    self.span(
                        name_start..inp.pos(),
                        if condition {
                            VppSpanKind::ConditionalArgTrue
                        } else {
                            VppSpanKind::ConditionalArgFalse
                        },
                    );
                }
                "else" => {
                    if post_else {
                        self.diag(
                            directive_range,
                            Severity::Error,
                            "'`else' following a '`else' directive".into(),
                        );
                    }

                    condition = true;
                    post_else = true;
                }
                "endif" => {
                    break;
                }
                _ => unreachable!(),
            }
        }
    }

    fn scan_conditional_body<'a>(
        &mut self,
        inp: &mut impl CharStream<'a>,
        out: &mut Vec<TextChunk>,
    ) {
        let mut depth = 0;
        let mut sub = inp.chunk_state().writer(|c| out.push(c));

        while let Some(c) = sub.peek() {
            match c {
                '`' => {
                    let mut la = sub.chars().clone();
                    let directive_start = la.pos();
                    la.expect('`');
                    let name = la.read_while(bsv_ident);
                    let directive_range = directive_start..la.pos();
                    match name.as_str() {
                        "ifdef" | "ifndef" => {
                            sub.advance();
                            sub.advance_while(bsv_ident);
                            if sub.peek().is_some_and(bsv_whitespace) {
                                depth += 1;
                            } else {
                                self.diag(
                                    directive_range,
                                    Severity::Warning,
                                    "nested branching directives must be followed by whitespace to be recognized".into()
                                );
                            }
                        }
                        "elseif" | "else" | "endif" if depth == 0 => {
                            if la.peek().is_some_and(bsv_whitespace) {
                                break;
                            } else {
                                sub.advance();
                                sub.advance_while(bsv_ident);
                                self.diag(
                                    directive_range,
                                    Severity::Warning,
                                    "nested branching directives must be followed by whitespace to be recognized".into()
                                );
                            }
                        }
                        "else" => {
                            sub.advance();
                            sub.advance_while(bsv_ident);
                            if !sub.peek().is_some_and(bsv_whitespace) {
                                self.diag(
                                    directive_range,
                                    Severity::Warning,
                                    "nested branching directives must be followed by whitespace to be recognized".into()
                                );
                            }
                        }
                        "elseif" | "endif" => {
                            sub.advance();
                            sub.advance_while(bsv_ident);
                            if sub.peek().is_some_and(bsv_whitespace) {
                                depth -= 1;
                            } else {
                                self.diag(
                                    directive_range,
                                    Severity::Warning,
                                    "nested branching directives must be followed by whitespace to be recognized".into()
                                );
                            }
                        }
                        _ => {
                            sub.advance();
                            sub.advance_while(bsv_ident);
                        }
                    };
                }
                _ => sub.advance(),
            }
        }

        sub.flush();
    }

    fn handle_expansion<'a>(
        &mut self,
        inp: &mut impl CharStream<'a>,
        out: &mut Vec<TextChunk>,
        pos: Pos,
        name: &str,
    ) {
        self.span(pos..inp.pos(), VppSpanKind::MacroCall);
        // There is a difference between `FOO and `FOO(), so we represent them differently
        let mut has_arg_list = false;
        // TODO: This is certainly a place where some sort of SSO vec would be nice
        let args: Vec<Vec<TextChunk>> = match inp.peek() {
            Some('(') => {
                has_arg_list = true;
                // TODO: We currently do not run argument lists through preprocessor before
                // expansion. This will produce different ouput from bsc in some cases.
                self.read_expansion_args(inp)
            }
            _ => Vec::new(),
        };

        let Some((_, def)) = self.defs.get(name) else {
            self.diag(
                pos..inp.pos(),
                Severity::Error,
                format!("missing macro definition for {name}"),
            );
            return;
        };

        if args.len() != def.num_args as usize {
            // Inline `Self::diag` call to apease borrowchecking gods.
            self.ctx.diagnostics.push(
                Span::cross_origin(pos, inp.pos(), &self.ctx.origins),
                Severity::Error,
                "VPP",
                format!(
                    "macro argument count mismatch, expected {}, got {}",
                    def.num_args,
                    args.len()
                ),
            );
        }

        let origins = &mut self.ctx.origins;
        let mut state = MacroExpansionState::new(
            Span::cross_origin(pos, inp.pos(), origins),
            OriginReason::Macro,
        );

        let mut has_concat = false;

        for part in &def.parts {
            match part {
                VppMacroPart::Arg(arg, span) => {
                    let Some(arg) = args.get(*arg) else {
                        continue;
                    };

                    let mut span = *span;
                    span.origin = state.augment(origins, span.origin);
                    let mut interp_state =
                        MacroExpansionState::new(span, OriginReason::MacroInterp);

                    for chunk in arg {
                        interp_state.push(origins, chunk.clone());
                    }
                }
                VppMacroPart::Chunk(chunk) => {
                    state.push(origins, chunk.clone());
                }
                VppMacroPart::Concat(pos) => {
                    if !has_arg_list {
                        // bsc currently does not perform catenation if macro is invoked
                        // without an arg list (`FOO).
                        has_concat = true;
                        state.push(
                            origins,
                            TextChunk {
                                pos: *pos,
                                text: literal_substr!("``"),
                            },
                        );
                        continue;
                    }

                    // Trim whitespace before concat operator
                    while let Some(chunk) = state.expanded.last_mut() {
                        let trimmed = chunk
                            .text
                            .substr_using(|s| s.trim_end_matches(bsv_whitespace));
                        if trimmed.is_empty() {
                            state.expanded.pop();
                        } else {
                            chunk.text = trimmed;
                            break;
                        }
                    }
                    state.need_trim = true;
                }
            }
        }

        if !has_arg_list && has_concat {
            self.diag(
                pos..inp.pos(),
                Severity::Hint,
                format!(
                    "macro catenation operators '``' only work if the macro is called with an empty argument list: '{name}()'"
                )
            );
        }

        // Run expanded macro through preprocessor again.
        self.run(TextCharStream::new(state.expanded.iter()), out);
    }

    fn read_expansion_args<'a>(&mut self, inp: &mut impl CharStream<'a>) -> Vec<Vec<TextChunk>> {
        let pos = inp.pos();
        let mut args = Vec::new();
        inp.expect('(');

        while let Some(c) = inp.peek() {
            if c == ')' {
                break;
            }

            let mut depth = 0;
            let mut arg = Vec::new();
            let mut sub = inp.chunk_state().writer(|c| arg.push(c));

            while let Some(c) = sub.peek() {
                match c {
                    ',' if depth == 0 => {
                        sub.flush();
                        inp.next();
                        break;
                    }
                    ')' if depth == 0 => {
                        sub.flush();
                        break;
                    }
                    '(' => {
                        depth += 1;
                        sub.advance();
                    }
                    ')' => {
                        depth -= 1;
                        sub.advance();
                    }
                    '`' => {
                        let pos = sub.pos();
                        sub.advance();
                        sub.advance_while(bsv_ident);
                        self.diag(
                            pos..sub.pos(),
                            Severity::Information,
                            "macro expansion inside macro argument lists is currently not performed by blues-lsp, behavior may diverge from bsc".into()
                        );
                    }
                    _ => sub.advance(),
                }
            }

            args.push(arg);
        }

        if inp.peek() != Some(')') {
            self.diag(
                pos..inp.pos(),
                Severity::Error,
                "macro argument list is missing a closing ')'".into(),
            );
        }
        inp.next();

        args
    }

    fn handle_plain_text<'a>(&mut self, inp: &mut impl CharStream<'a>, out: &mut Vec<TextChunk>) {
        let mut sub = inp.chunk_state().writer(|c| out.push(c));

        while let Some(c) = sub.peek() {
            match c {
                '`' => break,
                '/' => {
                    sub.advance();
                    match sub.peek() {
                        Some('/') => {
                            self.scan_line_comment(&mut sub, false);
                        }
                        Some('*') => self.scan_block_comment(&mut sub),
                        _ => continue,
                    }
                }
                _ => sub.advance(),
            }
        }

        sub.flush();
    }

    /// Returns `true` if terminating newline was escaped
    fn scan_line_comment<'a>(
        &mut self,
        sub: &mut impl ChunkWriter<'a>,
        handle_lf_escape: bool,
    ) -> bool {
        while let Some(c) = sub.peek() {
            match c {
                '\\' if handle_lf_escape => {
                    let pos = sub.pos();
                    sub.advance();
                    match sub.peek() {
                        Some('\r') => {
                            // bsc currently does not handle non-terminating line
                            // comments on non-LF line endings
                            self.diag(
                                pos..sub.pos(),
                                Severity::Warning,
                                "escaping line endings inside a line comment, inside a macro definition does not work with CRLF or CR line endings".into()
                            );
                        }
                        Some('\n') => {
                            return true;
                        }
                        _ => (),
                    }
                }
                // We only handle LF and CRLF line endings to follow bsc
                '\n' => return false,
                _ => sub.advance(),
            }
        }
        false
    }

    fn scan_block_comment<'a>(&self, sub: &mut impl ChunkWriter<'a>) {
        sub.advance();

        while let Some(c) = sub.peek() {
            match c {
                '*' => {
                    sub.advance();
                    if let Some('/') = sub.peek() {
                        sub.advance();
                        break;
                    }
                }
                _ => sub.advance(),
            }
        }
    }
}

impl<'src> Preprocessor<'src> for VppPreprocessor<'_> {
    fn process<I: CharStream<'src>>(&mut self, input: I, output: &mut Vec<TextChunk>) {
        self.run(input, output);
    }
}

// Ad hoc state for filling in expanded macro text
struct MacroExpansionState {
    // Span in parent origin
    parent_span: Span,

    // Mapping from underlying origins to new, augmented ones
    // TODO: techicaly we only need a mapping file -> new origin,
    // but this is easier for now.
    origins: Vec<(OriginId, OriginId)>, // old -> new

    // Do we need to trim whitespace (after concat operator)?
    need_trim: bool,

    // Chunks for the expanded macro contents
    expanded: Vec<TextChunk>,

    reason: OriginReason,
}

impl MacroExpansionState {
    fn new(parent_span: Span, reason: OriginReason) -> Self {
        Self {
            parent_span,
            origins: Vec::new(),
            need_trim: false,
            expanded: Vec::new(),
            reason,
        }
    }

    fn augment(&mut self, origins: &mut OriginTable, origin: OriginId) -> OriginId {
        match self.origins.iter().find(|o| o.0 == origin) {
            Some((_, new_origin)) => *new_origin,
            None => {
                let new_origin = origins.add(Origin {
                    origin: self.parent_span.origin,
                    span: self.parent_span.text_span,
                    file: origins.get(origin).file.clone(),
                    reason: self.reason,
                });
                self.origins.push((origin, new_origin));
                new_origin
            }
        }
    }

    fn push(&mut self, origins: &mut OriginTable, chunk: TextChunk) {
        let mut pos = chunk.pos.text_pos;
        let mut text = chunk.text;

        if self.need_trim {
            let mut counter = LineColCounter::start_at(pos);
            text = text.substr_using(|s| {
                s.trim_matches(|c| {
                    if bsv_whitespace(c) {
                        counter.advance(c);
                        true
                    } else {
                        false
                    }
                })
            });
            if let Some(c) = text.chars().next() {
                pos = counter.pos(Some(c));
                self.need_trim = false;
            } else {
                // Chunk is empty after trimming
                return;
            }
        }

        let new_origin = self.augment(origins, chunk.pos.origin);

        self.expanded.push(TextChunk {
            pos: Pos {
                origin: new_origin,
                text_pos: pos,
            },
            text,
        });
    }
}