internal: make name consistent with usage

crates/parser/src/grammar.rs

@@ -44,20 +44,23 @@ use crate::{
     TokenSet,
 };
 
-pub(crate) fn root(p: &mut Parser) {
-    let m = p.start();
-    p.eat(SHEBANG);
-    items::mod_contents(p, false);
-    m.complete(p, SOURCE_FILE);
-}
-
-/// Various pieces of syntax that can be parsed by macros by example
-pub(crate) mod fragments {
+pub(crate) mod entry_points {
     use super::*;
 
-    pub(crate) use super::{
-        expressions::block_expr, paths::type_path as path, patterns::pattern_single, types::type_,
-    };
+    pub(crate) fn source_file(p: &mut Parser) {
+        let m = p.start();
+        p.eat(SHEBANG);
+        items::mod_contents(p, false);
+        m.complete(p, SOURCE_FILE);
+    }
+
+    pub(crate) use expressions::block_expr;
+
+    pub(crate) use paths::type_path as path;
+
+    pub(crate) use patterns::pattern_single as pattern;
+
+    pub(crate) use types::type_;
 
     pub(crate) fn expr(p: &mut Parser) {
         let _ = expressions::expr_with_attrs(p);
@@ -71,8 +74,8 @@ pub(crate) mod fragments {
         expressions::stmt(p, expressions::StmtWithSemi::Optional, false)
     }
 
-    pub(crate) fn opt_visibility(p: &mut Parser) {
-        let _ = super::opt_visibility(p);
+    pub(crate) fn visibility(p: &mut Parser) {
+        let _ = opt_visibility(p);
     }
 
     // Parse a meta item , which excluded [], e.g : #[ MetaItem ]

crates/parser/src/lib.rs

@@ -71,23 +71,13 @@ pub trait TreeSink {
     fn error(&mut self, error: ParseError);
 }
 
-fn parse_from_tokens<F>(token_source: &mut dyn TokenSource, tree_sink: &mut dyn TreeSink, f: F)
-where
-    F: FnOnce(&mut parser::Parser),
-{
-    let mut p = parser::Parser::new(token_source);
-    f(&mut p);
-    let events = p.finish();
-    event::process(tree_sink, events);
-}
-
-/// Parse given tokens into the given sink as a rust file.
-pub fn parse(token_source: &mut dyn TokenSource, tree_sink: &mut dyn TreeSink) {
-    parse_from_tokens(token_source, tree_sink, grammar::root);
-}
-
+/// rust-analyzer parser allows you to choose one of the possible entry points.
+///
+/// The primary consumer of this API are declarative macros, `$x:expr` matchers
+/// are implemented by calling into the parser with non-standard entry point.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub enum FragmentKind {
+pub enum ParserEntryPoint {
+    SourceFile,
     Path,
     Expr,
     Statement,
@@ -103,27 +93,37 @@ pub enum FragmentKind {
     Attr,
 }
 
-pub fn parse_fragment(
+/// Parse given tokens into the given sink as a rust file.
+pub fn parse_source_file(token_source: &mut dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse(token_source, tree_sink, ParserEntryPoint::SourceFile);
+}
+
+pub fn parse(
     token_source: &mut dyn TokenSource,
     tree_sink: &mut dyn TreeSink,
-    fragment_kind: FragmentKind,
+    entry_point: ParserEntryPoint,
 ) {
-    let parser: fn(&'_ mut parser::Parser) = match fragment_kind {
-        FragmentKind::Path => grammar::fragments::path,
-        FragmentKind::Expr => grammar::fragments::expr,
-        FragmentKind::Type => grammar::fragments::type_,
-        FragmentKind::Pattern => grammar::fragments::pattern_single,
-        FragmentKind::Item => grammar::fragments::item,
-        FragmentKind::Block => grammar::fragments::block_expr,
-        FragmentKind::Visibility => grammar::fragments::opt_visibility,
-        FragmentKind::MetaItem => grammar::fragments::meta_item,
-        FragmentKind::Statement => grammar::fragments::stmt,
-        FragmentKind::StatementOptionalSemi => grammar::fragments::stmt_optional_semi,
-        FragmentKind::Items => grammar::fragments::macro_items,
-        FragmentKind::Statements => grammar::fragments::macro_stmts,
-        FragmentKind::Attr => grammar::fragments::attr,
+    let entry_point: fn(&'_ mut parser::Parser) = match entry_point {
+        ParserEntryPoint::SourceFile => grammar::entry_points::source_file,
+        ParserEntryPoint::Path => grammar::entry_points::path,
+        ParserEntryPoint::Expr => grammar::entry_points::expr,
+        ParserEntryPoint::Type => grammar::entry_points::type_,
+        ParserEntryPoint::Pattern => grammar::entry_points::pattern,
+        ParserEntryPoint::Item => grammar::entry_points::item,
+        ParserEntryPoint::Block => grammar::entry_points::block_expr,
+        ParserEntryPoint::Visibility => grammar::entry_points::visibility,
+        ParserEntryPoint::MetaItem => grammar::entry_points::meta_item,
+        ParserEntryPoint::Statement => grammar::entry_points::stmt,
+        ParserEntryPoint::StatementOptionalSemi => grammar::entry_points::stmt_optional_semi,
+        ParserEntryPoint::Items => grammar::entry_points::macro_items,
+        ParserEntryPoint::Statements => grammar::entry_points::macro_stmts,
+        ParserEntryPoint::Attr => grammar::entry_points::attr,
     };
-    parse_from_tokens(token_source, tree_sink, parser)
+
+    let mut p = parser::Parser::new(token_source);
+    entry_point(&mut p);
+    let events = p.finish();
+    event::process(tree_sink, events);
 }
 
 /// A parsing function for a specific braced-block.