Unbreak feature combination builds

crates/rune/src/compile/context.rs

@@ -7,7 +7,9 @@ use crate::no_std::sync::Arc;
 use crate::compile::meta;
 #[cfg(feature = "doc")]
 use crate::compile::Docs;
-use crate::compile::{ComponentRef, ContextError, IntoComponent, Item, ItemBuf, MetaInfo, Names};
+#[cfg(feature = "emit")]
+use crate::compile::MetaInfo;
+use crate::compile::{ComponentRef, ContextError, IntoComponent, Item, ItemBuf, Names};
 use crate::hash;
 use crate::module::{
     Fields, InternalEnum, Module, ModuleAssociated, ModuleAttributeMacro, ModuleConstant,
@@ -35,6 +37,7 @@ pub(crate) struct ContextMeta {
 }
 
 impl ContextMeta {
+    #[cfg(feature = "emit")]
     pub(crate) fn info(&self) -> MetaInfo {
         MetaInfo::new(&self.kind, self.hash, self.item.as_deref())
     }

crates/rune/src/compile/error.rs

@@ -212,6 +212,7 @@ pub(crate) enum ErrorKind {
     },
     ModAlreadyLoaded {
         item: ItemBuf,
+        #[cfg(feature = "emit")]
         existing: (SourceId, Span),
     },
     MissingMacro {
@@ -268,7 +269,9 @@ pub(crate) enum ErrorKind {
     UnsupportedPatternExpr,
     UnsupportedBinding,
     DuplicateObjectKey {
+        #[cfg(feature = "emit")]
         existing: Span,
+        #[cfg(feature = "emit")]
         object: Span,
     },
     InstanceFunctionOutsideImpl,
@@ -279,6 +282,7 @@ pub(crate) enum ErrorKind {
     ContinueOutsideOfLoop,
     SelectMultipleDefaults,
     ExpectedBlockSemiColon {
+        #[cfg(feature = "emit")]
         followed_span: Span,
     },
     FnConstAsyncConflict,
@@ -339,13 +343,16 @@ pub(crate) enum ErrorKind {
         name: Box<str>,
     },
     VariableMoved {
+        #[cfg(feature = "emit")]
         moved_at: Span,
     },
     UnsupportedGenerics,
     NestedTest {
+        #[cfg(feature = "emit")]
         nested_span: Span,
     },
     NestedBench {
+        #[cfg(feature = "emit")]
         nested_span: Span,
     },
     MissingFunctionHash {
@@ -356,6 +363,7 @@ pub(crate) enum ErrorKind {
     },
     PatternMissingFields {
         item: ItemBuf,
+        #[cfg(feature = "emit")]
         fields: Box<[Box<str>]>,
     },
     MissingLabelLocation {
@@ -412,21 +420,27 @@ pub(crate) enum ErrorKind {
     BadNumberLiteral,
     AmbiguousItem {
         item: ItemBuf,
+        #[cfg(feature = "emit")]
         locations: Vec<(Location, ItemBuf)>,
     },
     AmbiguousContextItem {
         item: ItemBuf,
+        #[cfg(feature = "emit")]
         infos: Box<[MetaInfo]>,
     },
     NotVisible {
+        #[cfg(feature = "emit")]
         chain: Vec<Location>,
+        #[cfg(feature = "emit")]
         location: Location,
         visibility: Visibility,
         item: ItemBuf,
         from: ItemBuf,
     },
     NotVisibleMod {
+        #[cfg(feature = "emit")]
         chain: Vec<Location>,
+        #[cfg(feature = "emit")]
         location: Location,
         visibility: Visibility,
         item: ItemBuf,
@@ -436,6 +450,7 @@ pub(crate) enum ErrorKind {
         item: ItemBuf,
     },
     ImportCycle {
+        #[cfg(feature = "emit")]
         path: Vec<ImportStep>,
     },
     ImportRecursionLimit {

crates/rune/src/compile/pool.rs

@@ -4,7 +4,9 @@ use core::fmt;
 
 use crate::no_std::collections::HashMap;
 
-use crate::compile::{Item, ItemBuf, Location, Visibility};
+#[cfg(feature = "emit")]
+use crate::compile::Location;
+use crate::compile::{Item, ItemBuf, Visibility};
 use crate::hash::Hash;
 
 /// The identifier of a module.
@@ -34,6 +36,7 @@ impl fmt::Display for ItemId {
 #[non_exhaustive]
 pub(crate) struct ModMeta {
     /// The location of the module.
+    #[cfg(feature = "emit")]
     pub(crate) location: Location,
     /// The item of the module.
     pub(crate) item: ItemId,

crates/rune/src/compile/v1/scopes.rs

@@ -143,11 +143,12 @@ impl<'hir> Scopes<'hir> {
                 tracing::trace!(?var, "getting var");
                 q.visitor.visit_variable_use(self.source_id, var.span, span);
 
-                if let Some(moved_at) = var.moved_at {
+                if let Some(_moved_at) = var.moved_at {
                     return Err(compile::Error::new(
                         span,
                         ErrorKind::VariableMoved {
-                            moved_at: moved_at.span(),
+                            #[cfg(feature = "emit")]
+                            moved_at: _moved_at.span(),
                         },
                     ));
                 }
@@ -177,11 +178,12 @@ impl<'hir> Scopes<'hir> {
                 tracing::trace!(?var, "taking var");
                 q.visitor.visit_variable_use(self.source_id, var.span, span);
 
-                if let Some(moved_at) = var.moved_at {
+                if let Some(_moved_at) = var.moved_at {
                     return Err(compile::Error::new(
                         span,
                         ErrorKind::VariableMoved {
-                            moved_at: moved_at.span(),
+                            #[cfg(feature = "emit")]
+                            moved_at: _moved_at.span(),
                         },
                     ));
                 }

crates/rune/src/hir/lowering.rs

@@ -372,11 +372,13 @@ pub(crate) fn expr_object<'hir>(
     let assignments = &mut *iter!(&ast.assignments, |(ast, _)| {
         let key = object_key(cx, &ast.key)?;
 
-        if let Some(existing) = keys_dup.insert(key.1, key.0) {
+        if let Some(_existing) = keys_dup.insert(key.1, key.0) {
             return Err(compile::Error::new(
                 key.0,
                 ErrorKind::DuplicateObjectKey {
-                    existing: existing.span(),
+                    #[cfg(feature = "emit")]
+                    existing: _existing.span(),
+                    #[cfg(feature = "emit")]
                     object: key.0.span(),
                 },
             ));
@@ -1206,11 +1208,13 @@ fn pat<'hir>(cx: &mut Ctxt<'hir, '_, '_>, ast: &ast::Pat) -> compile::Result<hir
                     }
                 };
 
-                if let Some(existing) = keys_dup.insert(key, pat) {
+                if let Some(_existing) = keys_dup.insert(key, pat) {
                     return Err(compile::Error::new(
                         pat,
                         ErrorKind::DuplicateObjectKey {
-                            existing: existing.span(),
+                            #[cfg(feature = "emit")]
+                            existing: _existing.span(),
+                            #[cfg(feature = "emit")]
                             object: pat.span(),
                         },
                     ));
@@ -1259,6 +1263,7 @@ fn pat<'hir>(cx: &mut Ctxt<'hir, '_, '_>, ast: &ast::Pat) -> compile::Result<hir
                             ast,
                             ErrorKind::PatternMissingFields {
                                 item: cx.q.pool.item(meta.item_meta.item).to_owned(),
+                                #[cfg(feature = "emit")]
                                 fields,
                             },
                         ));

crates/rune/src/indexing/index.rs

@@ -458,12 +458,13 @@ impl<'a, 'arena> Indexer<'a, 'arena> {
                 .load(root, self.q.pool.module_item(mod_item), &*item_mod)?;
 
         if let Some(loaded) = self.loaded.as_mut() {
-            if let Some(existing) = loaded.insert(mod_item, (self.source_id, item_mod.span())) {
+            if let Some(_existing) = loaded.insert(mod_item, (self.source_id, item_mod.span())) {
                 return Err(compile::Error::new(
                     &*item_mod,
                     ErrorKind::ModAlreadyLoaded {
                         item: self.q.pool.module_item(mod_item).to_owned(),
-                        existing,
+                        #[cfg(feature = "emit")]
+                        existing: _existing,
                     },
                 ));
             }
@@ -756,10 +757,13 @@ fn item_fn(idx: &mut Indexer<'_, '_>, mut ast: ast::ItemFn) -> compile::Result<(
 
     let is_test = match p.try_parse::<attrs::Test>(resolve_context!(idx.q), &ast.attributes)? {
         Some((attr, _)) => {
-            if let Some(nested_span) = idx.nested_item {
+            if let Some(_nested_span) = idx.nested_item {
                 return Err(compile::Error::new(
                     attr,
-                    ErrorKind::NestedTest { nested_span },
+                    ErrorKind::NestedTest {
+                        #[cfg(feature = "emit")]
+                        nested_span: _nested_span,
+                    },
                 ));
             }
 
@@ -770,12 +774,15 @@ fn item_fn(idx: &mut Indexer<'_, '_>, mut ast: ast::ItemFn) -> compile::Result<(
 
     let is_bench = match p.try_parse::<attrs::Bench>(resolve_context!(idx.q), &ast.attributes)? {
         Some((attr, _)) => {
-            if let Some(nested_span) = idx.nested_item {
+            if let Some(_nested_span) = idx.nested_item {
                 let span = attr.span().join(ast.descriptive_span());
 
                 return Err(compile::Error::new(
                     span,
-                    ErrorKind::NestedBench { nested_span },
+                    ErrorKind::NestedBench {
+                        #[cfg(feature = "emit")]
+                        nested_span: _nested_span,
+                    },
                 ));
             }
 
@@ -940,6 +947,7 @@ fn statements(idx: &mut Indexer<'_, '_>, ast: &mut Vec<ast::Stmt>) -> compile::R
             return Err(compile::Error::new(
                 span,
                 ErrorKind::ExpectedBlockSemiColon {
+                    #[cfg(feature = "emit")]
                     followed_span: stmt.span(),
                 },
             ));

crates/rune/src/lib.rs

@@ -208,8 +208,8 @@ mod exported_macros;
 #[macro_use]
 pub mod ast;
 
-#[cfg(feature = "fmt")]
-pub mod fmt;
+#[cfg(all(feature = "fmt", feature = "cli"))]
+pub(crate) mod fmt;
 
 cfg_emit! {
     pub use ::codespan_reporting::term::termcolor;

crates/rune/src/modules/collections.rs

@@ -1,12 +1,16 @@
 //! `std::collections` module.
 
+#[cfg(feature = "std")]
 mod hash_map;
+#[cfg(feature = "std")]
 mod hash_set;
 mod vec_deque;
 
 use crate::{ContextError, Module};
 
+#[cfg(feature = "std")]
 pub(crate) use self::hash_map::HashMap;
+#[cfg(feature = "std")]
 pub(crate) use self::hash_set::HashSet;
 pub(crate) use self::vec_deque::VecDeque;
 use crate as rune;

crates/rune/src/modules/iter.rs

@@ -3,10 +3,13 @@
 use crate::no_std::prelude::*;
 
 use crate as rune;
-use crate::modules::collections::{HashMap, HashSet, VecDeque};
+use crate::modules::collections::VecDeque;
+#[cfg(feature = "std")]
+use crate::modules::collections::{HashMap, HashSet};
+#[cfg(feature = "std")]
+use crate::runtime::EnvProtocolCaller;
 use crate::runtime::{
-    EnvProtocolCaller, FromValue, Function, Iterator, Object, OwnedTuple, Protocol, Value, Vec,
-    VmResult,
+    FromValue, Function, Iterator, Object, OwnedTuple, Protocol, Value, Vec, VmResult,
 };
 use crate::{ContextError, Module};
 
@@ -49,7 +52,9 @@ pub fn module() -> Result<Module, ContextError> {
 
     module.function_meta(collect_vec)?;
     module.function_meta(collect_vec_deque)?;
+    #[cfg(feature = "std")]
     module.function_meta(collect_hash_set)?;
+    #[cfg(feature = "std")]
     module.function_meta(collect_hash_map)?;
     module.function_meta(collect_tuple)?;
     module.function_meta(collect_object)?;
@@ -1070,6 +1075,7 @@ fn collect_vec_deque(it: Iterator) -> VmResult<VecDeque> {
 /// assert_eq!((0..3).iter().collect::<HashSet>(), HashSet::from([0, 1, 2]));
 /// ```
 #[rune::function(instance, path = collect::<HashSet>)]
+#[cfg(feature = "std")]
 fn collect_hash_set(it: Iterator) -> VmResult<HashSet> {
     let mut caller = EnvProtocolCaller;
     HashSet::from_iter(it, &mut caller)
@@ -1087,6 +1093,7 @@ fn collect_hash_set(it: Iterator) -> VmResult<HashSet> {
 /// assert_eq!(actual, expected);
 /// ```
 #[rune::function(instance, path = collect::<HashMap>)]
+#[cfg(feature = "std")]
 fn collect_hash_map(it: Iterator) -> VmResult<HashMap> {
     let mut caller = EnvProtocolCaller;
     HashMap::from_iter(it, &mut caller)