Captured identifiers in SQL strings

Initial draft

rusqlite-macros/src/lib.rs

@@ -0,0 +1,81 @@
+//! Private implementation details of `rusqlite`.
+
+use proc_macro::{Delimiter, Literal, TokenStream, TokenTree};
+
+use fallible_iterator::FallibleIterator;
+use sqlite3_parser::lexer::sql::Parser;
+use sqlite3_parser::ast::{ParameterInfo, ToTokens};
+
+// https://internals.rust-lang.org/t/custom-error-diagnostics-with-procedural-macros-on-almost-stable-rust/8113
+
+#[doc(hidden)]
+#[proc_macro]
+pub fn __bind(input: TokenStream) -> TokenStream {
+    try_bind(input).unwrap_or_else(|msg| parse_ts(&format!("compile_error!({:?})", msg)))
+}
+
+type Result<T> = std::result::Result<T, String>;
+
+fn try_bind(input: TokenStream) -> Result<TokenStream> {
+    //eprintln!("INPUT: {:#?}", input);
+    let (stmt, literal) = {
+        let mut iter = input.into_iter();
+        let stmt = iter.next().unwrap();
+        let _punct = iter.next().unwrap();
+        let literal = iter.next().unwrap();
+        assert!(iter.next().is_none());
+        (stmt, literal)
+    };
+
+    let literal = match into_literal(&literal) {
+        Some(it) => it,
+        None => return Err("expected a plain string literal".to_string()),
+    };
+    let sql = literal.to_string();
+    if !sql.starts_with('"') {
+        return Err("expected a plain string literal".to_string());
+    }
+    let sql = strip_matches(&sql, "\"");
+    //eprintln!("SQL: {}", sql);
+
+    let mut parser = Parser::new(sql.as_bytes());
+    let ast = match parser.next() {
+        Ok(None) => return Err("Invalid input".to_owned()),
+        Err(err) => {
+            return Err(err.to_string());
+        }
+        Ok(Some(ast)) => ast
+    };
+    let mut info = ParameterInfo::default();
+    if let Err(err) = ast.to_tokens(&mut info) {
+        return Err(err.to_string());
+    }
+    //eprintln!("ParameterInfo.count: {:#?}", info.count);
+    //eprintln!("ParameterInfo.names: {:#?}", info.names);
+
+    let mut res = TokenStream::new();
+    Ok(res)
+}
+
+
+fn into_literal(ts: &TokenTree) -> Option<Literal> {
+    match ts {
+        TokenTree::Literal(l) => Some(l.clone()),
+        TokenTree::Group(g) => match g.delimiter() {
+            Delimiter::None => match g.stream().into_iter().collect::<Vec<_>>().as_slice() {
+                [TokenTree::Literal(l)] => Some(l.clone()),
+                _ => None,
+            },
+            Delimiter::Parenthesis | Delimiter::Brace | Delimiter::Bracket => None,
+        },
+        _ => None,
+    }
+}
+
+fn strip_matches<'a>(s: &'a str, pattern: &str) -> &'a str {
+    s.strip_prefix(pattern).unwrap_or(s).strip_suffix(pattern).unwrap_or(s)
+}
+
+fn parse_ts(s: &str) -> TokenStream {
+    s.parse().unwrap()
+}