feat: prqlc compile --debug-log

.gitignore

@@ -35,6 +35,8 @@ _*.sql
 *.snap.new
 
 *.my.csv
+log*.json
+log*.html
 
 cobertura.xml
 codecov.json

prqlc/bindings/prqlc-python/src/lib.rs

@@ -63,16 +63,16 @@ mod debug {
     #[pyfunction]
     pub fn prql_lineage(prql_query: &str) -> PyResult<String> {
         prqlc_lib::prql_to_pl(prql_query)
-            .and_then(prqlc_lib::debug::pl_to_lineage)
-            .and_then(|x| prqlc_lib::debug::json::from_lineage(&x))
+            .and_then(prqlc_lib::internal::pl_to_lineage)
+            .and_then(|x| prqlc_lib::internal::json::from_lineage(&x))
             .map_err(|err| (PyErr::new::<exceptions::PyValueError, _>(err.to_json())))
     }
 
     #[pyfunction]
     pub fn pl_to_lineage(pl_json: &str) -> PyResult<String> {
         prqlc_lib::json::to_pl(pl_json)
-            .and_then(prqlc_lib::debug::pl_to_lineage)
-            .and_then(|x| prqlc_lib::debug::json::from_lineage(&x))
+            .and_then(prqlc_lib::internal::pl_to_lineage)
+            .and_then(|x| prqlc_lib::internal::json::from_lineage(&x))
             .map_err(|err| (PyErr::new::<exceptions::PyValueError, _>(err.to_json())))
     }
 }

prqlc/prqlc-parser/src/lexer/lr/mod.rs

@@ -1,3 +1,8 @@
-pub mod token;
+mod token;
 
 pub use token::*;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct Tokens(pub Vec<Token>);

prqlc/prqlc-parser/src/lexer/mod.rs

@@ -1,9 +1,6 @@
-use chumsky::{
-    error::Cheap,
-    prelude::*,
-    text::{newline, Character},
-};
-use serde::{Deserialize, Serialize};
+use chumsky::error::Cheap;
+use chumsky::prelude::*;
+use chumsky::text::{newline, Character};
 
 use crate::error::{Error, ErrorSource, Reason, WithErrorInfo};
 use crate::lexer::lr::{Literal, Token, TokenKind, ValueAndUnit};
@@ -24,8 +21,8 @@ pub fn lex_string_recovery(source: &str, source_id: u16) -> (Option<Vec<Token>>,
     (tokens, errors)
 }
 
