runtime/stdlib: Support fallible field accessors

The Array field accessor now raises an error if it contains multiple
values for the given field.

Author: shesek

src/error.rs

@@ -122,6 +122,9 @@ pub enum RuntimeError {
     #[error("Field does not exists: {}", ValErrFmt(.0))]
     FieldNotFound(Box<Value>),
 
+    #[error("Attempted to access an array field with multiple values: {} (can use `t::multi($arr, $field)` to get them as an array)", ValErrFmt(.0))]
+    FieldArrayTagDuplicated(Box<Value>),
+
     #[error("Required value missing")]
     MissingValue,
 

src/runtime/array.rs

@@ -107,17 +107,20 @@ impl Array {
 
 // Tagged array field access
 impl FieldAccess for Array {
-    fn get_field(self, field: &Value) -> Option<Value> {
-        // Returns the first element tagged with `field`. There may be more.
-        // Getting multiple values is possible through `t::multi($array, $field)`
+    fn get_field_fallible(self, field: &Value) -> Result<Option<Value>> {
+        let mut field_value = None;
         for el in self.into_inner() {
             if let Value::Array(mut el_arr) = el {
                 if el_arr.len() == 2 && el_arr[0] == *field {
-                    return Some(el_arr.remove(1));
+                    ensure!(
+                        field_value.is_none(),
+                        Error::FieldArrayTagDuplicated(field.clone().into())
+                    );
+                    field_value = Some(el_arr.remove(1));
                 }
             }
         }
-        None
+        Ok(field_value)
     }
 }
 

src/runtime/mod.rs

@@ -235,16 +235,21 @@ impl Evaluate for ast::FieldAccess {
     fn eval(&self, scope: &ScopeRef) -> Result<Value> {
         let target = self.target.eval(scope)?;
         let field = self.field.eval(scope)?;
-        let result = target.get_field(&field);
+        let result = target.get_field_fallible(&field)?;
         if self.check_exists {
             Ok(result.is_some().into())
         } else {
             result.ok_or_else(|| Error::FieldNotFound(field.into()))
         }
     }
 }
-pub trait FieldAccess {
-    fn get_field(self, field: &Value) -> Option<Value>;
+pub trait FieldAccess: Sized {
+    fn get_field_fallible(self, field: &Value) -> Result<Option<Value>> {
+        Ok(self.get_field(field))
+    }
+    fn get_field(self, _field: &Value) -> Option<Value> {
+        unimplemented!("Must implement either get_field_fallible() or get_field()")
+    }
 }
 
 impl Evaluate for ast::FnExpr {

src/runtime/value.rs

@@ -513,17 +513,17 @@ impl ExprRepr for Value {
 }
 
 impl FieldAccess for Value {
-    fn get_field(self, field: &Value) -> Option<Value> {
+    fn get_field_fallible(self, field: &Value) -> Result<Option<Value>> {
         match self {
-            Value::Array(x) => x.get_field(field),
-            Value::Psbt(x) => x.get_field(field),
-            Value::Transaction(x) => x.get_field(field),
-            Value::Policy(x) => x.get_field(field),
-            Value::Descriptor(x) => x.get_field(field),
-            Value::TapInfo(x) => x.get_field(field),
-            Value::Address(x) => x.get_field(field),
-            Value::WshScript(x) => x.get_field(field),
-            _ => None,
+            Value::Array(x) => x.get_field_fallible(field),
+            Value::Psbt(x) => x.get_field_fallible(field),
+            Value::Transaction(x) => x.get_field_fallible(field),
+            Value::Policy(x) => x.get_field_fallible(field),
+            Value::Descriptor(x) => x.get_field_fallible(field),
+            Value::TapInfo(x) => x.get_field_fallible(field),
+            Value::Address(x) => x.get_field_fallible(field),
+            Value::WshScript(x) => x.get_field_fallible(field),
+            _ => Ok(None),
         }
     }
 }

src/stdlib/miniscript.rs

@@ -273,8 +273,7 @@ impl FieldAccess for Descriptor {
             "scripts" => tap_scripts_to_val(&*self.tap_info().ok()??),
             _ => {
                 return None;
-            }
-            // TODO address_type
+            } // TODO address_type
         })
     }
 }