Merge BlockstreamResearch#65: Add type casts

a3bb49d test: Use casts in example programs (Christian Lewe)
e2f1920 feat: Cast values of structurally equivalent types (Christian Lewe)

Pull request description:

  Depends on BlockstreamResearch#64

  Add type casts based on structural type equality.

ACKs for top commit:
  apoelstra:
    ACK a3bb49d short and sweet

Tree-SHA512: f1381e6faa941b682e03ff05ed826b6768f119b02851276952772b11901824f763160f7b8b8b14d108e4221a5556a943def55b067cdce84d86246569941898a5

Author: uncomputable

example_progs/cat.simf

@@ -1,12 +1,8 @@
 fn main() {
-    let a: u8 = 0x10;
-    let b: u8 = 0x01;
-    let ab: u16 = (a, b);
+    let ab: u16 = <(u8, u8)>::into((0x10, 0x01));
     let c: u16 = 0x1001;
     jet_verify(jet_eq_16(ab, c));
-    let a: u4 = 0b1011;
-    let b: u4 = 0b1101;
-    let ab: u8 = (a, b);
+    let ab: u8 = <(u4, u4)>::into((0b1011, 0b1101));
     let c: u8 = 0b10111101;
     jet_verify(jet_eq_8(ab, c));
 }

example_progs/function.simf

@@ -1,7 +1,6 @@
 fn checked_add_32(a: u32, b: u32) -> u32 {
     let (carry, sum): (bool, u32) = jet_add_32(a, b);
-    // FIXME: Need to cast `bool` to `u1`
-    // jet_verify(jet_complement_1(carry));
+    jet_verify(<u1>::into(jet_complement_1(<bool>::into(carry))));
     sum
 }
 

src/ast.rs

@@ -10,7 +10,9 @@ use crate::error::{Error, RichError, WithSpan};
 use crate::parse;
 use crate::parse::{FunctionName, Identifier, MatchPattern, Span, WitnessName};
 use crate::pattern::Pattern;
-use crate::types::{AliasedType, ResolvedType, TypeConstructible, TypeDeconstructible};
+use crate::types::{
+    AliasedType, ResolvedType, StructuralType, TypeConstructible, TypeDeconstructible,
+};
 use crate::value::{UIntValue, Value};
 
 /// Map of witness names to their expected type, as declared in the program.
@@ -233,6 +235,8 @@ pub enum CallName {
     UnwrapRight(ResolvedType),
     /// [`Option::unwrap`].
     Unwrap,
+    /// Cast from the given source type.
+    TypeCast(ResolvedType),
     /// A custom function that was defined previously.
     ///
     /// We effectively copy the function body into every call of the function.
@@ -899,6 +903,20 @@ impl AbstractSyntaxTree for Call {
                     scope,
                 )?])
             }
+            CallName::TypeCast(source) => {
+                if from.args.len() != 1 {
+                    return Err(Error::InvalidNumberOfArguments(1, from.args.len()))
+                        .with_span(from);
+                }
+                if StructuralType::from(&source) != StructuralType::from(ty) {
+                    return Err(Error::InvalidCast(source, ty.clone())).with_span(from);
+                }
+                Arc::from([Expression::analyze(
+                    from.args.first().unwrap(),
+                    &source,
+                    scope,
+                )?])
+            }
             CallName::Custom(function) => {
                 if from.args.len() != function.params().len() {
                     return Err(Error::InvalidNumberOfArguments(
@@ -951,6 +969,9 @@ impl AbstractSyntaxTree for CallName {
                 .map(Self::UnwrapRight)
                 .with_span(from),
             parse::CallName::Unwrap => Ok(Self::Unwrap),
+            parse::CallName::TypeCast(target) => {
+                scope.resolve(target).map(Self::TypeCast).with_span(from)
+            }
             parse::CallName::Custom(name) => scope
                 .get_function(name)
                 .cloned()

src/compile.rs

@@ -301,6 +301,13 @@ impl Call {
                 let get_inner = ProgNode::assertr_take(fail_cmr, &ProgNode::iden());
                 ProgNode::comp(&right_and_unit, &get_inner).with_span(self)
             }
+            CallName::TypeCast(..) => {
+                // A cast converts between two structurally equal types.
+                // Structural equality of Simfony types A and B means
+                // exact equality of the underlying Simplicity types of A and of B.
+                // Therefore, a Simfony cast is a NOP in Simplicity.
+                Ok(args)
+            }
             CallName::Custom(function) => {
                 let params_pattern = Pattern::tuple(
                     function

src/error.rs

@@ -154,6 +154,7 @@ pub enum Error {
     CannotCompile(String),
     JetDoesNotExist(JetName),
     TypeValueMismatch(ResolvedType),
+    InvalidCast(ResolvedType, ResolvedType),
     MainNoInputs,
     MainNoOutput,
     MainRequired,
@@ -212,6 +213,10 @@ impl fmt::Display for Error {
                 f,
                 "Value does not match the assigned type `{ty}`"
             ),
+            Error::InvalidCast(source, target) => write!(
+                f,
+                "Cannot cast values of type `{source}` as values of type `{target}`"
+            ),
             Error::MainNoInputs => write!(
                 f,
                 "Main function takes no input parameters"

src/lib.rs

@@ -66,7 +66,7 @@ mod tests {
             ("add.simf", "empty.wit"),
             ("add.simf", "empty.wit"),
             ("array.simf", "empty.wit"),
-            // ("cat.simf", "empty.wit"),
+            ("cat.simf", "empty.wit"),
             (
                 "checksigfromstackverify.simf",
                 "checksigfromstackverify.wit",

src/minimal.pest

@@ -55,10 +55,11 @@ none_expr         = @{ "None" }
 some_expr         =  { "Some(" ~ expression ~ ")" }
 false_expr        = @{ "false" }
 true_expr         = @{ "true" }
-unwrap_left       = ${ "unwrap_left::<" ~ ty ~ ">" }
-unwrap_right      = ${ "unwrap_right::<" ~ ty ~ ">" }
+unwrap_left       =  { "unwrap_left::<" ~ ty ~ ">" }
+unwrap_right      =  { "unwrap_right::<" ~ ty ~ ">" }
 unwrap            = @{ "unwrap" }
-call_name         = ${ jet | unwrap_left | unwrap_right | unwrap | function_name }
+type_cast         =  { "<" ~ ty ~ ">::into" }
+call_name         =  { jet | unwrap_left | unwrap_right | unwrap | type_cast | function_name }
 call_args         =  { "(" ~ (expression ~ ("," ~ expression)*)? ~ ")" }
 call_expr         =  { call_name ~ call_args }
 unsigned_decimal  = @{ (ASCII_DIGIT | "_")+ }

src/parse.rs

@@ -278,6 +278,8 @@ pub enum CallName {
     UnwrapRight(AliasedType),
     /// Some unwrap function.
     Unwrap,
+    /// Cast from the given source type.
+    TypeCast(AliasedType),
     /// Name of a custom function.
     Custom(FunctionName),
 }
@@ -813,6 +815,10 @@ impl PestParse for CallName {
                 AliasedType::parse(inner).map(Self::UnwrapRight)
             }
             Rule::unwrap => Ok(Self::Unwrap),
+            Rule::type_cast => {
+                let inner = pair.into_inner().next().unwrap();
+                AliasedType::parse(inner).map(Self::TypeCast)
+            }
             Rule::function_name => FunctionName::parse(pair).map(Self::Custom),
             _ => panic!("Corrupt grammar"),
         }