-pub fn lex_source(source: &str) -> Result<TokenVec, Vec<Error>> {
-    lexer().parse(source).map(TokenVec).map_err(|e| {
+pub fn lex_source(source: &str) -> Result<lr::Tokens, Vec<Error>> {
+    lexer().parse(source).map(lr::Tokens).map_err(|e| {
         e.into_iter()
             .map(|x| convert_lexer_error(source, x, 0))
             .collect()
@@ -470,6 +467,3 @@ fn end_expr() -> impl Parser<char, (), Error = Cheap<char>> {
     ))
     .rewind()
 }
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-pub struct TokenVec(pub Vec<Token>);

prqlc/prqlc-parser/src/lexer/test.rs

@@ -2,40 +2,39 @@ use chumsky::Parser;
 use insta::assert_debug_snapshot;
 use insta::assert_snapshot;
 
-use crate::lexer::lr::token::{Literal, TokenKind};
-use crate::lexer::TokenVec;
+use crate::lexer::lr::{Literal, TokenKind, Tokens};
 use crate::lexer::{lex_source, lexer, literal, quoted_string};
 
 #[test]
 fn line_wrap() {
-    assert_debug_snapshot!(TokenVec(lexer().parse(r"5 +
+    assert_debug_snapshot!(Tokens(lexer().parse(r"5 +
     \ 3 "
         ).unwrap()), @r###"
-        TokenVec(
-            [
-                0..1: Literal(Integer(5)),
-                2..3: Control('+'),
-                3..9: LineWrap([]),
-                10..11: Literal(Integer(3)),
-            ],
-        )
-        "###);
+    Tokens(
+        [
+            0..1: Literal(Integer(5)),
+            2..3: Control('+'),
+            3..9: LineWrap([]),
+            10..11: Literal(Integer(3)),
+        ],
+    )
+    "###);
 
     // Comments are included; no newline after the comments
-    assert_debug_snapshot!(TokenVec(lexer().parse(r"5 +
+    assert_debug_snapshot!(Tokens(lexer().parse(r"5 +
 # comment
    # comment with whitespace
   \ 3 "
         ).unwrap()), @r###"
-        TokenVec(
-            [
-                0..1: Literal(Integer(5)),
-                2..3: Control('+'),
-                3..46: LineWrap([Comment(" comment"), Comment(" comment with whitespace")]),
-                47..48: Literal(Integer(3)),
-            ],
-        )
-        "###);
+    Tokens(
+        [
+            0..1: Literal(Integer(5)),
+            2..3: Control('+'),
+            3..46: LineWrap([Comment(" comment"), Comment(" comment with whitespace")]),
+            47..48: Literal(Integer(3)),
+        ],
+    )
+    "###);
 
     // Check display, for the test coverage (use `assert_eq` because the
     // line-break doesn't work well with snapshots)
@@ -75,28 +74,28 @@ fn numbers() {
 
 #[test]
 fn debug_display() {
-    assert_debug_snapshot!(TokenVec(lexer().parse("5 + 3").unwrap()), @r###"
-        TokenVec(
-            [
-                0..1: Literal(Integer(5)),
-                2..3: Control('+'),
-                4..5: Literal(Integer(3)),
-            ],
-        )
-        "###);
+    assert_debug_snapshot!(Tokens(lexer().parse("5 + 3").unwrap()), @r###"
+    Tokens(
+        [
+            0..1: Literal(Integer(5)),
+            2..3: Control('+'),
+            4..5: Literal(Integer(3)),
+        ],
+    )
+    "###);
 }
 
 #[test]
 fn comment() {
-    assert_debug_snapshot!(TokenVec(lexer().parse("# comment\n# second line").unwrap()), @r###"
-        TokenVec(
-            [
-                0..9: Comment(" comment"),
-                9..10: NewLine,
-                10..23: Comment(" second line"),
-            ],
-        )
-        "###);
+    assert_debug_snapshot!(Tokens(lexer().parse("# comment\n# second line").unwrap()), @r###"
+    Tokens(
+        [
+            0..9: Comment(" comment"),
+            9..10: NewLine,
+            10..23: Comment(" second line"),
+        ],
+    )
+    "###);
 
     assert_snapshot!(TokenKind::Comment(" This is a single-line comment".to_string()), @r###"
         # This is a single-line comment
@@ -105,13 +104,13 @@ fn comment() {
 
 #[test]
 fn doc_comment() {
-    assert_debug_snapshot!(TokenVec(lexer().parse("#! docs").unwrap()), @r###"
-        TokenVec(
-            [
-                0..7: DocComment(" docs"),
-            ],
-        )
-        "###);
+    assert_debug_snapshot!(Tokens(lexer().parse("#! docs").unwrap()), @r###"
+    Tokens(
+        [
+            0..7: DocComment(" docs"),
+        ],
+    )
+    "###);
 }
 
 #[test]
@@ -151,43 +150,43 @@ fn quotes() {
 
 #[test]
 fn range() {
-    assert_debug_snapshot!(TokenVec(lexer().parse("1..2").unwrap()), @r###"
-        TokenVec(
-            [
-                0..1: Literal(Integer(1)),
-                1..3: Range { bind_left: true, bind_right: true },
-                3..4: Literal(Integer(2)),
-            ],
-        )
-        "###);
+    assert_debug_snapshot!(Tokens(lexer().parse("1..2").unwrap()), @r###"
+    Tokens(
+        [
+            0..1: Literal(Integer(1)),
+            1..3: Range { bind_left: true, bind_right: true },
+            3..4: Literal(Integer(2)),
+        ],
+    )
+    "###);
 
-    assert_debug_snapshot!(TokenVec(lexer().parse("..2").unwrap()), @r###"
-        TokenVec(
-            [
-                0..2: Range { bind_left: true, bind_right: true },
-                2..3: Literal(Integer(2)),
-            ],
-        )
-        "###);
+    assert_debug_snapshot!(Tokens(lexer().parse("..2").unwrap()), @r###"
+    Tokens(
+        [
+            0..2: Range { bind_left: true, bind_right: true },
+            2..3: Literal(Integer(2)),
+        ],
+    )
+    "###);
 
-    assert_debug_snapshot!(TokenVec(lexer().parse("1..").unwrap()), @r###"
-        TokenVec(
-            [
-                0..1: Literal(Integer(1)),
-                1..3: Range { bind_left: true, bind_right: true },
-            ],
-        )
-        "###);
+    assert_debug_snapshot!(Tokens(lexer().parse("1..").unwrap()), @r###"
+    Tokens(
+        [
+            0..1: Literal(Integer(1)),
+            1..3: Range { bind_left: true, bind_right: true },
+        ],
+    )
+    "###);
 
-    assert_debug_snapshot!(TokenVec(lexer().parse("in ..5").unwrap()), @r###"
-        TokenVec(
-            [
-                0..2: Ident("in"),
-                2..5: Range { bind_left: false, bind_right: true },
-                5..6: Literal(Integer(5)),
-            ],
-        )
-        "###);
+    assert_debug_snapshot!(Tokens(lexer().parse("in ..5").unwrap()), @r###"
+    Tokens(
+        [
+            0..2: Ident("in"),
+            2..5: Range { bind_left: false, bind_right: true },
+            5..6: Literal(Integer(5)),
+        ],
+    )
+    "###);
 }
 
 #[test]
@@ -196,7 +195,7 @@ fn test_lex_source() {
 
     assert_debug_snapshot!(lex_source("5 + 3"), @r###"
     Ok(
-        TokenVec(
+        Tokens(
             [
                 0..1: Literal(Integer(5)),
                 2..3: Control('+'),