style: clippy clean when not all features are enabled

Author: talagrand

src/ast.rs

@@ -19,11 +19,13 @@ pub(crate) type NumberType = i64;
 
 /// Allowed non-alphanumeric characters in Scheme symbol names
 /// Most represent mathematical symbols or predicates ("?"), "$" supported for JavaScript identifiers
+#[cfg(any(feature = "scheme", feature = "jsonlogic"))]
 pub(crate) const SYMBOL_SPECIAL_CHARS: &str = "+-*/<>=!?_$";
 
 /// Check if a string is a valid symbol name
 /// Valid: non-empty, no leading digit, no "-digit" prefix, alphanumeric + SYMBOL_SPECIAL_CHARS
 /// Note: This function is tested as part of the parser tests in parser.rs
+#[cfg(any(feature = "scheme", feature = "jsonlogic"))]
 pub(crate) fn is_valid_symbol(name: &str) -> bool {
     let mut chars = name.chars();
 

src/builtinops.rs

@@ -56,6 +56,7 @@ use crate::evaluator::{
     Arity, Environment, NumIter, StringIter, ValueIter, eval_and, eval_define, eval_if,
     eval_lambda, eval_or, eval_quote,
 };
+#[cfg(any(feature = "scheme", feature = "jsonlogic", test))]
 use std::collections::HashMap;
 use std::sync::{Arc, LazyLock};
 
@@ -112,12 +113,13 @@ impl PartialEq for BuiltinOp {
 
 impl BuiltinOp {
     /// Check if this operation is a special form
-    #[cfg_attr(not(test), expect(dead_code))]
+    #[cfg(test)]
     pub(crate) fn is_special_form(&self) -> bool {
         matches!(self.op_kind, OpKind::SpecialForm(_))
     }
 
     /// Check if the given number of arguments is valid for this operation
+    #[cfg(any(feature = "scheme", feature = "jsonlogic"))]
     pub(crate) fn validate_arity(&self, arg_count: usize) -> Result<(), Error> {
         self.arity.validate(arg_count)
     }
@@ -518,12 +520,14 @@ static BUILTIN_OPS: LazyLock<Vec<BuiltinOp>> = LazyLock::new(|| {
 });
 
 /// Lazy static map from scheme_id to BuiltinOp (private - use find_builtin_op_by_scheme_id)
+#[cfg(any(feature = "scheme", feature = "jsonlogic", test))]
 static BUILTIN_SCHEME: LazyLock<HashMap<&'static str, &'static BuiltinOp>> = LazyLock::new(|| {
     let ops: &'static [BuiltinOp] = BUILTIN_OPS.as_slice();
     ops.iter().map(|op| (op.scheme_id, op)).collect()
 });
 
 /// Lazy static map from jsonlogic_id to BuiltinOp (private - use find_builtin_op_by_jsonlogic_id)
+#[cfg(any(feature = "jsonlogic", test))]
 static BUILTIN_JSONLOGIC: LazyLock<HashMap<&'static str, &'static BuiltinOp>> =
     LazyLock::new(|| {
         let ops: &'static [BuiltinOp] = BUILTIN_OPS.as_slice();
@@ -536,21 +540,25 @@ pub(crate) fn get_builtin_ops() -> &'static [BuiltinOp] {
 }
 
 /// Find a builtin operation by its Scheme identifier
+#[cfg(any(feature = "scheme", feature = "jsonlogic", test))]
 pub(crate) fn find_scheme_op(id: &str) -> Option<&'static BuiltinOp> {
     BUILTIN_SCHEME.get(id).copied()
 }
 
 /// Find a builtin operation by its JSONLogic identifier
+#[cfg(any(feature = "jsonlogic", test))]
 pub(crate) fn find_jsonlogic_op(id: &str) -> Option<&'static BuiltinOp> {
     BUILTIN_JSONLOGIC.get(id).copied()
 }
 
 /// Get the quote builtin operation - guaranteed to exist
+#[cfg(any(feature = "scheme", feature = "jsonlogic"))]
 pub(crate) fn get_quote_op() -> &'static BuiltinOp {
     find_scheme_op("quote").expect("quote builtin operation must be available")
 }
 
 /// Get the list builtin operation - guaranteed to exist
+#[cfg(feature = "jsonlogic")]
 pub(crate) fn get_list_op() -> &'static BuiltinOp {
     find_scheme_op("list").expect("list builtin operation must be available")
 }