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

flux_syntax/
lib.rs
