Hide rowan behind a non-default cst feature

Author: nickolay

Cargo.toml

@@ -18,10 +18,13 @@ edition = "2018"
 name = "sqlparser"
 path = "src/lib.rs"
 
+[features]
+cst = ["rowan"]  # Retain a concrete synatax tree, available as `parser.syntax()`
+
 [dependencies]
 bigdecimal = { version = "0.1.0", optional = true }
 log = "0.4.5"
-rowan = "0.10.0"
+rowan = { version = "0.10.0", optional = true }
 
 [dev-dependencies]
 simple_logger = "1.0.1"

examples/cli.rs

@@ -58,17 +58,20 @@ fn main() {
 
     match parse_result {
         Ok(statements) => {
-            println!(
-                "Round-trip:\n'{}'",
-                statements
-                    .iter()
-                    .map(std::string::ToString::to_string)
-                    .collect::<Vec<_>>()
-                    .join("\n")
-            );
-            println!("Parse results:\n{:#?}", statements);
-
-            println!("Parse tree:\n{:#?}", parser.syntax());
+            if cfg!(not(feature = "cst")) {
+                println!(
+                    "Round-trip:\n'{}'",
+                    statements
+                        .iter()
+                        .map(std::string::ToString::to_string)
+                        .collect::<Vec<_>>()
+                        .join("\n")
+                );
+                println!("Parse results:\n{:#?}", statements);
+            } else {
+                #[cfg(feature = "cst")]
+                println!("Parse tree:\n{:#?}", parser.syntax());
+            }
         }
         Err(e) => {
             println!("Error during parsing: {:?}", e);

src/cst.rs

@@ -120,6 +120,7 @@ impl Token {
     }
 }
 
+#[cfg(feature = "cst")]
 impl From<SyntaxKind> for rowan::SyntaxKind {
     fn from(kind: SyntaxKind) -> Self {
         Self(kind as u16)
@@ -128,6 +129,7 @@ impl From<SyntaxKind> for rowan::SyntaxKind {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Lang {}
+#[cfg(feature = "cst")]
 impl rowan::Language for Lang {
     type Kind = SyntaxKind;
     fn kind_from_raw(raw: rowan::SyntaxKind) -> Self::Kind {
@@ -139,4 +141,5 @@ impl rowan::Language for Lang {
     }
 }
 
+#[cfg(feature = "cst")]
 pub type SyntaxNode = rowan::SyntaxNode<Lang>;

src/lib.rs

@@ -35,6 +35,7 @@
 #![warn(clippy::all)]
 
 pub mod ast;
+#[cfg(feature = "cst")]
 mod builder;
 pub mod cst;
 pub mod dialect;

src/parser.rs

@@ -21,7 +21,9 @@ use super::tokenizer::*;
 use std::error::Error;
 use std::fmt;
 
+#[cfg(feature = "cst")]
 use crate::builder;
+
 use crate::{cst, cst::SyntaxKind as SK};
 
 #[derive(Debug, Clone, PartialEq)]
@@ -41,6 +43,7 @@ macro_rules! parser_err {
 pub struct Marker {
     /// position in the token stream (`parser.index`)
     index: usize,
+    #[cfg(feature = "cst")]
     builder_checkpoint: builder::Checkpoint,
 }
 
@@ -83,13 +86,16 @@ pub struct Parser {
     tokens: Vec<Token>,
     /// The index of the first unprocessed token in `self.tokens`
     index: usize,
+
+    #[cfg(feature = "cst")]
     builder: builder::GreenNodeBuilder<'static>,
 
     // TBD: the parser currently provides an API to move around the token
     // stream without restrictions (`next_token`/`prev_token`), while the
     // `builder` does not. To work around this, we keep a list of "pending"
     // tokens which have already been processed via `next_token`, but may
     // be put back via `prev_token`.
+    #[cfg(feature = "cst")]
     pending: Vec<(cst::SyntaxKind, rowan::SmolStr)>,
 }
 
@@ -112,16 +118,21 @@ macro_rules! ret {
 impl Parser {
     /// Parse the specified tokens
     pub fn new(tokens: Vec<Token>) -> Self {
+        #[allow(unused_mut)]
         let mut parser = Parser {
             tokens,
             index: 0,
+            #[cfg(feature = "cst")]
             builder: builder::GreenNodeBuilder::new(),
+            #[cfg(feature = "cst")]
             pending: vec![],
         };
+        #[cfg(feature = "cst")]
         parser.builder.start_node(SK::ROOT.into());
         parser
     }
 
+    #[cfg(feature = "cst")]
     pub fn syntax(mut self) -> cst::SyntaxNode {
         if self.peek_token().is_some() {
             // Not at end-of-file: either some extraneous tokens left after
@@ -807,6 +818,7 @@ impl Parser {
         self.flush_pending_buffer();
         Marker {
             index: self.index,
+            #[cfg(feature = "cst")]
             builder_checkpoint: self.builder.checkpoint(),
         }
     }
@@ -826,19 +838,25 @@ impl Parser {
 
     pub fn reset(&mut self, m: Marker) {
         self.index = m.index;
+        #[cfg(feature = "cst")]
         self.pending.truncate(0);
+        #[cfg(feature = "cst")]
         self.builder.reset(m.builder_checkpoint);
     }
 
+    #[allow(unused_variables)]
     pub fn complete<T>(&mut self, m: Marker, kind: cst::SyntaxKind, rv: T) -> T {
         self.flush_pending_buffer();
+        #[cfg(feature = "cst")]
         self.builder
             .start_node_at(m.builder_checkpoint, kind.into());
+        #[cfg(feature = "cst")]
         self.builder.finish_node();
         rv
     }
 
     pub fn flush_pending_buffer(&mut self) {
+        #[cfg(feature = "cst")]
         for (kind, s) in self.pending.drain(..) {
             self.builder.token(kind.into(), s);
         }
@@ -886,8 +904,11 @@ impl Parser {
         self.index += 1;
         #[allow(clippy::let_and_return)]
         let token = self.tokens.get(self.index - 1);
-        if let Some(t) = token {
-            self.pending.push((t.kind(), t.to_string().into()));
+        #[cfg(feature = "cst")]
+        {
+            if let Some(t) = token {
+                self.pending.push((t.kind(), t.to_string().into()));
+            }
         }
         token
     }
@@ -900,10 +921,13 @@ impl Parser {
             assert!(self.index > 0);
             self.index -= 1;
 
-            if !self.pending.is_empty() {
-                self.pending.pop();
-            } else {
-                assert!(self.index >= self.tokens.len()); // past EOF
+            #[cfg(feature = "cst")]
+            {
+                if !self.pending.is_empty() {
+                    self.pending.pop();
+                } else {
+                    assert!(self.index >= self.tokens.len()); // past EOF
+                }
             }
 
             if let Some(Token::Whitespace(_)) = self.tokens.get(self.index) {
@@ -913,6 +937,7 @@ impl Parser {
             // There may be only one non-whitespace token `pending` as by
             // convention, backtracking (i.e. going more than one token back)
             // is done via `start`/`reset` instead.
+            #[cfg(feature = "cst")]
             for tok in &self.pending {
                 assert!(tok.0 == SK::Whitespace);
             }
@@ -941,9 +966,12 @@ impl Parser {
             Some(Token::Word(ref k)) if expected.eq_ignore_ascii_case(&k.keyword) => {
                 self.next_token();
                 // TBD: a hack to change the "kind" of the token just processed
-                let mut p = self.pending.pop().unwrap();
-                p.0 = SK::KW.into();
-                self.pending.push(p);
+                #[cfg(feature = "cst")]
+                {
+                    let mut p = self.pending.pop().unwrap();
+                    p.0 = SK::KW;
+                    self.pending.push(p);
+                }
                 true
             }
             _ => false,

src/test_utils.rs

@@ -57,17 +57,24 @@ impl TestedDialects {
             #[allow(clippy::let_and_return)]
             let rv = f(&mut parser);
 
-            // Concatenating CST tokens should result in a string
-            // identical to the input SQL:
-            let syn = parser.syntax();
-            assert_eq!(sql, syn.to_string());
+            #[cfg(feature = "cst")]
+            {
+                // Concatenating CST tokens should result in a string
+                // identical to the input SQL:
+                let syn = parser.syntax();
+                assert_eq!(sql, syn.to_string());
+            }
 
             rv
         })
     }
 
     pub fn parse_sql_statements(&self, sql: &str) -> Result<Vec<Statement>, ParserError> {
-        self.run_parser_method(sql, Parser::parse_statements)
+        if cfg!(feature = "cst") {
+            self.run_parser_method(sql, Parser::parse_statements)
+        } else {
+            self.one_of_identical_results(|dialect| Parser::parse_sql(dialect, &sql))
+        }
         // To fail the `ensure_multiple_dialects_are_tested` test:
         // Parser::parse_sql(&**self.dialects.first().unwrap(), sql)
     }