[RFC007] Migrate to the new compact value representation

Cargo.toml

@@ -19,7 +19,7 @@ resolver = "2"
 version = "1.14.0"
 authors = ["The Nickel Team <[email protected]>"]
 license = "MIT"
-edition = "2021"
+edition = "2024"
 rust-version = "1.85"
 keywords = ["configuration", "language", "nix", "nickel"]
 repository = "https://github.com/tweag/nickel"
@@ -136,6 +136,8 @@ arbtest = "0.3"
 rpds = "1.1.0"
 imbl-sized-chunks = "0.1"
 
+paste = "1.0"
+
 [profile.dev.package.lalrpop]
 opt-level = 3
 

cli/src/customize/interface.rs

@@ -2,27 +2,29 @@
 //! customize mode of the command-line.
 use super::*;
 
+use nickel_lang_core::eval::value::{Container, NickelValue};
+
 /// The interface of a configuration (a Nickel program) which represents all nested field paths
 /// that are accessible from the root term together with their associated metadata.
 ///
 /// Interface is used to derive a command-line interface from a configuration when using the
 /// `customize_mode` option.
 #[derive(Debug, Clone, Default)]
-pub(super) struct TermInterface {
+pub(super) struct ValueInterface {
     pub(super) fields: HashMap<LocIdent, FieldInterface>,
 }
 
 /// The interface of a specific field. This field can be itself a record and contain subfields.
 #[derive(Debug, Clone, Default)]
 pub(super) struct FieldInterface {
     /// The interface of the subfields of this field, if it's a record itself.
-    pub(super) subfields: Option<TermInterface>,
+    pub(super) subfields: Option<ValueInterface>,
     pub(super) field: Field,
 }
 
-impl Combine for TermInterface {
+impl Combine for ValueInterface {
     fn combine(first: Self, second: Self) -> Self {
-        let TermInterface { mut fields } = first;
+        let ValueInterface { mut fields } = first;
 
         for (id, field) in second.fields.into_iter() {
             if let Some(prev) = fields.remove(&id) {
@@ -32,7 +34,7 @@ impl Combine for TermInterface {
             }
         }
 
-        TermInterface { fields }
+        ValueInterface { fields }
     }
 }
 
@@ -52,9 +54,9 @@ impl Combine for FieldInterface {
     }
 }
 
-impl From<&RecordData> for TermInterface {
+impl From<&RecordData> for ValueInterface {
     fn from(value: &RecordData) -> Self {
-        TermInterface {
+        ValueInterface {
             fields: value
                 .fields
                 .iter()
@@ -64,36 +66,37 @@ impl From<&RecordData> for TermInterface {
     }
 }
 
-impl From<&Term> for TermInterface {
-    fn from(term: &Term) -> Self {
-        term.extract_interface().unwrap_or_default()
+impl From<&NickelValue> for ValueInterface {
+    fn from(value: &NickelValue) -> Self {
+        value.extract_interface().unwrap_or_default()
     }
 }
 
 trait ExtractInterface {
-    fn extract_interface(&self) -> Option<TermInterface>;
+    fn extract_interface(&self) -> Option<ValueInterface>;
 }
 
-impl ExtractInterface for &Term {
-    fn extract_interface(&self) -> Option<TermInterface> {
-        if let Term::Record(rd) = self {
-            Some(TermInterface::from(rd))
-        } else {
-            None
-        }
+impl ExtractInterface for NickelValue {
+    fn extract_interface(&self) -> Option<ValueInterface> {
+        self.as_record().map(|container| match container {
+            Container::Empty => ValueInterface {
+                fields: HashMap::new(),
+            },
+            Container::Alloc(record) => record.into(),
+        })
     }
 }
 
 impl ExtractInterface for Field {
-    fn extract_interface(&self) -> Option<TermInterface> {
-        self.value.as_ref().map(|t| TermInterface::from(t.as_ref()))
+    fn extract_interface(&self) -> Option<ValueInterface> {
+        self.value.as_ref().map(ValueInterface::from)
     }
 }
 
 impl ExtractInterface for Type {
-    fn extract_interface(&self) -> Option<TermInterface> {
+    fn extract_interface(&self) -> Option<ValueInterface> {
         match &self.typ {
-            TypeF::Record(rrows) => Some(TermInterface {
+            TypeF::Record(rrows) => Some(ValueInterface {
                 fields: rrows
                     .iter()
                     .filter_map(|item| {
@@ -114,13 +117,13 @@ impl ExtractInterface for Type {
 }
 
 impl ExtractInterface for RuntimeContract {
-    fn extract_interface(&self) -> Option<TermInterface> {
-        self.contract.as_ref().extract_interface()
+    fn extract_interface(&self) -> Option<ValueInterface> {
+        self.contract.extract_interface()
     }
 }
 
 impl ExtractInterface for LabeledType {
-    fn extract_interface(&self) -> Option<TermInterface> {
+    fn extract_interface(&self) -> Option<ValueInterface> {
         self.typ.extract_interface()
     }
 }
@@ -198,7 +201,7 @@ impl FieldInterface {
     }
 
     pub(super) fn has_subfields(&self) -> bool {
-        matches!(&self.subfields, Some(ref intf) if !intf.fields.is_empty())
+        matches!(&self.subfields, Some(intf) if !intf.fields.is_empty())
     }
 
     /// Return the list of the type and contract annotations joined as a comma-separated string, if

cli/src/customize/mod.rs

@@ -12,8 +12,8 @@ use nickel_lang_core::{
     identifier::LocIdent,
     program::{FieldPath, Program},
     term::{
+        LabeledType, MergePriority, RuntimeContract,
         record::{Field, RecordData},
-        LabeledType, MergePriority, RuntimeContract, Term,
     },
     typ::{RecordRowF, RecordRowsIteratorItem, Type, TypeF},
 };
@@ -25,7 +25,7 @@ use crate::{
 
 pub mod interface;
 
-use interface::{FieldInterface, TermInterface};
+use interface::{FieldInterface, ValueInterface};
 
 /// The value name used through the CLI to indicate that an option accepts any Nickel expression as
 /// a value.
@@ -178,7 +178,7 @@ struct CustomizableFields {
 
 impl CustomizableFields {
     /// Create data from a term interface.
-    fn new(term_iface: TermInterface) -> Self {
+    fn new(term_iface: ValueInterface) -> Self {
         let mut this = Self::default();
 
         for (id, field_iface) in term_iface.fields {
@@ -287,7 +287,7 @@ impl CustomizeOptions {
                 return CliResult::Err(Error::CliUsage {
                     error,
                     files: program.files(),
-                })
+                });
             }
         };
 
@@ -318,7 +318,7 @@ impl CustomizeOptions {
                 return CliResult::Err(Error::CliUsage {
                     error,
                     files: program.files(),
-                })
+                });
             }
         };
 
@@ -342,7 +342,7 @@ impl CustomizeMode {
                 files: program.files(),
             })?;
 
-        let customizable_fields = CustomizableFields::new(TermInterface::from(evaled.as_ref()));
+        let customizable_fields = CustomizableFields::new(ValueInterface::from(&evaled));
         let opts = CustomizeOptions::parse_from(self.customize_mode.iter());
 
         match opts.command {