rune-rs · udoprog · Jul 23, 2024 · Jul 23, 2024 · Jul 23, 2024
diff --git a/crates/rune-core/src/hash/to_type_hash.rs b/crates/rune-core/src/hash/to_type_hash.rs
@@ -2,7 +2,8 @@ use core::hash::{self, Hash as _, Hasher as _};
 
 #[cfg(feature = "alloc")]
 use crate::alloc;
-use crate::hash::{Hash, TYPE};
+use crate::hash::Hash;
+use crate::hash::TYPE;
 use crate::item::{IntoComponent, ItemBuf};
 
 /// Helper trait used to convert a type into a type hash.

diff --git a/crates/rune-core/src/item/item.rs b/crates/rune-core/src/item/item.rs
@@ -24,7 +24,7 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{Item, ItemBuf};
+    /// use rune::{Item, ItemBuf};
     ///
     /// assert_eq!(Item::new(), &*ItemBuf::new());
     /// ```
@@ -44,7 +44,7 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{Item, ItemBuf};
+    /// use rune::{Item, ItemBuf};
     ///
     /// let item = ItemBuf::with_item(["foo", "bar"])?;
     ///
@@ -61,7 +61,7 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{Item, ItemBuf};
+    /// use rune::{Item, ItemBuf};
     ///
     /// assert_eq!(Item::new().as_bytes(), b"");
     ///
@@ -79,7 +79,7 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::ItemBuf;
+    /// use rune::ItemBuf;
     ///
     /// let item = ItemBuf::with_crate("std")?;
     /// assert_eq!(item.as_crate(), Some("std"));
@@ -101,7 +101,8 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{ComponentRef, ItemBuf};
+    /// use rune::ItemBuf;
+    /// use rune::item::ComponentRef;
     ///
     /// let item = ItemBuf::with_item(["foo", "bar"])?;
     /// assert_eq!(item.first(), Some(ComponentRef::Str("foo")));
@@ -117,7 +118,7 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::ItemBuf;
+    /// use rune::ItemBuf;
     ///
     /// let item = ItemBuf::new();
     /// assert!(item.is_empty());
@@ -154,7 +155,8 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{Item, ComponentRef};
+    /// use rune::Item;
+    /// use rune::item::ComponentRef;
     ///
     /// let item = Item::new();
     /// assert!(item.is_empty());
@@ -185,7 +187,8 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{Item, ComponentRef};
+    /// use rune::Item;
+    /// use rune::item::ComponentRef;
     ///
     /// let item = Item::new();
     /// assert!(item.is_empty());
@@ -217,7 +220,8 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{ComponentRef, IntoComponent, ItemBuf};
+    /// use rune::ItemBuf;
+    /// use rune::item::{ComponentRef, IntoComponent};
     ///
     /// let mut item = ItemBuf::new();
     ///
@@ -260,7 +264,7 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{Item, ItemBuf};
+    /// use rune::{Item, ItemBuf};
     ///
     /// assert!(Item::new().is_super_of(Item::new(), 1));
     /// assert!(!ItemBuf::with_item(["a"])?.is_super_of(Item::new(), 1));
@@ -304,7 +308,7 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{Item, ItemBuf};
+    /// use rune::{Item, ItemBuf};
     ///
     /// assert_eq!(
     ///     (ItemBuf::new(), ItemBuf::new()),
