replace Construct with Commit in CompiledProgram

This commit represents an important change: in the user-facing types we
are no longer holding ConstructNode objects, which mean that we are not
handing the user incomplete types which are tied to a specific inference
context.

This means that within our code, whenever we need to manipulate types, we
need to create a new local type inference context which is then dropped
at the end of the function. We'll need this when we update rust-simplicity
to a version that has only locally-scoped context objects.

The bulk of the diff is in src/named.rs, changing the populate_witness
method to convert a CommitNode to a RedeemNode, which is mostly just fixing
type signatures by chasing compiler errors. Sorry for the noise. I also
add a new stringly-typed error, which I'm not thrilled with, but this
crate is already full of them.

Author: apoelstra

src/lib.rs

@@ -80,12 +80,16 @@ impl TemplateProgram {
         arguments
             .is_consistent(self.simfony.parameters())
             .map_err(|error| error.to_string())?;
+
+        let construct = self
+            .simfony
+            .compile(arguments, include_debug_symbols)
+            .with_file(Arc::clone(&self.file))?;
+        let commit = named::finalize_types(&construct).map_err(|e| e.to_string())?;
+
         Ok(CompiledProgram {
             debug_symbols: self.simfony.debug_symbols(self.file.as_ref()),
-            simplicity: self
-                .simfony
-                .compile(arguments, include_debug_symbols)
-                .with_file(Arc::clone(&self.file))?,
+            simplicity: commit,
             witness_types: self.simfony.witness_types().shallow_clone(),
         })
     }
@@ -94,7 +98,7 @@ impl TemplateProgram {
 /// A SimplicityHL program, compiled to Simplicity.
 #[derive(Clone, Debug)]
 pub struct CompiledProgram {
-    simplicity: ProgNode,
+    simplicity: Arc<named::CommitNode>,
     witness_types: WitnessTypes,
     debug_symbols: DebugSymbols,
 }
@@ -123,8 +127,6 @@ impl CompiledProgram {
     /// Access the Simplicity target code, without witness data.
     pub fn commit(&self) -> Arc<CommitNode<Elements>> {
         named::forget_names(&self.simplicity)
-            .finalize_types()
-            .expect("Compiled SimplicityHL program has type 1 -> 1")
     }
 
     /// Satisfy the SimplicityHL program with the given `witness_values`.
@@ -152,13 +154,13 @@ impl CompiledProgram {
         witness_values
             .is_consistent(&self.witness_types)
             .map_err(|e| e.to_string())?;
-        let simplicity_witness = named::populate_witnesses(&self.simplicity, witness_values);
-        let simplicity_redeem = match env {
-            Some(env) => simplicity_witness.finalize_pruned(env),
-            None => simplicity_witness.finalize_unpruned(),
-        };
+
+        let mut simplicity_redeem = named::populate_witnesses(&self.simplicity, witness_values)?;
+        if let Some(env) = env {
+            simplicity_redeem = simplicity_redeem.prune(env).map_err(|e| e.to_string())?;
+        }
         Ok(SatisfiedProgram {
-            simplicity: simplicity_redeem.map_err(|e| e.to_string())?,
+            simplicity: simplicity_redeem,
             debug_symbols: self.debug_symbols.clone(),
         })
     }

src/named.rs

@@ -197,57 +197,59 @@ where
 /// types in the construct `node`. This can be done by calling [`WitnessValues::is_consistent`]
 /// on the original SimplicityHL program before it is compiled to Simplicity.
 pub fn populate_witnesses<J: Jet>(
-    node: &Node<WithNames<node::Construct<J>>>,
+    node: &Node<WithNames<node::Commit<J>>>,
     values: WitnessValues,
-) -> Arc<node::ConstructNode<J>> {
+) -> Result<Arc<node::RedeemNode<J>>, String> {
     struct Populator {
         values: WitnessValues,
     }
 
-    impl<J: Jet> Converter<WithNames<node::Construct<J>>, node::Construct<J>> for Populator {
-        type Error = core::convert::Infallible;
+    impl<J: Jet> Converter<WithNames<node::Commit<J>>, node::Redeem<J>> for Populator {
+        type Error = String;
 
         fn convert_witness(
             &mut self,
-            _: &PostOrderIterItem<&Node<WithNames<node::Construct<J>>>>,
+            _: &PostOrderIterItem<&Node<WithNames<node::Commit<J>>>>,
             witness: &WitnessName,
-        ) -> Result<Option<simplicity::Value>, Self::Error> {
-            let maybe_value = self
-                .values
-                .get(witness)
-                .map(StructuralValue::from)
-                .map(simplicity::Value::from);
-            Ok(maybe_value)
+        ) -> Result<simplicity::Value, Self::Error> {
+            match self.values.get(witness) {
+                Some(val) => Ok(simplicity::Value::from(StructuralValue::from(val))),
+                None => Err(format!("missing witness for {witness}")),
+            }
         }
 
         fn convert_disconnect(
             &mut self,
-            _: &PostOrderIterItem<&Node<WithNames<node::Construct<J>>>>,
-            _: Option<&Arc<node::ConstructNode<J>>>,
+            _: &PostOrderIterItem<&Node<WithNames<node::Commit<J>>>>,
+            _: Option<&Arc<node::RedeemNode<J>>>,
             _: &NoDisconnect,
-        ) -> Result<Option<Arc<node::ConstructNode<J>>>, Self::Error> {
-            Ok(None)
+        ) -> Result<Arc<node::RedeemNode<J>>, Self::Error> {
+            unreachable!("SimplicityHL does not use disconnect right now")
         }
 
         fn convert_data(
             &mut self,
-            data: &PostOrderIterItem<&Node<WithNames<node::Construct<J>>>>,
-            _: Inner<
-                &Arc<node::ConstructNode<J>>,
+            data: &PostOrderIterItem<&Node<WithNames<node::Commit<J>>>>,
+            inner: Inner<
+                &Arc<node::RedeemNode<J>>,
                 J,
-                &Option<Arc<node::ConstructNode<J>>>,
-                &Option<simplicity::Value>,
+                &Arc<node::RedeemNode<J>>,
+                &simplicity::Value,
             >,
-        ) -> Result<node::ConstructData<J>, Self::Error> {
-            Ok(data.node.cached_data().clone())
+        ) -> Result<Arc<node::RedeemData<J>>, Self::Error> {
+            let inner = inner
+                .map(|node| node.cached_data())
+                .map_disconnect(|node| node.cached_data())
+                .map_witness(simplicity::Value::shallow_clone);
+            Ok(Arc::new(node::RedeemData::new(
+                data.node.cached_data().arrow().shallow_clone(),
+                inner,
+            )))
         }
     }
 
     let mut populator = Populator { values };
-    match node.convert::<InternalSharing, _, _>(&mut populator) {
-        Ok(ret) => ret,
-        Err(inf) => match inf {},
-    }
+    node.convert::<InternalSharing, _, _>(&mut populator)
 }
 
 // This awkward construction is required by rust-simplicity to implement WitnessConstructible