flux_syntax/
lib.rs

1#![feature(rustc_private, box_patterns, let_chains, new_range_api)]
2
3extern crate rustc_ast;
4extern crate rustc_span;
5
6pub mod lexer;
7mod parser;
8pub mod surface;
9
10use lexer::{Cursor, Token};
11use parser::lookahead::Peek;
12use rustc_ast::tokenstream::TokenStream;
13use rustc_span::{BytePos, Span, SyntaxContext, def_id::LocalDefId};
14use surface::NodeId;
15
16#[derive(Default)]
17pub struct ParseSess {
18    next_node_id: usize,
19}
20
21impl ParseSess {
22    fn cx<'a>(&'a mut self, tokens: &'a TokenStream, span: Span) -> ParseCtxt<'a> {
23        ParseCtxt::new(self, tokens, span)
24    }
25
26    pub fn parse_refined_by(
27        &mut self,
28        tokens: &TokenStream,
29        span: Span,
30    ) -> ParseResult<surface::RefineParams> {
31        parser::parse_refined_by(&mut self.cx(tokens, span))
32    }
33
34    pub fn parse_generics(
35        &mut self,
36        tokens: &TokenStream,
37        span: Span,
38    ) -> ParseResult<surface::Generics> {
39        parser::parse_generics(&mut self.cx(tokens, span))
40    }
41
42    pub fn parse_type_alias(
43        &mut self,
44        tokens: &TokenStream,
45        span: Span,
46    ) -> ParseResult<surface::TyAlias> {
47        parser::parse_type_alias(&mut self.cx(tokens, span))
48    }
49
50    pub fn parse_fn_sig(
51        &mut self,
52        tokens: &TokenStream,
53        span: Span,
54    ) -> ParseResult<surface::FnSig> {
55        parser::parse_fn_sig(&mut self.cx(tokens, span))
56    }
57
58    pub fn parse_trait_assoc_reft(
59        &mut self,
60        tokens: &TokenStream,
61        span: Span,
62    ) -> ParseResult<Vec<surface::TraitAssocReft>> {
63        parser::parse_trait_assoc_refts(&mut self.cx(tokens, span))
64    }
65
66    pub fn parse_impl_assoc_reft(
67        &mut self,
68        tokens: &TokenStream,
69        span: Span,
70    ) -> ParseResult<Vec<surface::ImplAssocReft>> {
71        parser::parse_impl_assoc_refts(&mut self.cx(tokens, span))
72    }
73
74    pub fn parse_qual_names(
75        &mut self,
76        tokens: &TokenStream,
77        span: Span,
78    ) -> ParseResult<surface::QualNames> {
79        parser::parse_qual_names(&mut self.cx(tokens, span))
80    }
81
82    pub fn parse_reveal_names(
83        &mut self,
84        tokens: &TokenStream,
85        span: Span,
86    ) -> ParseResult<surface::RevealNames> {
87        parser::parse_reveal_names(&mut self.cx(tokens, span))
88    }
89
90    pub fn parse_flux_item(
91        &mut self,
92        tokens: &TokenStream,
93        span: Span,
94    ) -> ParseResult<Vec<surface::Item>> {
95        parser::parse_flux_items(&mut self.cx(tokens, span))
96    }
97
98    pub fn parse_type(&mut self, tokens: &TokenStream, span: Span) -> ParseResult<surface::Ty> {
99        parser::parse_type(&mut self.cx(tokens, span))
100    }
101
102    pub fn parse_variant(
103        &mut self,
104        tokens: &TokenStream,
105        span: Span,
106    ) -> ParseResult<surface::VariantDef> {
107        parser::parse_variant(&mut self.cx(tokens, span))
108    }
109
110    pub fn parse_expr(&mut self, tokens: &TokenStream, span: Span) -> ParseResult<surface::Expr> {
111        parser::parse_expr(&mut self.cx(tokens, span), true)
112    }
113
114    pub fn parse_constant_info(
115        &mut self,
116        tokens: &TokenStream,
117        span: Span,
118    ) -> ParseResult<surface::ConstantInfo> {
119        let expr = parser::parse_expr(&mut self.cx(tokens, span), true)?;
120        Ok(surface::ConstantInfo { expr: Some(expr) })
121    }
122
123    pub fn parse_yes_or_no_with_reason(
124        &mut self,
125        tokens: &TokenStream,
126        span: Span,
127    ) -> ParseResult<bool> {
128        parser::parse_yes_or_no_with_reason(&mut self.cx(tokens, span))
129    }
130
131    pub fn next_node_id(&mut self) -> NodeId {
132        let id = NodeId(self.next_node_id);
133        self.next_node_id += 1;
134        id
135    }
136}
137
138struct ParseCtxt<'a> {
139    ctx: SyntaxContext,
140    parent: Option<LocalDefId>,
141    tokens: Cursor<'a>,
142    sess: &'a mut ParseSess,
143}
144
145impl<'a> ParseCtxt<'a> {
146    fn new(sess: &'a mut ParseSess, tokens: &'a TokenStream, span: Span) -> Self {
147        Self {
148            sess,
149            tokens: Cursor::new(tokens, span.lo()),
150            ctx: span.ctxt(),
151            parent: span.parent(),
152        }
153    }
154
155    fn next_node_id(&mut self) -> NodeId {
156        self.sess.next_node_id()
157    }
158
159    fn mk_span(&self, lo: BytePos, hi: BytePos) -> Span {
160        Span::new(lo, hi, self.ctx, self.parent)
161    }
162
163    fn lo(&self) -> BytePos {
164        self.tokens.lo()
165    }
166
167    fn hi(&self) -> BytePos {
168        self.tokens.hi()
169    }
170
171    fn unexpected_token(&mut self, expected: Vec<&'static str>) -> ParseError {
172        let (lo, tok, hi) = self.tokens.at(0);
173        let kind = if tok == Token::Eof {
174            ParseErrorKind::UnexpectedEof
175        } else {
176            ParseErrorKind::UnexpectedToken { expected }
177        };
178        ParseError { kind, span: self.mk_span(lo, hi) }
179    }
180
181    fn cannot_be_chained(&self, lo: BytePos, hi: BytePos) -> ParseError {
182        ParseError { kind: ParseErrorKind::CannotBeChained, span: self.mk_span(lo, hi) }
183    }
184}
185
186pub type ParseResult<T = ()> = Result<T, ParseError>;
187
188pub struct ParseError {
189    pub kind: ParseErrorKind,
190    pub span: Span,
191}
192
193#[derive(Debug)]
194pub enum ParseErrorKind {
195    UnexpectedToken { expected: Vec<&'static str> },
196    UnexpectedEof,
197    CannotBeChained,
198    InvalidBinding,
199}
flux_syntax/lib.rs

flux_syntax/
lib.rs
