flux_syntax/
lib.rs

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

flux_syntax/
lib.rs
