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

harn_lexer/
token.rs