@@ -368,7 +372,7 @@ impl Item {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::ItemBuf;
+    /// use rune::ItemBuf;
     ///
     /// let item = ItemBuf::with_item(["foo", "bar", "baz"])?;
     /// let item2 = ItemBuf::with_item(["foo", "bar"])?;
@@ -416,8 +420,9 @@ impl TryToOwned for Item {
 /// # Examples
 ///
 /// ```
-/// use rune::compile::{ComponentRef, ItemBuf};
 /// use rune::alloc::prelude::*;
+/// use rune::ItemBuf;
+/// use rune::item::ComponentRef;
 ///
 /// let root = ItemBuf::new().try_to_string()?;
 /// assert_eq!("{root}", root);

diff --git a/crates/rune-core/src/item/item_buf.rs b/crates/rune-core/src/item/item_buf.rs
@@ -155,7 +155,7 @@ impl ItemBuf {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::ItemBuf;
+    /// use rune::ItemBuf;
     ///
     /// let item = ItemBuf::new();
     /// let mut it = item.iter();
@@ -173,7 +173,8 @@ impl ItemBuf {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{ComponentRef, ItemBuf};
+    /// use rune::ItemBuf;
+    /// use rune::item::ComponentRef;
     ///
     /// let item = ItemBuf::with_item(["foo", "bar"])?;
     /// let mut it = item.iter();
@@ -196,7 +197,8 @@ impl ItemBuf {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{ComponentRef, ItemBuf};
+    /// use rune::ItemBuf;
+    /// use rune::item::ComponentRef;
     ///
     /// let mut item = ItemBuf::with_crate("std")?;
     /// item.push("foo");
@@ -217,7 +219,8 @@ impl ItemBuf {
     /// # Examples
     ///
     /// ```
-    /// use rune::compile::{ComponentRef, ItemBuf};
+    /// use rune::ItemBuf;
+    /// use rune::item::ComponentRef;
     ///
     /// let item = ItemBuf::with_crate_item("std", ["option"])?;
     /// assert_eq!(item.as_crate(), Some("std"));

diff --git a/crates/rune-core/src/item/iter.rs b/crates/rune-core/src/item/iter.rs
@@ -46,6 +46,8 @@ impl<'a> Iter<'a> {
     ///
     /// Will consume the next component in the iterator, but will only indicate
     /// if the next component was present, and was a [Component::Str].
+    ///
+    /// [Component::Str]: super::Component::Str
     pub fn next_str(&mut self) -> Option<&'a str> {
         match self.next()? {
             ComponentRef::Str(s) => Some(s),
@@ -57,6 +59,8 @@ impl<'a> Iter<'a> {
     ///
     /// Will consume the next component in the iterator, but will only indicate
     /// if the next component was present, and was a [Component::Str].
+    ///
+    /// [Component::Str]: super::Component::Str
     pub fn next_back_str(&mut self) -> Option<&'a str> {
         match self.next_back()? {
             ComponentRef::Str(s) => Some(s),

diff --git a/crates/rune-core/src/lib.rs b/crates/rune-core/src/lib.rs
@@ -37,22 +37,8 @@ extern crate std as rust_std;
 extern crate alloc as rust_alloc;
 
 pub use rune_alloc as alloc;
-
-mod hash;
-#[doc(hidden)]
-pub use hash::ParametersBuilder;
-pub use hash::{Hash, IntoHash, ToTypeHash};
-
-mod item;
-#[cfg(feature = "alloc")]
-pub use self::item::Component;
-pub use self::item::{ComponentRef, IntoComponent, Item, ItemBuf};
-
-mod raw_str;
-pub use self::raw_str::RawStr;
-
-mod protocol;
-pub use self::protocol::Protocol;
-
-mod params;
-pub use self::params::Params;
+pub mod hash;
+pub mod item;
+pub mod params;
+pub mod protocol;
+pub mod raw_str;
diff --git a/crates/rune-macros/src/any.rs b/crates/rune-macros/src/any.rs
@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 
 use proc_macro2::TokenStream;
 use quote::{quote, quote_spanned, ToTokens};
-use rune_core::Hash;
+use rune_core::hash::Hash;
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::Token;

diff --git a/crates/rune-macros/src/hash.rs b/crates/rune-macros/src/hash.rs
@@ -1,6 +1,7 @@
 use core::mem::take;
 
-use rune_core::{ComponentRef, Hash, ItemBuf};
+use rune_core::hash::Hash;
+use rune_core::item::{ComponentRef, ItemBuf};
 
 /// Construct a type hash from a Rust path.
 pub(crate) fn build_type_hash(path: &syn::Path) -> syn::Result<Hash> {

diff --git a/crates/rune-macros/src/item.rs b/crates/rune-macros/src/item.rs
@@ -1,7 +1,7 @@
 use core::mem::take;
 
 use proc_macro2::Span;
-use rune_core::{ComponentRef, ItemBuf};
+use rune_core::item::{ComponentRef, ItemBuf};
 
 /// Construct a static item from a path.
 pub(crate) fn build_item(path: &syn::Path) -> syn::Result<syn::ExprArray> {

diff --git a/crates/rune-shim/src/lib.rs b/crates/rune-shim/src/lib.rs
@@ -2,8 +2,8 @@
 pub use rune_alloc as alloc;
 
 #[cfg(feature = "rune-core")]
-pub mod compile {
-    pub use rune_core::{Component, ComponentRef, IntoComponent, Item, ItemBuf};
+pub mod item {
+    pub use rune_core::item::{Component, ComponentRef, IntoComponent, Item, ItemBuf};
 }
 
 pub mod support {
@@ -12,4 +12,4 @@ pub mod support {
 }
 
 #[cfg(feature = "rune-core")]
-pub use rune_core::{Item, ItemBuf};
+pub use rune_core::item::{Item, ItemBuf};
diff --git a/crates/rune/src/ast/attribute.rs b/crates/rune/src/ast/attribute.rs
@@ -2,8 +2,6 @@ use crate::ast::prelude::*;
 
 #[test]
 fn ast_parse() {
-    use crate::testing::rt;
-
     rt::<ast::Attribute>("#[foo = \"foo\"]");
     rt::<ast::Attribute>("#[foo()]");
     rt::<ast::Attribute>("#![foo]");

diff --git a/crates/rune/src/ast/block.rs b/crates/rune/src/ast/block.rs
@@ -2,8 +2,6 @@ use crate::ast::prelude::*;
 
 #[test]
 fn ast_parse() {
-    use crate::testing::rt;
-
     let expr = rt::<ast::ExprBlock>("{}");
     assert_eq!(expr.block.statements.len(), 0);
 

diff --git a/crates/rune/src/ast/condition.rs b/crates/rune/src/ast/condition.rs
@@ -2,8 +2,6 @@ use crate::ast::prelude::*;
 
 #[test]
 fn ast_parse() {
-    use crate::testing::rt;
-
     rt::<ast::Condition>("true");
     rt::<ast::Condition>("let [a, ..] = v");
 }

diff --git a/crates/rune/src/ast/expr.rs b/crates/rune/src/ast/expr.rs
@@ -5,16 +5,14 @@ use crate::ast::prelude::*;
 
 #[test]
 fn ast_parse() {
-    use crate::testing::rt;
-
     rt::<ast::Expr>("()");
     rt::<ast::Expr>("foo[\"foo\"]");
+    rt::<ast::Expr>("foo[\"bar\"]");
     rt::<ast::Expr>("foo.bar()");
     rt::<ast::Expr>("var()");
     rt::<ast::Expr>("var");
     rt::<ast::Expr>("42");
     rt::<ast::Expr>("1 + 2 / 3 - 4 * 1");
-    rt::<ast::Expr>("foo[\"bar\"]");
     rt::<ast::Expr>("let var = 42");
     rt::<ast::Expr>("let var = \"foo bar\"");
     rt::<ast::Expr>("var[\"foo\"] = \"bar\"");
@@ -47,6 +45,26 @@ fn ast_parse() {
     rt::<ast::Expr>("[false, 1, 'b']");
 }
 
+#[test]
+fn expr_if() {
+    let expr = rt::<ast::Expr>(r#"if true {} else {}"#);
+    assert!(matches!(expr, ast::Expr::If(..)));
+
+    let expr = rt::<ast::Expr>("if 1 { } else { if 2 { } else { } }");
+    assert!(matches!(expr, ast::Expr::If(..)));
+}
+
+#[test]
+fn expr_while() {
+    let expr = rt::<ast::Expr>(r#"while true {}"#);
+    assert!(matches!(expr, ast::Expr::While(..)));
+}
+
+#[test]
+fn test_macro_call_chain() {
+    rt::<ast::Expr>("format!(\"{}\", a).bar()");
+}
+
 /// Indicator that an expression should be parsed with an eager brace.
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct EagerBrace(bool);
@@ -785,51 +803,3 @@ fn paren_group(p: &mut Parser<'_>, attributes: Vec<ast::Attribute>) -> Result<Ex
         p, attributes, open, expr,
     )?))
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::ast;
-    use crate::testing::rt;
-
-    #[test]
-    fn test_expr_if() {
-        let expr = rt::<ast::Expr>(r#"if true {} else {}"#);
-        assert!(matches!(expr, ast::Expr::If(..)));
-
-        let expr = rt::<ast::Expr>("if 1 { } else { if 2 { } else { } }");
-        assert!(matches!(expr, ast::Expr::If(..)));
-    }
-
-    #[test]
-    fn test_expr_while() {
-        let expr = rt::<ast::Expr>(r#"while true {}"#);
-        assert!(matches!(expr, ast::Expr::While(..)));
-    }
-
-    #[test]
-    fn test_expr() {
-        rt::<ast::Expr>("foo[\"foo\"]");
-        rt::<ast::Expr>("foo.bar()");
-        rt::<ast::Expr>("var()");
-        rt::<ast::Expr>("var");
-        rt::<ast::Expr>("42");
-        rt::<ast::Expr>("1 + 2 / 3 - 4 * 1");
-        rt::<ast::Expr>("foo[\"bar\"]");
-        rt::<ast::Expr>("let var = 42");
-        rt::<ast::Expr>("let var = \"foo bar\"");
-        rt::<ast::Expr>("var[\"foo\"] = \"bar\"");
-        rt::<ast::Expr>("let var = objects[\"foo\"] + 1");
-        rt::<ast::Expr>("var = 42");
-
-        // Chained function calls.
-        rt::<ast::Expr>("foo.bar.baz()");
-        rt::<ast::Expr>("foo[0][1][2]");
-        rt::<ast::Expr>("foo.bar()[0].baz()[1]");
-        rt::<ast::Expr>("42 is i64::i64");
-    }
-
-    #[test]
-    fn test_macro_call_chain() {
-        rt::<ast::Expr>("format!(\"{}\", a).bar()");
-    }
-}
diff --git a/crates/rune/src/ast/expr_assign.rs b/crates/rune/src/ast/expr_assign.rs
@@ -2,8 +2,6 @@ use crate::ast::prelude::*;
 
 #[test]
 fn ast_parse() {
-    use crate::testing::rt;
-
     rt::<ast::ExprAssign>("a = 2");
     rt::<ast::ExprAssign>("a = b = 3");
 }