stick invariant <'brand> tag onto Scope and CoreExt

When we update to rust-simplicity 0.6, we will need to stick an invariant
lifetime (conventionally called 'brand) onto a bunch of types to ensure
that constructed nodes from different type inference contexts are not
mixed.

For the types we own, do this ahead of the actual update, to separate out
the noise from the "real" changes.

Author: apoelstra

src/compile/mod.rs

@@ -39,7 +39,7 @@ type ProgNode = Arc<named::ConstructNode<Elements>>;
 /// Bindings from inner scopes overwrite bindings from outer scopes.
 /// Bindings live as long as their scope.
 #[derive(Debug, Clone)]
-struct Scope {
+struct Scope<'brand> {
     /// For each scope, the set of assigned variables.
     ///
     /// A stack of scopes. Each scope is a stack of patterns.
@@ -72,9 +72,12 @@ struct Scope {
     /// Values for parameters inside the SimplicityHL program.
     arguments: Arguments,
     include_debug_symbols: bool,
+    // In the next commits, this will be dropped since the 'brand
+    // tag will be moved into 'ctx'.
+    phantom: std::marker::PhantomData<fn(&'brand ()) -> &'brand ()>,
 }
 
-impl Scope {
+impl<'brand> Scope<'brand> {
     /// Create the main scope.
     ///
     /// _This function should be called at the start of the compilation and then never again._
@@ -94,6 +97,7 @@ impl Scope {
             call_tracker,
             arguments,
             include_debug_symbols,
+            phantom: core::marker::PhantomData,
         }
     }
 
@@ -105,6 +109,7 @@ impl Scope {
             call_tracker: Arc::clone(&self.call_tracker),
             arguments: self.arguments.clone(),
             include_debug_symbols: self.include_debug_symbols,
+            phantom: core::marker::PhantomData,
         }
     }
 
@@ -221,9 +226,9 @@ impl Scope {
     }
 }
 
-fn compile_blk(
+fn compile_blk<'brand>(
     stmts: &[Statement],
-    scope: &mut Scope,
+    scope: &mut Scope<'brand>,
     index: usize,
     last_expr: Option<&Expression>,
 ) -> Result<PairBuilder<ProgNode>, RichError> {
@@ -278,7 +283,10 @@ impl Program {
 }
 
 impl Expression {
-    fn compile(&self, scope: &mut Scope) -> Result<PairBuilder<ProgNode>, RichError> {
+    fn compile<'brand>(
+        &self,
+        scope: &mut Scope<'brand>,
+    ) -> Result<PairBuilder<ProgNode>, RichError> {
         match self.inner() {
             ExpressionInner::Block(stmts, expr) => {
                 scope.push_scope();
@@ -292,7 +300,10 @@ impl Expression {
 }
 
 impl SingleExpression {
-    fn compile(&self, scope: &mut Scope) -> Result<PairBuilder<ProgNode>, RichError> {
+    fn compile<'brand>(
+        &self,
+        scope: &mut Scope<'brand>,
+    ) -> Result<PairBuilder<ProgNode>, RichError> {
         let expr = match self.inner() {
             SingleExpressionInner::Constant(value) => {
                 let value = StructuralValue::from(value);
@@ -360,7 +371,10 @@ impl SingleExpression {
 }
 
 impl Call {
-    fn compile(&self, scope: &mut Scope) -> Result<PairBuilder<ProgNode>, RichError> {
+    fn compile<'brand>(
+        &self,
+        scope: &mut Scope<'brand>,
+    ) -> Result<PairBuilder<ProgNode>, RichError> {
         let args_ast = SingleExpression::tuple(self.args().clone(), *self.as_ref());
         let args = args_ast.compile(scope)?;
 
@@ -626,7 +640,10 @@ fn for_while(
 }
 
 impl Match {
-    fn compile(&self, scope: &mut Scope) -> Result<PairBuilder<ProgNode>, RichError> {
+    fn compile<'brand>(
+        &self,
+        scope: &mut Scope<'brand>,
+    ) -> Result<PairBuilder<ProgNode>, RichError> {
         scope.push_scope();
         scope.insert(
             self.left()

src/named.rs

@@ -260,7 +260,7 @@ impl<J: Jet> WitnessConstructible<WitnessName> for node::ConstructData<J> {
 }
 
 /// More constructors for types that implement [`CoreConstructible`].
-pub trait CoreExt: CoreConstructible + Sized {
+pub trait CoreExt<'brand>: CoreConstructible + Sized {
     fn h(inference_context: &types::Context) -> PairBuilder<Self> {
         PairBuilder::iden(inference_context)
     }
@@ -339,7 +339,7 @@ pub trait CoreExt: CoreConstructible + Sized {
     }
 }
 
-impl<N: CoreConstructible> CoreExt for N {}
+impl<'brand, N: CoreConstructible> CoreExt<'brand> for N {}
 
 /// Builder of expressions that contain
 /// `take`, `drop` and `iden` only.
@@ -360,7 +360,7 @@ impl<P> Default for SelectorBuilder<P> {
     }
 }
 
-impl<P: CoreExt> SelectorBuilder<P> {
+impl<'brand, P: CoreExt<'brand>> SelectorBuilder<P> {
     /// Select the first component '0' of the input pair.
     pub fn o(mut self) -> Self {
         self.selection.push(false);
@@ -406,7 +406,7 @@ impl<P: CoreExt> SelectorBuilder<P> {
 #[derive(Debug, Clone, Hash)]
 pub struct PairBuilder<P>(P);
 
-impl<P: CoreExt> PairBuilder<P> {
+impl<'brand, P: CoreExt<'brand>> PairBuilder<P> {
     /// Create the unit expression.
     ///
     /// ## Invariant

src/pattern.rs

@@ -202,7 +202,10 @@ impl BasePattern {
     /// The expression takes as input a value that matches the `self` pattern.
     ///
     /// The expression is a sequence of `take` and `drop` followed by `iden`.
-    fn get<P: CoreExt>(&self, identifier: &Identifier) -> Option<SelectorBuilder<P>> {
+    fn get<'brand, P: CoreExt<'brand>>(
+        &self,
+        identifier: &Identifier,
+    ) -> Option<SelectorBuilder<P>> {
         let mut selector = SelectorBuilder::default();
 
         for data in self.verbose_pre_order_iter() {
@@ -302,7 +305,7 @@ impl BasePattern {
     /// This means there are infinitely many translating expressions from `self` to `to`.
     /// For instance, `iden`, `iden & iden`, `(iden & iden) & iden`, and so on.
     /// We enforce a unique translation by banning ignore from the `to` pattern.
-    pub fn translate<P: CoreExt>(
+    pub fn translate<'brand, P: CoreExt<'brand>>(
         &self,
         ctx: &simplicity::types::Context,
         to: &Self,