quilt-python 0.1.0__tar.gz → 0.2.0__tar.gz

{quilt_python-0.1.0 → quilt_python-0.2.0}/Cargo.lock

@@ -977,9 +977,17 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "quilt-expand-wasm"
+version = "0.2.0"
+dependencies = [
+ "miette",
+ "quiltlang",
+]
+
 [[package]]
 name = "quilt-lsp"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "dashmap 6.2.1",
@@ -1002,7 +1010,7 @@ dependencies = [
 
 [[package]]
 name = "quilt-wasm"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "quiltlang",
  "wasm-bindgen",
@@ -1010,7 +1018,7 @@ dependencies = [
 
 [[package]]
 name = "quilt_python"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "postcard",
  "pyo3",
@@ -1019,7 +1027,7 @@ dependencies = [
 
 [[package]]
 name = "quiltlang"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "clap",
  "indoc",
@@ -1602,7 +1610,7 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-quilt"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "cc",
  "tree-sitter",

{quilt_python-0.1.0 → quilt_python-0.2.0}/Cargo.toml

@@ -4,7 +4,7 @@ members = ["quilt", "quilt-python", "tree-sitter-quilt"]
 
 [workspace.package]
 edition = "2021"
-version = "0.1.0"
+version = "0.2.0"
 license = "MIT OR Apache-2.0"
 authors = ["Alexander Varga <varga.alex@gmail.com>"]
 repository = "https://github.com/QuiltLang/quilt"
@@ -12,10 +12,10 @@ repository = "https://github.com/QuiltLang/quilt"
 [workspace.dependencies]
 # Internal crates. The core package is published as `quiltlang` (issue #33);
 # `package =` keeps the `quilt` dependency key so `use quilt::...` is unchanged.
-quilt = {version = "0.1.0", path = "quilt", package = "quiltlang", default-features = false}
+quilt = {version = "0.2.0", path = "quilt", package = "quiltlang", default-features = false}
 # `version` is required alongside `path` so dependents (quiltlang, quilt-lsp)
 # can be `cargo publish`ed: the registry copy drops `path` and keeps `version`.
-tree-sitter-quilt = {version = "0.1.0", path = "tree-sitter-quilt"}
+tree-sitter-quilt = {version = "0.2.0", path = "tree-sitter-quilt"}
 # Grammar crates pulled from their QuiltLang forks (previously git submodules).
 # Each is pinned to an explicit `rev` so the build is reproducible even for
 # library consumers and `cargo install --git … quiltlang` runs that ignore our

{quilt_python-0.1.0 → quilt_python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quilt-python
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/lang.rs

@@ -6,16 +6,46 @@ use std::sync::Arc;
 /**************************************************************/
 
 /// Kinds of terms. These are sorts of messages for communicating between parsers.
+///
+/// The variants name the grammatical roles a fragment can play. Languages map
+/// their tree-sitter node tags onto these via [`Language::typ`] /
+/// [`Language::classify_term`], and holes record the kind their position
+/// demands via [`TSProvider::hole_kind`](crate::treesitter::TSProvider::hole_kind).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum InnerKind {
+    /// An expression — produces a value (e.g. `1 + 2`, a function call).
     Expr,
+    /// A statement — runs for its effect and lives among siblings in a block
+    /// (e.g. `let x = 1;`, an expression statement).
     Stmt,
+    /// An item / top-level declaration (e.g. `fn`, `struct`, `impl`, `use`).
+    /// Like [`Stmt`](InnerKind::Stmt) it sits among siblings rather than
+    /// producing a value, but it is a definition rather than a runtime
+    /// statement. [`InnerKind::is_stmt_like`] groups the two.
+    Item,
+    /// A brace-delimited block *body* — the `{ … }` of a function, loop, or
+    /// branch. Distinct from a block used as a value (which is an
+    /// [`Expr`](InnerKind::Expr)); see
+    /// [`TSProvider::hole_kind`](crate::treesitter::TSProvider::hole_kind),
+    /// which reads the surrounding tree to tell the two apart.
+    Block,
     #[default]
-    // TODO: rename or also add `Block`
+    /// A whole file / module — a sequence of top-level items.
     File,
     // TODO: add more, language specific types, number, function, etc.
 }
 
+impl InnerKind {
+    /// Whether a fragment of this kind lives in a "variadic" sibling position
+    /// (a statement or an item) rather than producing a value. The expander's
+    /// emit/splice heuristics treat statements and items alike, so they ask
+    /// this instead of comparing against a single variant.
+    #[must_use]
+    pub fn is_stmt_like(self) -> bool {
+        matches!(self, InnerKind::Stmt | InnerKind::Item)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum Arity {
     #[default]

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/langs/bash/lang.rs

@@ -10,6 +10,7 @@ use crate::{
     qterm::QTerm,
     treesitter::{DynTSLanguage, TSLanguage, TSProvider},
 };
+use miette::Result;
 use tree_sitter::Parser;
 
 /**************************************************************/
@@ -43,21 +44,21 @@ impl TSProvider for BashProvider {
     /// Squash the `program` wrapper around a single quoted fragment so the
     /// term is the fragment itself (command / statement). A multi-statement
     /// fragment (a whole script) stays a `program`.
-    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> (QTerm, InnerKind) {
+    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> Result<(QTerm, InnerKind)> {
         let QTerm::Tuple { tag, terms, .. } = &qterm else {
-            return (qterm, InnerKind::default());
+            return Ok((qterm, InnerKind::default()));
         };
         if &**tag != "program" {
-            return (qterm, InnerKind::default());
+            return Ok((qterm, InnerKind::default()));
         }
         if terms.len() != 1 {
-            return (qterm, InnerKind::File);
+            return Ok((qterm, InnerKind::File));
         }
         let kind = match &*terms[0] {
             QTerm::Tuple { tag, .. } if is_expr_tag(tag) => InnerKind::Expr,
             _ => InnerKind::Stmt,
         };
-        (qterm.squash(), kind)
+        Ok((qterm.squash(), kind))
     }
 
     fn arity(&self, tag: &str) -> Arity {

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/langs/html/lang.rs

@@ -14,6 +14,7 @@ use crate::{
     qterm::QTerm,
     treesitter::{DynTSLanguage, TSLanguage, TSProvider},
 };
+use miette::Result;
 use tree_sitter::Parser;
 
 /**************************************************************/
@@ -44,24 +45,26 @@ impl TSProvider for HtmlProvider {
     /// term is the fragment itself (element / text / …). A multi-node fragment
     /// (a whole page) stays a `document`.
     ///
-    /// The returned `InnerKind` is advisory only (`parse_pre` discards it); we
-    /// never panic on an unexpected shape, like the WGSL provider.
-    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> (QTerm, InnerKind) {
+    /// The returned `InnerKind` is advisory only (`parse_pre` discards it); like
+    /// the WGSL provider, we accept any shape here rather than rejecting
+    /// unrecognised ones (only the Rust provider errors on shapes it can't
+    /// place).
+    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> Result<(QTerm, InnerKind)> {
         let QTerm::Tuple { tag, terms, .. } = &qterm else {
-            return (qterm, InnerKind::default());
+            return Ok((qterm, InnerKind::default()));
         };
         if &**tag != "document" {
-            return (qterm, InnerKind::default());
+            return Ok((qterm, InnerKind::default()));
         }
         if terms.len() != 1 {
             // empty file, or several top-level nodes (a whole page)
-            return (qterm, InnerKind::File);
+            return Ok((qterm, InnerKind::File));
         }
         let kind = match &*terms[0] {
             QTerm::Tuple { tag, .. } if is_expr_tag(tag) => InnerKind::Expr,
             _ => InnerKind::Stmt,
         };
-        (qterm.squash(), kind)
+        Ok((qterm.squash(), kind))
     }
 
     fn arity(&self, tag: &str) -> Arity {

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/langs/python/lang.rs

@@ -4,6 +4,7 @@ use crate::{
     term::Term,
     treesitter::{DynTSLanguage, TSLanguage, TSProvider},
 };
+use miette::Result;
 use tree_sitter::Parser;
 
 /**************************************************************/
@@ -50,9 +51,9 @@ impl TSProvider for PythonProvider {
         }
     }
 
-    fn unwrap(&self, qterm: QTerm, ikind: Option<InnerKind>) -> (QTerm, InnerKind) {
+    fn unwrap(&self, qterm: QTerm, ikind: Option<InnerKind>) -> Result<(QTerm, InnerKind)> {
         if qterm.len() != 1 {
-            return (qterm, InnerKind::File);
+            return Ok((qterm, InnerKind::File));
         }
         let qterm = qterm.squash();
         if qterm.tag() == QTermTag::tuple("expression_statement") {
@@ -61,28 +62,28 @@ impl TSProvider for PythonProvider {
             // the statement whole; bare tuples render without delimiters, so
             // the fragment splices flat into expression position.
             if qterm.len() != 1 {
-                return (qterm, InnerKind::Expr);
+                return Ok((qterm, InnerKind::Expr));
             }
             let inner = qterm.squash();
             if inner.tag() == QTermTag::tuple("assignment") {
                 // An assignment is always a statement, regardless of position.
-                return (inner, InnerKind::Stmt);
+                return Ok((inner, InnerKind::Stmt));
             }
             // A non-assignment expression statement like `foo()`. When the
             // caller explicitly placed the hole in statement position, honour
             // that: keep the `expression_statement` wrapper and report Stmt.
             // Otherwise treat it as a bare expression and squash to the inner.
             if ikind == Some(InnerKind::Stmt) {
-                return (qterm, InnerKind::Stmt);
+                return Ok((qterm, InnerKind::Stmt));
             }
-            return (inner, InnerKind::Expr);
+            return Ok((inner, InnerKind::Expr));
         }
         // If the caller explicitly expected an expression (e.g. the hole was
         // in expression position), trust that over the default Stmt guess.
         if ikind == Some(InnerKind::Expr) {
-            return (qterm, InnerKind::Expr);
+            return Ok((qterm, InnerKind::Expr));
         }
-        (qterm, InnerKind::Stmt)
+        Ok((qterm, InnerKind::Stmt))
     }
 }
 

quilt_python-0.2.0/quilt/src/langs/rust/lang.rs

@@ -0,0 +1,152 @@
+use crate::{
+    lang::{Arity, InnerKind},
+    qterm::QTerm,
+    treesitter::{DynTSLanguage, TSLanguage, TSProvider},
+};
+use miette::{miette, Result};
+use tree_sitter::Parser;
+
+/**************************************************************/
+
+pub struct RustProvider(tree_sitter::Parser);
+
+impl Default for RustProvider {
+    fn default() -> Self {
+        let mut parser = Parser::new();
+        parser
+            .set_language(&tree_sitter_rust::LANGUAGE.into())
+            .expect("Error loading Rust parser");
+        Self(parser)
+    }
+}
+
+impl TSProvider for RustProvider {
+    fn parser(&mut self) -> &mut tree_sitter::Parser {
+        &mut self.0
+    }
+
+    fn hole_str(&self) -> &'static str {
+        "{}"
+    }
+
+    fn unwrap(&self, qterm: QTerm, ikind: Option<InnerKind>) -> Result<(QTerm, InnerKind)> {
+        // dbg!(&qterm);
+        #[allow(clippy::single_match)]
+        Ok(match &qterm {
+            QTerm::Tuple { tag, terms, .. } => match &**tag {
+                "source_file" => {
+                    if terms.len() == 1 {
+                        let q0 = &terms[0];
+                        match &**q0 {
+                            QTerm::Tuple { tag, .. } => {
+                                // The hole's position (when known) settles
+                                // ambiguous bodies like a bare `{ }`; otherwise
+                                // guess from the tag.
+                                let kind = match ikind {
+                                    Some(k) if k != InnerKind::File => k,
+                                    _ if **tag == *"{}" => InnerKind::Stmt,
+                                    _ => self.typ(tag),
+                                };
+                                (qterm.squash(), kind)
+                            }
+                            _ => return Err(unsupported_shape(&qterm)),
+                        }
+                    } else {
+                        (qterm, InnerKind::File)
+                    }
+                }
+                "{}" => (qterm, InnerKind::Expr),
+                _ => return Err(unsupported_shape(&qterm)),
+            },
+            _ => return Err(unsupported_shape(&qterm)),
+        })
+    }
+
+    fn arity(&self, tag: &str) -> Arity {
+        match tag {
+            "block" | "source_file" => Arity::Variadic,
+            _ => Arity::Unknown,
+        }
+    }
+
+    fn typ(&self, tag: &str) -> InnerKind {
+        match tag {
+            "source_file" => InnerKind::File,
+            // `let_declaration` ends with "declaration" but is a statement, not
+            // an item — match it before the item rule below.
+            "let_declaration" => InnerKind::Stmt,
+            _ if tag.ends_with("item") || tag.ends_with("declaration") => InnerKind::Item,
+            _ if tag.ends_with("statement") => InnerKind::Stmt,
+            _ => InnerKind::Expr,
+        }
+    }
+
+    fn hole_kind(&self, node: tree_sitter::Node) -> InnerKind {
+        // A `block` is a value (expression) by tag, but in body/branch
+        // position it is a block body. Read the parent to tell the two apart:
+        // `fn f() {…}` / `loop {…}` use the `body` field, `if c {…}` uses
+        // `consequence`, and the `else {…}` block hangs off an `else_clause`.
+        // (A `block` in `value` position — `let x = {…}` — stays `Expr`.)
+        if node.kind() == "block" {
+            if let Some(parent) = node.parent() {
+                let is_body = parent.kind() == "else_clause"
+                    || ["body", "consequence"]
+                        .iter()
+                        .any(|field| parent.child_by_field_name(field) == Some(node));
+                if is_body {
+                    return InnerKind::Block;
+                }
+            }
+        }
+        self.typ(node.kind())
+    }
+
+    fn hashbang(&self) -> Option<&'static str> {
+        Some("#!/usr/bin/env rust-script")
+    }
+}
+
+/// Diagnostic for a Rust fragment whose tree-sitter parse shape the provider
+/// doesn't know how to unwrap. Replaces the `unimplemented!` panics that used
+/// to crash the expander on unusual-but-valid Rust (issue #11); the parse's
+/// s-expression is included so the gap can be reported and reproduced.
+fn unsupported_shape(qterm: &QTerm) -> miette::Report {
+    miette!(
+        "Quilt can't place this Rust fragment — unsupported parse shape: {}.\n\
+         This is a gap in Quilt's Rust support; please report it along with the \
+         fragment that triggered it.",
+        qterm.sexp()
+    )
+}
+
+pub type RustLanguage = TSLanguage<RustProvider>;
+pub type DynRustLanguage = DynTSLanguage<RustProvider>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::qterm::tb;
+
+    /// A parse shape the provider can't place (here, a root tag that is neither
+    /// `source_file` nor the `{}` hole) now surfaces a diagnostic instead of
+    /// panicking via `unimplemented!` (issue #11).
+    #[test]
+    fn unsupported_shape_returns_err_not_panic() {
+        let provider = RustProvider::default();
+        let err = provider
+            .unwrap(tb("not_a_real_node_kind").build(), None)
+            .expect_err("an unrecognised parse shape should be an error");
+        assert!(
+            err.to_string().contains("unsupported parse shape"),
+            "diagnostic should name the unsupported shape, got: {err}"
+        );
+    }
+
+    /// A well-formed single-node `source_file` still unwraps successfully.
+    #[test]
+    fn source_file_single_node_unwraps_ok() {
+        let provider = RustProvider::default();
+        let qterm = tb("source_file").c(&tb("expression_statement").b()).build();
+        assert!(provider.unwrap(qterm, None).is_ok());
+    }
+}

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/langs/typescript/lang.rs

@@ -4,6 +4,7 @@ use crate::{
     term::Term,
     treesitter::{DynTSLanguage, TSLanguage, TSProvider},
 };
+use miette::Result;
 use tree_sitter::Parser;
 
 /**************************************************************/
@@ -63,10 +64,10 @@ impl TSProvider for TypeScriptProvider {
     /// Python provider. A single top-level `expression_statement` squashes to
     /// its inner expression (so `ts↖foo()↗` splices in expression position);
     /// the hole's known position (`ikind`) settles the ambiguous cases.
-    fn unwrap(&self, qterm: QTerm, ikind: Option<InnerKind>) -> (QTerm, InnerKind) {
+    fn unwrap(&self, qterm: QTerm, ikind: Option<InnerKind>) -> Result<(QTerm, InnerKind)> {
         // empty file, or several top-level nodes — keep the `program` whole.
         if qterm.len() != 1 {
-            return (qterm, InnerKind::File);
+            return Ok((qterm, InnerKind::File));
         }
         let qterm = qterm.squash();
         if qterm.tag() == QTermTag::tuple("expression_statement") {
@@ -74,27 +75,27 @@ impl TSProvider for TypeScriptProvider {
             // sequence: keep the statement, but it splices flat as an
             // expression.
             if qterm.len() != 1 {
-                return (qterm, InnerKind::Expr);
+                return Ok((qterm, InnerKind::Expr));
             }
             let inner = qterm.squash();
             // When the caller explicitly placed the hole in statement position,
             // honour that (keep the `expression_statement`); otherwise treat a
             // bare expression statement as an expression.
             if ikind == Some(InnerKind::Stmt) {
-                return (qterm, InnerKind::Stmt);
+                return Ok((qterm, InnerKind::Stmt));
             }
-            return (inner, InnerKind::Expr);
+            return Ok((inner, InnerKind::Expr));
         }
         // A declaration / control-flow statement / other top-level node. Trust
         // an explicit expression expectation over the default Stmt guess.
         if ikind == Some(InnerKind::Expr) {
-            return (qterm, InnerKind::Expr);
+            return Ok((qterm, InnerKind::Expr));
         }
         let tag = match &qterm {
             QTerm::Tuple { tag, .. } => self.typ(tag),
             _ => InnerKind::Stmt,
         };
-        (qterm, tag)
+        Ok((qterm, tag))
     }
 }
 

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/langs/wgsl/lang.rs

@@ -10,6 +10,7 @@ use crate::{
     qterm::QTerm,
     treesitter::{DynTSLanguage, TSLanguage, TSProvider},
 };
+use miette::Result;
 use tree_sitter::Parser;
 
 /**************************************************************/
@@ -42,25 +43,26 @@ impl TSProvider for WgslProvider {
     ///
     /// The returned `InnerKind` is advisory only (`parse_pre` discards it; the
     /// emit heuristic re-derives the kind from the term via `classify_term`).
-    /// We never panic on an unexpected shape, unlike the Rust provider.
-    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> (QTerm, InnerKind) {
+    /// We accept any shape here rather than rejecting unrecognised ones, unlike
+    /// the Rust provider (which errors on shapes it can't place).
+    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> Result<(QTerm, InnerKind)> {
         let QTerm::Tuple { tag, terms, .. } = &qterm else {
-            return (qterm, InnerKind::default());
+            return Ok((qterm, InnerKind::default()));
         };
         if &**tag != "source_file" {
-            return (qterm, InnerKind::default());
+            return Ok((qterm, InnerKind::default()));
         }
         if terms.len() != 1 {
             // empty file, or several top-level declarations (a whole shader),
             // or a statement plus its trailing `;` — all kept whole. The
             // statement/`;` shape is recognised by `classify_term` below.
-            return (qterm, InnerKind::File);
+            return Ok((qterm, InnerKind::File));
         }
         let kind = match &*terms[0] {
             QTerm::Tuple { tag, .. } if is_expr_tag(tag) => InnerKind::Expr,
             _ => InnerKind::Stmt,
         };
-        (qterm.squash(), kind)
+        Ok((qterm.squash(), kind))
     }
 
     fn arity(&self, tag: &str) -> Arity {

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/langs/zsh/lang.rs

@@ -10,6 +10,7 @@ use crate::{
     qterm::QTerm,
     treesitter::{DynTSLanguage, TSLanguage, TSProvider},
 };
+use miette::Result;
 use tree_sitter::Parser;
 
 /**************************************************************/
@@ -43,21 +44,21 @@ impl TSProvider for ZshProvider {
     /// Squash the `program` wrapper around a single quoted fragment so the
     /// term is the fragment itself (command / statement). A multi-statement
     /// fragment (a whole script) stays a `program`.
-    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> (QTerm, InnerKind) {
+    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> Result<(QTerm, InnerKind)> {
         let QTerm::Tuple { tag, terms, .. } = &qterm else {
-            return (qterm, InnerKind::default());
+            return Ok((qterm, InnerKind::default()));
         };
         if &**tag != "program" {
-            return (qterm, InnerKind::default());
+            return Ok((qterm, InnerKind::default()));
         }
         if terms.len() != 1 {
-            return (qterm, InnerKind::File);
+            return Ok((qterm, InnerKind::File));
         }
         let kind = match &*terms[0] {
             QTerm::Tuple { tag, .. } if is_expr_tag(tag) => InnerKind::Expr,
             _ => InnerKind::Stmt,
         };
-        (qterm.squash(), kind)
+        Ok((qterm.squash(), kind))
     }
 
     fn arity(&self, tag: &str) -> Arity {

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/multi.rs

@@ -1,4 +1,4 @@
-use crate::lang::{Arity, InnerKind, Language, LanguagePost};
+use crate::lang::{Arity, Language, LanguagePost};
 #[cfg(feature = "parse")]
 use crate::lang::{FlatNode, Hole};
 use crate::meta::{MetaLanguage, OuterKind};
@@ -476,9 +476,8 @@ impl<M: MetaLanguage + ?Sized, LS: Languages> Expander<'_, LS, M> {
                                     ..
                                 } = &**term
                                 {
-                                    if self.langs.get(self.lang)?.typ(qtag) == InnerKind::Stmt
-                                        && self.langs.get(lang2)?.classify_term(body)
-                                            == InnerKind::Stmt
+                                    if self.langs.get(self.lang)?.typ(qtag).is_stmt_like()
+                                        && self.langs.get(lang2)?.classify_term(body).is_stmt_like()
                                     {
                                         okind = OuterKind::Emit;
                                     }
@@ -550,7 +549,7 @@ impl<M: MetaLanguage + ?Sized, LS: Languages> Expander<'_, LS, M> {
                                 {
                                     if index == d {
                                         if let QTerm::Tuple { tag, .. } = &**child {
-                                            if self.langs.get(lang1)?.typ(tag) == InnerKind::Stmt {
+                                            if self.langs.get(lang1)?.typ(tag).is_stmt_like() {
                                                 okind = OuterKind::Splice;
                                             }
                                         }

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/src/treesitter.rs

@@ -46,8 +46,8 @@ pub trait TSProvider {
     /// A string representing a hole where another language is dropped in.
     /// Must not contain new-lines.
     fn hole_str(&self) -> &'static str;
-    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> (QTerm, InnerKind) {
-        (qterm, Default::default())
+    fn unwrap(&self, qterm: QTerm, _ikind: Option<InnerKind>) -> Result<(QTerm, InnerKind)> {
+        Ok((qterm, Default::default()))
     }
     fn arity(&self, _tag: &str) -> Arity {
         Default::default()
@@ -58,6 +58,19 @@ pub trait TSProvider {
         Default::default()
     }
 
+    /// The [`InnerKind`] a hole at this tree-sitter node's position demands.
+    ///
+    /// Unlike [`typ`](TSProvider::typ), which only sees a node's *kind* (its
+    /// tag), this is handed the node in its parse tree, so it can read context
+    /// the tag alone can't express. The motivating case is [`InnerKind::Block`]:
+    /// a Rust `block` is an expression by tag (`let x = { … }`), but in body
+    /// position (`fn f() { … }`, `loop { … }`, `if c { … }`) it denotes a block
+    /// body. The default ignores the extra context and falls back to
+    /// `typ(node.kind())`.
+    fn hole_kind(&self, node: tree_sitter::Node) -> InnerKind {
+        self.typ(node.kind())
+    }
+
     /// Classify a fully-parsed term to determine its kind.  Unlike [`typ`],
     /// which only sees the root tag, this can inspect the full term tree.
     /// The default falls back to `typ` on the root tag; override for languages
@@ -122,7 +135,10 @@ impl<P: TSProvider> Language for TSLanguage<P> {
                 hole_points.next();
                 holes.push(Hole {
                     otag: node.kind().into(),
-                    ikind: Some(provider.typ(node.kind())),
+                    // `hole_kind` (not `typ`) so the surrounding tree can refine
+                    // the kind — e.g. a body-position `block` becomes `Block`
+                    // rather than the `Expr` its tag alone implies.
+                    ikind: Some(provider.hole_kind(node)),
                     prefix: prefix.clone().into(),
                 });
                 return qsym(hole_str);
@@ -262,7 +278,7 @@ impl<P: TSProvider> Language for TSLanguage<P> {
             &mut prefix,
             true,
         );
-        let (qterm, _ikind) = self.provider.unwrap(qterm, ikind);
+        let (qterm, _ikind) = self.provider.unwrap(qterm, ikind)?;
         let holes = holes.into();
         let hole_str = self.provider.hole_str();
 

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/tests/inner_kinds.rs

@@ -14,10 +14,14 @@
 //! 3. Python `unwrap` respects `ikind` — when the caller passes an explicit
 //!    `InnerKind` hint, Python's `unwrap` uses it instead of guessing.
 //!
-//! (Issue #25 items #2 `typ` for target languages and #4 `InnerKind::Block`
-//! are deferred: both need the emit/splice heuristic to classify a child by its
-//! *own* language rather than the enclosing quote's before they can be added
-//! without breaking the existing splice behaviour.)
+//! (Issue #25 item #2 — `typ` for target languages — is still deferred: it
+//! needs the emit/splice heuristic to classify a child by its *own* language
+//! rather than the enclosing quote's before it can be added without breaking
+//! the existing splice behaviour. Item #4 — `InnerKind::Block` — has since
+//! landed via issue #10: rather than mapping the `{}` placeholder's tag (which
+//! would poison every Rust expression hole), `TSProvider::hole_kind` reads the
+//! hole's parent in the parse tree, so only body-position blocks become
+//! `Block`. See `rs_block_hole_ikind` in tests/kinds.rs.)
 
 use indoc::indoc;
 use quilt::{

{quilt_python-0.1.0 → quilt_python-0.2.0}/quilt/tests/kinds.rs

@@ -71,6 +71,57 @@ fn rs_hole_ikinds() -> Result<()> {
     Ok(())
 }
 
+/// `typ` distinguishes items (definitions) from statements and expressions.
+#[test]
+fn rs_typ_kinds() {
+    use quilt::lang::Language as _;
+    let lang = RustLanguage::default();
+    assert_eq!(lang.typ("source_file"), InnerKind::File);
+    assert_eq!(lang.typ("function_item"), InnerKind::Item);
+    assert_eq!(lang.typ("struct_item"), InnerKind::Item);
+    assert_eq!(lang.typ("use_declaration"), InnerKind::Item);
+    // `let` is a statement, not an item, despite the "declaration" suffix.
+    assert_eq!(lang.typ("let_declaration"), InnerKind::Stmt);
+    assert_eq!(lang.typ("expression_statement"), InnerKind::Stmt);
+    assert_eq!(lang.typ("binary_expression"), InnerKind::Expr);
+    // A `block`'s tag alone is an expression (a block expression).
+    assert_eq!(lang.typ("block"), InnerKind::Expr);
+}
+
+/// A hole in block-body position is typed `Block`, while a hole in value
+/// position stays `Expr` — even though both are spelled with the same `{}`
+/// placeholder. The distinction comes from `hole_kind` reading the parent.
+#[test]
+fn rs_block_hole_ikind() -> Result<()> {
+    use quilt::lang::{FlatNode, LanguagePost as _};
+    let mut lang = RustLanguage::default();
+
+    // `fn f() <hole>` — the hole is the function body block.
+    let body = [FlatNode::Str("fn f() "), FlatNode::Hole];
+    let kinds = lang
+        .parse_pre(None, &body)?
+        .holes()
+        .iter()
+        .map(|h| h.ikind)
+        .collect::<Vec<_>>();
+    assert_eq!(kinds, [Some(InnerKind::Block)]);
+
+    // `let x = <hole>;` — the hole is the let value, an expression.
+    let value = [
+        FlatNode::Str("let x = "),
+        FlatNode::Hole,
+        FlatNode::Str(";"),
+    ];
+    let kinds = lang
+        .parse_pre(None, &value)?
+        .holes()
+        .iter()
+        .map(|h| h.ikind)
+        .collect::<Vec<_>>();
+    assert_eq!(kinds, [Some(InnerKind::Expr)]);
+    Ok(())
+}
+
 #[test]
 fn rs_auto_stmt() -> Result<()> {
     rs_helper(None, "let x = 1 + 2;", &QTermTag::tuple("let_declaration"))

{quilt_python-0.1.0 → quilt_python-0.2.0}/tree-sitter-quilt/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tree-sitter-quilt"
 description = "Quilt grammar for tree-sitter"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Alexander Varga <varga.alex@gmail.com>"]
 license.workspace = true
 keywords = ["incremental", "parsing", "tree-sitter", "quilt"]

quilt_python-0.1.0/quilt/src/langs/rust/lang.rs

@@ -1,90 +0,0 @@
-use crate::{
-    lang::{Arity, InnerKind},
-    qterm::QTerm,
-    treesitter::{DynTSLanguage, TSLanguage, TSProvider},
-};
-use tree_sitter::Parser;
-
-/**************************************************************/
-
-pub struct RustProvider(tree_sitter::Parser);
-
-impl Default for RustProvider {
-    fn default() -> Self {
-        let mut parser = Parser::new();
-        parser
-            .set_language(&tree_sitter_rust::LANGUAGE.into())
-            .expect("Error loading Rust parser");
-        Self(parser)
-    }
-}
-
-impl TSProvider for RustProvider {
-    fn parser(&mut self) -> &mut tree_sitter::Parser {
-        &mut self.0
-    }
-
-    fn hole_str(&self) -> &'static str {
-        "{}"
-    }
-
-    fn unwrap(&self, qterm: QTerm, ikind: Option<InnerKind>) -> (QTerm, InnerKind) {
-        // dbg!(&qterm);
-        #[allow(clippy::single_match)]
-        match &qterm {
-            QTerm::Tuple { tag, terms, .. } => match &**tag {
-                "source_file" => {
-                    if terms.len() == 1 {
-                        let q0 = &terms[0];
-                        match &**q0 {
-                            QTerm::Tuple { tag, .. } => {
-                                // The hole's position (when known) settles
-                                // ambiguous bodies like a bare `{ }`; otherwise
-                                // guess from the tag.
-                                let kind = match ikind {
-                                    Some(k) if k != InnerKind::File => k,
-                                    _ if **tag == *"{}" => InnerKind::Stmt,
-                                    _ => self.typ(tag),
-                                };
-                                (qterm.squash(), kind)
-                            }
-                            _ => unimplemented!("{}", qterm.sexp()),
-                        }
-                    } else {
-                        (qterm, InnerKind::File)
-                    }
-                }
-                "{}" => (qterm, InnerKind::Expr),
-                _ => unimplemented!("{}", qterm.sexp()),
-            },
-            _ => unimplemented!("{}", qterm.sexp()),
-        }
-    }
-
-    fn arity(&self, tag: &str) -> Arity {
-        match tag {
-            "block" | "source_file" => Arity::Variadic,
-            _ => Arity::Unknown,
-        }
-    }
-
-    fn typ(&self, tag: &str) -> InnerKind {
-        if tag == "source_file" {
-            InnerKind::File
-        } else if tag.ends_with("statement")
-            || tag.ends_with("item")
-            || tag.ends_with("declaration")
-        {
-            InnerKind::Stmt
-        } else {
-            InnerKind::Expr
-        }
-    }
-
-    fn hashbang(&self) -> Option<&'static str> {
-        Some("#!/usr/bin/env rust-script")
-    }
-}
-
-pub type RustLanguage = TSLanguage<RustProvider>;
-pub type DynRustLanguage = DynTSLanguage<RustProvider>;