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;
11mod token;
12use lexer::Cursor;
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), token::Eof)
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::FluxItem>> {
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), false)
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    pub fn parse_detached_specs(
133        &mut self,
134        tokens: &TokenStream,
135        span: Span,
136    ) -> ParseResult<surface::DetachedSpecs> {
137        parser::parse_detached_specs(&mut self.cx(tokens, span))
138    }
139}
140
141struct ParseCtxt<'a> {
142    sess: &'a mut ParseSess,
143    ctx: SyntaxContext,
144    parent: Option<LocalDefId>,
145    edition: Edition,
146    tokens: Cursor<'a>,
147}
148
149impl<'a> ParseCtxt<'a> {
150    fn new(sess: &'a mut ParseSess, tokens: &'a TokenStream, span: Span) -> Self {
151        Self {
152            sess,
153            ctx: span.ctxt(),
154            parent: span.parent(),
155            edition: span.edition(),
156            tokens: Cursor::new(tokens, span.lo()),
157        }
158    }
159
160    fn next_node_id(&mut self) -> NodeId {
161        self.sess.next_node_id()
162    }
163
164    fn mk_span(&self, lo: BytePos, hi: BytePos) -> Span {
165        Span::new(lo, hi, self.ctx, self.parent)
166    }
167
168    fn lo(&self) -> BytePos {
169        self.tokens.lo()
170    }
171
172    fn hi(&self) -> BytePos {
173        self.tokens.hi()
174    }
175
176    fn is_reserved(&self, sym: Symbol) -> bool {
177        symbols::is_reserved(sym, self.edition)
178    }
179
180    fn unexpected_token(&mut self, expected: Vec<Expected>) -> ParseError {
181        let tok = self.tokens.at(0);
182        let kind = if tok.kind == token::Eof {
183            ParseErrorKind::UnexpectedEof
184        } else {
185            ParseErrorKind::UnexpectedToken { expected }
186        };
187        ParseError { kind, span: self.mk_span(tok.lo, tok.hi) }
188    }
189
190    fn cannot_be_chained(&self, lo: BytePos, hi: BytePos) -> ParseError {
191        ParseError { kind: ParseErrorKind::CannotBeChained, span: self.mk_span(lo, hi) }
192    }
193}
194
195pub type ParseResult<T = ()> = Result<T, ParseError>;
196
197pub struct ParseError {
198    pub kind: ParseErrorKind,
199    pub span: Span,
200}
201
202#[derive(Debug)]
203pub enum ParseErrorKind {
204    UnexpectedToken { expected: Vec<Expected> },
205    UnexpectedEof,
206    CannotBeChained,
207    InvalidBinding,
208    InvalidSort,
209    InvalidDetachedSpec,
210}
flux_syntax/lib.rs

flux_syntax/
lib.rs
