crates/syntax/src/parsing.rs

   1 //! Lexing, bridging to parser (which does the actual parsing) and
   2 //! incremental reparsing.
   3
   4 pub(crate) mod lexer;
   5 mod text_tree_sink;
   6 mod reparsing;
   7
   8 use parser::SyntaxKind;
   9 use text_tree_sink::TextTreeSink;
  10
  11 use crate::{syntax_node::GreenNode, AstNode, SyntaxError, SyntaxNode};
  12
  13 pub(crate) use crate::parsing::{lexer::*, reparsing::incremental_reparse};
  14
  15 pub(crate) fn parse_text(text: &str) -> (GreenNode, Vec<SyntaxError>) {
  16     let (lexer_tokens, lexer_errors) = tokenize(text);
  17     let parser_tokens = to_parser_tokens(text, &lexer_tokens);
  18
  19     let mut tree_sink = TextTreeSink::new(text, &lexer_tokens);
  20
  21     parser::parse_source_file(&parser_tokens, &mut tree_sink);
  22
  23     let (tree, mut parser_errors) = tree_sink.finish();
  24     parser_errors.extend(lexer_errors);
  25
  26     (tree, parser_errors)
  27 }
  28
  29 /// Returns `text` parsed as a `T` provided there are no parse errors.
  30 pub(crate) fn parse_text_as<T: AstNode>(
  31     text: &str,
  32     entry_point: parser::ParserEntryPoint,
  33 ) -> Result<T, ()> {
  34     let (lexer_tokens, lexer_errors) = tokenize(text);
  35     if !lexer_errors.is_empty() {
  36         return Err(());
  37     }
  38
  39     let parser_tokens = to_parser_tokens(text, &lexer_tokens);
  40
  41     let mut tree_sink = TextTreeSink::new(text, &lexer_tokens);
  42
  43     // TextTreeSink assumes that there's at least some root node to which it can attach errors and
  44     // tokens. We arbitrarily give it a SourceFile.
  45     use parser::TreeSink;
  46     tree_sink.start_node(SyntaxKind::SOURCE_FILE);
  47     parser::parse(&parser_tokens, &mut tree_sink, entry_point);
  48     tree_sink.finish_node();
  49
  50     let (tree, parser_errors, eof) = tree_sink.finish_eof();
  51     if !parser_errors.is_empty() || !eof {
  52         return Err(());
  53     }
  54
  55     SyntaxNode::new_root(tree).first_child().and_then(T::cast).ok_or(())
  56 }
  57
  58 pub(crate) fn to_parser_tokens(text: &str, lexer_tokens: &[lexer::Token]) -> ::parser::Tokens {
  59     let mut off = 0;
  60     let mut res = parser::Tokens::default();
  61     let mut was_joint = true;
  62     for t in lexer_tokens {
  63         if t.kind.is_trivia() {
  64             was_joint = false;
  65         } else if t.kind == SyntaxKind::IDENT {
  66             let token_text = &text[off..][..usize::from(t.len)];
  67             let contextual_kw =
  68                 SyntaxKind::from_contextual_keyword(token_text).unwrap_or(SyntaxKind::IDENT);
  69             res.push_ident(contextual_kw);
  70         } else {
  71             res.push(was_joint, t.kind);
  72             was_joint = true;
  73         }
  74         off += usize::from(t.len);
  75     }
  76     res
  77 }