Remove PolicyArc

The `concrete::PolicyArc` type is identical to `Policy` except that it
uses `Arc` to wrap the nested `Policy` structs.

In preparation for implementing `TreeLike` and removing recursive
functions that process the `Policy` type remove the `PolicyArc` and add
`Arc` wrappers around the nested `Policy` fields.

Note, this patch does a bunch on cloning in the recursive functions.
This will dissapear when they are re-written to use tree iteration.

There are more optimizaitons available by taking `Arc<Policy<Pk>>` as a
parameter to functions in the `compiler` module, left for later.

The unit tests are bit klunky, much mapping of iterators to add `Arc`, I
think this will come out in the wash as we keep working.

Author: tcharding

src/policy/compiler.rs

@@ -844,10 +844,14 @@ where
         }
         Concrete::And(ref subs) => {
             assert_eq!(subs.len(), 2, "and takes 2 args");
-            let mut left = best_compilations(policy_cache, &subs[0], sat_prob, dissat_prob)?;
-            let mut right = best_compilations(policy_cache, &subs[1], sat_prob, dissat_prob)?;
-            let mut q_zero_right = best_compilations(policy_cache, &subs[1], sat_prob, None)?;
-            let mut q_zero_left = best_compilations(policy_cache, &subs[0], sat_prob, None)?;
+            let mut left =
+                best_compilations(policy_cache, subs[0].as_ref(), sat_prob, dissat_prob)?;
+            let mut right =
+                best_compilations(policy_cache, subs[1].as_ref(), sat_prob, dissat_prob)?;
+            let mut q_zero_right =
+                best_compilations(policy_cache, subs[1].as_ref(), sat_prob, None)?;
+            let mut q_zero_left =
+                best_compilations(policy_cache, subs[0].as_ref(), sat_prob, None)?;
 
             compile_binary!(&mut left, &mut right, [1.0, 1.0], Terminal::AndB);
             compile_binary!(&mut right, &mut left, [1.0, 1.0], Terminal::AndB);
@@ -871,48 +875,56 @@ where
             let rw = subs[1].0 as f64 / total;
 
             //and-or
-            if let (Concrete::And(x), _) = (&subs[0].1, &subs[1].1) {
+            if let (Concrete::And(x), _) = (subs[0].1.as_ref(), subs[1].1.as_ref()) {
                 let mut a1 = best_compilations(
                     policy_cache,
-                    &x[0],
+                    x[0].as_ref(),
                     lw * sat_prob,
                     Some(dissat_prob.unwrap_or(0 as f64) + rw * sat_prob),
                 )?;
-                let mut a2 = best_compilations(policy_cache, &x[0], lw * sat_prob, None)?;
+                let mut a2 = best_compilations(policy_cache, x[0].as_ref(), lw * sat_prob, None)?;
 
                 let mut b1 = best_compilations(
                     policy_cache,
-                    &x[1],
+                    x[1].as_ref(),
                     lw * sat_prob,
                     Some(dissat_prob.unwrap_or(0 as f64) + rw * sat_prob),
                 )?;
-                let mut b2 = best_compilations(policy_cache, &x[1], lw * sat_prob, None)?;
+                let mut b2 = best_compilations(policy_cache, x[1].as_ref(), lw * sat_prob, None)?;
 
-                let mut c =
-                    best_compilations(policy_cache, &subs[1].1, rw * sat_prob, dissat_prob)?;
+                let mut c = best_compilations(
+                    policy_cache,
+                    subs[1].1.as_ref(),
+                    rw * sat_prob,
+                    dissat_prob,
+                )?;
 
                 compile_tern!(&mut a1, &mut b2, &mut c, [lw, rw]);
                 compile_tern!(&mut b1, &mut a2, &mut c, [lw, rw]);
             };
-            if let (_, Concrete::And(x)) = (&subs[0].1, &subs[1].1) {
+            if let (_, Concrete::And(x)) = (&subs[0].1.as_ref(), subs[1].1.as_ref()) {
                 let mut a1 = best_compilations(
                     policy_cache,
-                    &x[0],
+                    x[0].as_ref(),
                     rw * sat_prob,
                     Some(dissat_prob.unwrap_or(0 as f64) + lw * sat_prob),
                 )?;
-                let mut a2 = best_compilations(policy_cache, &x[0], rw * sat_prob, None)?;
+                let mut a2 = best_compilations(policy_cache, x[0].as_ref(), rw * sat_prob, None)?;
 
                 let mut b1 = best_compilations(
                     policy_cache,
-                    &x[1],
+                    x[1].as_ref(),
                     rw * sat_prob,
                     Some(dissat_prob.unwrap_or(0 as f64) + lw * sat_prob),
                 )?;
-                let mut b2 = best_compilations(policy_cache, &x[1], rw * sat_prob, None)?;
+                let mut b2 = best_compilations(policy_cache, x[1].as_ref(), rw * sat_prob, None)?;
 
-                let mut c =
-                    best_compilations(policy_cache, &subs[0].1, lw * sat_prob, dissat_prob)?;
+                let mut c = best_compilations(
+                    policy_cache,
+                    subs[0].1.as_ref(),
+                    lw * sat_prob,
+                    dissat_prob,
+                )?;
 
                 compile_tern!(&mut a1, &mut b2, &mut c, [rw, lw]);
                 compile_tern!(&mut b1, &mut a2, &mut c, [rw, lw]);
@@ -931,12 +943,22 @@ where
             let mut r_comp = vec![];
 
             for dissat_prob in dissat_probs(rw).iter() {
-                let l = best_compilations(policy_cache, &subs[0].1, lw * sat_prob, *dissat_prob)?;
+                let l = best_compilations(
+                    policy_cache,
+                    subs[0].1.as_ref(),
+                    lw * sat_prob,
+                    *dissat_prob,
+                )?;
                 l_comp.push(l);
             }
 
             for dissat_prob in dissat_probs(lw).iter() {
-                let r = best_compilations(policy_cache, &subs[1].1, rw * sat_prob, *dissat_prob)?;
+                let r = best_compilations(
+                    policy_cache,
+                    subs[1].1.as_ref(),
+                    rw * sat_prob,
+                    *dissat_prob,
+                )?;
                 r_comp.push(r);
             }
 
@@ -971,8 +993,8 @@ where
                 let sp = sat_prob * k_over_n;
                 //Expressions must be dissatisfiable
                 let dp = Some(dissat_prob.unwrap_or(0 as f64) + (1.0 - k_over_n) * sat_prob);
-                let be = best(types::Base::B, policy_cache, ast, sp, dp)?;
-                let bw = best(types::Base::W, policy_cache, ast, sp, dp)?;
+                let be = best(types::Base::B, policy_cache, ast.as_ref(), sp, dp)?;
+                let bw = best(types::Base::W, policy_cache, ast.as_ref(), sp, dp)?;
 
                 let diff = be.cost_1d(sp, dp) - bw.cost_1d(sp, dp);
                 best_es.push((be.comp_ext_data, be));
@@ -1005,7 +1027,7 @@ where
             let key_vec: Vec<Pk> = subs
                 .iter()
                 .filter_map(|s| {
-                    if let Concrete::Key(ref pk) = *s {
+                    if let Concrete::Key(ref pk) = s.as_ref() {
                         Some(pk.clone())
                     } else {
                         None
@@ -1025,9 +1047,11 @@ where
                 _ if k == subs.len() => {
                     let mut it = subs.iter();
                     let mut policy = it.next().expect("No sub policy in thresh() ?").clone();
-                    policy = it.fold(policy, |acc, pol| Concrete::And(vec![acc, pol.clone()]));
+                    policy = it.fold(policy, |acc, pol| {
+                        Concrete::And(vec![acc, pol.clone()]).into()
+                    });
 
-                    ret = best_compilations(policy_cache, &policy, sat_prob, dissat_prob)?;
+                    ret = best_compilations(policy_cache, policy.as_ref(), sat_prob, dissat_prob)?;
                 }
                 _ => {}
             }
@@ -1239,8 +1263,11 @@ mod tests {
     fn compile_timelocks() {
         // artificially create a policy that is problematic and try to compile
         let pol: SPolicy = Concrete::And(vec![
-            Concrete::Key("A".to_string()),
-            Concrete::And(vec![Concrete::after(9), Concrete::after(1000_000_000)]),
+            Arc::new(Concrete::Key("A".to_string())),
+            Arc::new(Concrete::And(vec![
+                Arc::new(Concrete::after(9)),
+                Arc::new(Concrete::after(1000_000_000)),
+            ])),
         ]);
         assert!(pol.compile::<Segwitv0>().is_err());
 
@@ -1346,13 +1373,22 @@ mod tests {
 
         // Liquid policy
         let policy: BPolicy = Concrete::Or(vec![
-            (127, Concrete::Threshold(3, key_pol[0..5].to_owned())),
+            (
+                127,
+                Arc::new(Concrete::Threshold(
+                    3,
+                    key_pol[0..5].iter().map(|p| (p.clone()).into()).collect(),
+                )),
+            ),
             (
                 1,
-                Concrete::And(vec![
-                    Concrete::Older(Sequence::from_height(10000)),
-                    Concrete::Threshold(2, key_pol[5..8].to_owned()),
-                ]),
+                Arc::new(Concrete::And(vec![
+                    Arc::new(Concrete::Older(Sequence::from_height(10000))),
+                    Arc::new(Concrete::Threshold(
+                        2,
+                        key_pol[5..8].iter().map(|p| (p.clone()).into()).collect(),
+                    )),
+                ])),
             ),
         ]);
 
@@ -1471,8 +1507,10 @@ mod tests {
         // and to a ms thresh otherwise.
         // k = 1 (or 2) does not compile, see https://github.com/rust-bitcoin/rust-miniscript/issues/114
         for k in &[10, 15, 21] {
-            let pubkeys: Vec<Concrete<bitcoin::PublicKey>> =
-                keys.iter().map(|pubkey| Concrete::Key(*pubkey)).collect();
+            let pubkeys: Vec<Arc<Concrete<bitcoin::PublicKey>>> = keys
+                .iter()
+                .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
+                .collect();
             let big_thresh = Concrete::Threshold(*k, pubkeys);
             let big_thresh_ms: SegwitMiniScript = big_thresh.compile().unwrap();
             if *k == 21 {
@@ -1499,18 +1537,18 @@ mod tests {
         // or(thresh(52, [pubkey; 52]), thresh(52, [pubkey; 52])) results in a 3642-bytes long
         // witness script with only 54 stack elements
         let (keys, _) = pubkeys_and_a_sig(104);
-        let keys_a: Vec<Concrete<bitcoin::PublicKey>> = keys[..keys.len() / 2]
+        let keys_a: Vec<Arc<Concrete<bitcoin::PublicKey>>> = keys[..keys.len() / 2]
             .iter()
-            .map(|pubkey| Concrete::Key(*pubkey))
+            .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
             .collect();
-        let keys_b: Vec<Concrete<bitcoin::PublicKey>> = keys[keys.len() / 2..]
+        let keys_b: Vec<Arc<Concrete<bitcoin::PublicKey>>> = keys[keys.len() / 2..]
             .iter()
-            .map(|pubkey| Concrete::Key(*pubkey))
+            .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
             .collect();
 
         let thresh_res: Result<SegwitMiniScript, _> = Concrete::Or(vec![
-            (1, Concrete::Threshold(keys_a.len(), keys_a)),
-            (1, Concrete::Threshold(keys_b.len(), keys_b)),
+            (1, Arc::new(Concrete::Threshold(keys_a.len(), keys_a))),
+            (1, Arc::new(Concrete::Threshold(keys_b.len(), keys_b))),
         ])
         .compile();
         let script_size = thresh_res.clone().and_then(|m| Ok(m.script_size()));
@@ -1523,8 +1561,10 @@ mod tests {
 
         // Hit the maximum witness stack elements limit
         let (keys, _) = pubkeys_and_a_sig(100);
-        let keys: Vec<Concrete<bitcoin::PublicKey>> =
-            keys.iter().map(|pubkey| Concrete::Key(*pubkey)).collect();
+        let keys: Vec<Arc<Concrete<bitcoin::PublicKey>>> = keys
+            .iter()
+            .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
+            .collect();
         let thresh_res: Result<SegwitMiniScript, _> =
             Concrete::Threshold(keys.len(), keys).compile();
         let n_elements = thresh_res
@@ -1542,8 +1582,10 @@ mod tests {
     fn shared_limits() {
         // Test the maximum number of OPs with a 67-of-68 multisig
         let (keys, _) = pubkeys_and_a_sig(68);
-        let keys: Vec<Concrete<bitcoin::PublicKey>> =
-            keys.iter().map(|pubkey| Concrete::Key(*pubkey)).collect();
+        let keys: Vec<Arc<Concrete<bitcoin::PublicKey>>> = keys
+            .iter()
+            .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
+            .collect();
         let thresh_res: Result<SegwitMiniScript, _> =
             Concrete::Threshold(keys.len() - 1, keys).compile();
         let ops_count = thresh_res.clone().and_then(|m| Ok(m.ext.ops.op_count()));
@@ -1555,8 +1597,10 @@ mod tests {
         );
         // For legacy too..
         let (keys, _) = pubkeys_and_a_sig(68);
-        let keys: Vec<Concrete<bitcoin::PublicKey>> =
-            keys.iter().map(|pubkey| Concrete::Key(*pubkey)).collect();
+        let keys: Vec<Arc<Concrete<bitcoin::PublicKey>>> = keys
+            .iter()
+            .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
+            .collect();
         let thresh_res = Concrete::Threshold(keys.len() - 1, keys).compile::<Legacy>();
         let ops_count = thresh_res.clone().and_then(|m| Ok(m.ext.ops.op_count()));
         assert_eq!(
@@ -1568,8 +1612,9 @@ mod tests {
 
         // Test that we refuse to compile policies with duplicated keys
         let (keys, _) = pubkeys_and_a_sig(1);
-        let key = Concrete::Key(keys[0]);
-        let res = Concrete::Or(vec![(1, key.clone()), (1, key.clone())]).compile::<Segwitv0>();
+        let key = Arc::new(Concrete::Key(keys[0]));
+        let res =
+            Concrete::Or(vec![(1, Arc::clone(&key)), (1, Arc::clone(&key))]).compile::<Segwitv0>();
         assert_eq!(
             res,
             Err(CompilerError::PolicyError(