harn_lexer/
token.rs

1use std::fmt;
2
3/// A segment of an interpolated string.
4#[derive(Debug, Clone, PartialEq)]
5pub enum StringSegment {
6    Literal(String),
7    Expression(String),
8}
9
10impl fmt::Display for StringSegment {
11    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12        match self {
13            StringSegment::Literal(s) => write!(f, "{s}"),
14            StringSegment::Expression(e) => write!(f, "${{{e}}}"),
15        }
16    }
17}
18
19/// Source location for error reporting.
20#[derive(Debug, Clone, Copy, PartialEq, Eq)]
21pub struct Span {
22    /// Byte offset from start of source (inclusive).
23    pub start: usize,
24    /// Byte offset from start of source (exclusive).
25    pub end: usize,
26    /// 1-based line number of start position.
27    pub line: usize,
28    /// 1-based column number of start position.
29    pub column: usize,
30    /// 1-based line number of end position (for multiline span detection).
31    pub end_line: usize,
32}
33
34impl Span {
35    pub fn with_offsets(start: usize, end: usize, line: usize, column: usize) -> Self {
36        Self {
37            start,
38            end,
39            line,
40            column,
41            end_line: line,
42        }
43    }
44
45    /// Create a span covering two spans (from start of `a` to end of `b`).
46    pub fn merge(a: Span, b: Span) -> Span {
47        Span {
48            start: a.start,
49            end: b.end,
50            line: a.line,
51            column: a.column,
52            end_line: b.end_line,
53        }
54    }
55
56    /// A dummy span for synthetic/generated nodes.
57    pub fn dummy() -> Self {
58        Self {
59            start: 0,
60            end: 0,
61            line: 0,
62            column: 0,
63            end_line: 0,
64        }
65    }
66}
67
68impl fmt::Display for Span {
69    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
70        write!(f, "{}:{}", self.line, self.column)
71    }
72}
73
74/// Token kinds produced by the lexer.
75#[derive(Debug, Clone, PartialEq)]
76pub enum TokenKind {
77    // Keywords
78    Pipeline,
79    Extends,
80    Override,
81    Let,
82    Var,
83    If,
84    Else,
85    For,
86    In,
87    Match,
88    Retry,
89    Parallel,
90    ParallelMap,
91    Return,
92    Import,
93    True,
94    False,
95    Nil,
96    Try,
97    Catch,
98    Throw,
99    Finally,
100    Fn,
101    Spawn,
102    While,
103    TypeKw,
104    Enum,
105    Struct,
106    Interface,
107    Pub,
108    From,
109    Thru,
110    Upto,
111    Guard,
112    Ask,
113    Deadline,
114    Yield,
115    Mutex,
116    Break,
117    Continue,
118    Select,
119
120    // Literals
121    Identifier(String),
122    StringLiteral(String),
123    InterpolatedString(Vec<StringSegment>),
124    IntLiteral(i64),
125    FloatLiteral(f64),
126    /// Duration literal in milliseconds: 500ms, 5s, 30m, 2h
127    DurationLiteral(u64),
128
129    // Two-character operators
130    Eq,            // ==
131    Neq,           // !=
132    And,           // &&
133    Or,            // ||
134    Pipe,          // |>
135    NilCoal,       // ??
136    QuestionDot,   // ?.
137    Arrow,         // ->
138    Lte,           // <=
139    Gte,           // >=
140    PlusAssign,    // +=
141    MinusAssign,   // -=
142    StarAssign,    // *=
143    SlashAssign,   // /=
144    PercentAssign, // %=
145
146    // Single-character operators
147    Assign,   // =
148    Not,      // !
149    Dot,      // .
150    Plus,     // +
151    Minus,    // -
152    Star,     // *
153    Slash,    // /
154    Percent,  // %
155    Lt,       // <
156    Gt,       // >
157    Question, // ?
158    Bar,      // |  (for union types)
159
160    // Delimiters
161    LBrace,    // {
162    RBrace,    // }
163    LParen,    // (
164    RParen,    // )
165    LBracket,  // [
166    RBracket,  // ]
167    Comma,     // ,
168    Colon,     // :
169    Semicolon, // ;
170
171    // Comments
172    LineComment(String),  // // text
173    BlockComment(String), // /* text */
174
175    // Special
176    Newline,
177    Eof,
178}
179
180impl fmt::Display for TokenKind {
181    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
182        match self {
183            TokenKind::Pipeline => write!(f, "pipeline"),
184            TokenKind::Extends => write!(f, "extends"),
185            TokenKind::Override => write!(f, "override"),
186            TokenKind::Let => write!(f, "let"),
187            TokenKind::Var => write!(f, "var"),
188            TokenKind::If => write!(f, "if"),
189            TokenKind::Else => write!(f, "else"),
190            TokenKind::For => write!(f, "for"),
191            TokenKind::In => write!(f, "in"),
192            TokenKind::Match => write!(f, "match"),
193            TokenKind::Retry => write!(f, "retry"),
194            TokenKind::Parallel => write!(f, "parallel"),
195            TokenKind::ParallelMap => write!(f, "parallel_map"),
196            TokenKind::Return => write!(f, "return"),
197            TokenKind::Import => write!(f, "import"),
198            TokenKind::True => write!(f, "true"),
199            TokenKind::False => write!(f, "false"),
200            TokenKind::Nil => write!(f, "nil"),
201            TokenKind::Try => write!(f, "try"),
202            TokenKind::Catch => write!(f, "catch"),
203            TokenKind::Throw => write!(f, "throw"),
204            TokenKind::Finally => write!(f, "finally"),
205            TokenKind::Fn => write!(f, "fn"),
206            TokenKind::Spawn => write!(f, "spawn"),
207            TokenKind::While => write!(f, "while"),
208            TokenKind::TypeKw => write!(f, "type"),
209            TokenKind::Enum => write!(f, "enum"),
210            TokenKind::Struct => write!(f, "struct"),
211            TokenKind::Interface => write!(f, "interface"),
212            TokenKind::Pub => write!(f, "pub"),
213            TokenKind::From => write!(f, "from"),
214            TokenKind::Thru => write!(f, "thru"),
215            TokenKind::Upto => write!(f, "upto"),
216            TokenKind::Guard => write!(f, "guard"),
217            TokenKind::Ask => write!(f, "ask"),
218            TokenKind::Deadline => write!(f, "deadline"),
219            TokenKind::Yield => write!(f, "yield"),
220            TokenKind::Mutex => write!(f, "mutex"),
221            TokenKind::Break => write!(f, "break"),
222            TokenKind::Continue => write!(f, "continue"),
223            TokenKind::Select => write!(f, "select"),
224            TokenKind::Identifier(s) => write!(f, "id({s})"),
225            TokenKind::StringLiteral(s) => write!(f, "str({s})"),
226            TokenKind::InterpolatedString(_) => write!(f, "istr(...)"),
227            TokenKind::IntLiteral(n) => write!(f, "int({n})"),
228            TokenKind::FloatLiteral(n) => write!(f, "float({n})"),
229            TokenKind::DurationLiteral(ms) => write!(f, "duration({ms}ms)"),
230            TokenKind::Eq => write!(f, "=="),
231            TokenKind::Neq => write!(f, "!="),
232            TokenKind::And => write!(f, "&&"),
233            TokenKind::Or => write!(f, "||"),
234            TokenKind::Pipe => write!(f, "|>"),
235            TokenKind::NilCoal => write!(f, "??"),
236            TokenKind::QuestionDot => write!(f, "?."),
237            TokenKind::Arrow => write!(f, "->"),
238            TokenKind::Lte => write!(f, "<="),
239            TokenKind::Gte => write!(f, ">="),
240            TokenKind::PlusAssign => write!(f, "+="),
241            TokenKind::MinusAssign => write!(f, "-="),
242            TokenKind::StarAssign => write!(f, "*="),
243            TokenKind::SlashAssign => write!(f, "/="),
244            TokenKind::PercentAssign => write!(f, "%="),
245            TokenKind::Assign => write!(f, "="),
246            TokenKind::Not => write!(f, "!"),
247            TokenKind::Dot => write!(f, "."),
248            TokenKind::Plus => write!(f, "+"),
249            TokenKind::Minus => write!(f, "-"),
250            TokenKind::Star => write!(f, "*"),
251            TokenKind::Slash => write!(f, "/"),
252            TokenKind::Percent => write!(f, "%"),
253            TokenKind::Lt => write!(f, "<"),
254            TokenKind::Gt => write!(f, ">"),
255            TokenKind::Question => write!(f, "?"),
256            TokenKind::Bar => write!(f, "|"),
257            TokenKind::LBrace => write!(f, "{{"),
258            TokenKind::RBrace => write!(f, "}}"),
259            TokenKind::LParen => write!(f, "("),
260            TokenKind::RParen => write!(f, ")"),
261            TokenKind::LBracket => write!(f, "["),
262            TokenKind::RBracket => write!(f, "]"),
263            TokenKind::Comma => write!(f, ","),
264            TokenKind::Colon => write!(f, ":"),
265            TokenKind::Semicolon => write!(f, ";"),
266            TokenKind::LineComment(s) => write!(f, "// {s}"),
267            TokenKind::BlockComment(s) => write!(f, "/* {s} */"),
268            TokenKind::Newline => write!(f, "\\n"),
269            TokenKind::Eof => write!(f, "EOF"),
270        }
271    }
272}
273
274/// A token with its kind and source location.
275#[derive(Debug, Clone, PartialEq)]
276pub struct Token {
277    pub kind: TokenKind,
278    pub span: Span,
279}
280
281impl Token {
282    pub fn with_span(kind: TokenKind, span: Span) -> Self {
283        Self { kind, span }
284    }
285}
harn_lexer/token.rs

harn_lexer/
token.rs
