flux_syntax/
lib.rs

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

flux_syntax/
lib.rs
