flux_syntax/
lib.rs

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

flux_syntax/
lib.rs
