typespec_rs 0.4.1

A Rust implementation of the TypeSpec type system — parser, checker, and emitter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

//! Emitter trait definition
//!
//! Defines the interface for emitting TypeSpec to various formats.

use crate::emit::EmitResult;
use crate::parser::{AstBuilder, AstNode, ParseResult};

/// Emitter trait for converting parsed TypeSpec to output formats
pub trait Emitter: Send + Sync {
    /// Emit the parsed TypeSpec to the target format
    fn emit(&self, result: &ParseResult) -> Result<EmitResult, String>;

    /// Get the format name (e.g., "yaml", "json", "markdown")
    fn format(&self) -> &str;
}

/// Get the identifier name from an AST node ID
pub(crate) fn get_name(builder: &AstBuilder, node_id: u32) -> String {
    if let Some(AstNode::Identifier(id)) = builder.nodes.get(&node_id) {
        id.value.clone()
    } else {
        "<unknown>".to_string()
    }
}

/// Get a type string representation from an AST node ID
pub(crate) fn get_type_string(builder: &AstBuilder, node_id: u32) -> String {
    match builder.nodes.get(&node_id) {
        Some(AstNode::Identifier(id)) => id.value.clone(),
        Some(AstNode::ArrayExpression(arr)) => {
            format!("{}[]", get_type_string(builder, arr.element_type))
        }
        Some(AstNode::TypeReference(tr)) => get_name(builder, tr.name),
        Some(AstNode::UnionExpression(u)) => {
            let opts: Vec<String> = u
                .options
                .iter()
                .map(|&opt| get_type_string(builder, opt))
                .collect();
            opts.join(" | ")
        }
        Some(AstNode::StringLiteral(s)) => format!("\"{}\"", s.value),
        Some(AstNode::NumericLiteral(n)) => n.value_as_string.clone(),
        Some(AstNode::BooleanLiteral(b)) => b.value.to_string(),
        _ => "<type>".to_string(),
    }
}