Merge branch 'develop' into feature/blocks-transactions-accounts

Author: jcnelson

Diff for: circle.yml

@@ -3,7 +3,7 @@ jobs:
   deploy:
     working_directory: /build
     docker:
-      - image: rust:1.39.0-stretch
+      - image: rust:1.39-stretch
     steps:
       - checkout
       - run:
@@ -15,7 +15,7 @@ jobs:
   test_demo:
     working_directory: /test
     docker:
-      - image: rust:1.39.0-stretch
+      - image: rust:1.39-stretch
     steps:
       - checkout
       - run:

Diff for: rust-toolchain

@@ -1 +1 @@
-1.39.0
+stable

Diff for: sample-programs/names.clar

@@ -11,9 +11,9 @@
 (define-public (preorder 
                 (name-hash (buff 20))
                 (name-price uint))
-  (if (is-ok? (contract-call! .tokens token-transfer
+  (if (is-ok (contract-call? .tokens token-transfer
                 burn-address name-price))
-      (begin (map-insert! preorder-map
+      (begin (map-insert preorder-map
                      (tuple (name-hash name-hash))
                      (tuple (paid name-price)
                             (buyer tx-sender)))
@@ -25,26 +25,26 @@
                 (name uint)
                 (salt uint))
   (let ((preorder-entry
-         (expects! ;; name _must_ have been preordered.
-           (map-get preorder-map
+         (unwrap! ;; name _must_ have been preordered.
+           (map-get? preorder-map
              (tuple (name-hash (hash160 (xor name salt)))))
            (err "no preorder found")))
         (name-entry 
-         (map-get name-map (tuple (name name)))))
+         (map-get? name-map (tuple (name name)))))
     (if (and
          ;; name shouldn't *already* exist
-         (is-none? name-entry)
+         (is-none name-entry)
          ;; preorder must have paid enough
          (<= (price-function name) 
              (get paid preorder-entry))
          ;; preorder must have been the current principal
-         (eq? tx-sender
+         (is-eq tx-sender
               (get buyer preorder-entry)))
         (if (and
-              (map-insert! name-map
+              (map-insert name-map
                         (tuple (name name))
                         (tuple (owner recipient-principal)))
-              (map-delete! preorder-map
+              (map-delete preorder-map
                         (tuple (name-hash (hash160 (xor name salt))))))
             (ok u0)
             (err "failed to insert new name entry"))

Diff for: sample-programs/tokens.clar

@@ -1,13 +1,13 @@
 (define-map tokens ((account principal)) ((balance uint)))
 (define-private (get-balance (account principal))
-  (default-to u0 (get balance (map-get tokens (tuple (account account))))))
+  (default-to u0 (get balance (map-get? tokens (tuple (account account))))))
 
 (define-private (token-credit! (account principal) (amount uint))
   (if (<= amount u0)
       (err "must move positive balance")
       (let ((current-amount (get-balance account)))
         (begin
-          (map-set! tokens (tuple (account account))
+          (map-set tokens (tuple (account account))
                       (tuple (balance (+ amount current-amount))))
           (ok amount)))))
 
@@ -16,7 +16,7 @@
     (if (or (> amount balance) (<= amount u0))
         (err "must transfer positive balance and possess funds")
         (begin
-          (map-set! tokens (tuple (account tx-sender))
+          (map-set tokens (tuple (account tx-sender))
                       (tuple (balance (- balance amount))))
           (token-credit! to amount)))))
 

Diff for: src/vm/analysis/definition_sorter/mod.rs

@@ -57,7 +57,7 @@ impl <'a> DefinitionSorter {
         let sorted_indexes = walker.get_sorted_dependencies(&self.graph)?;
 
         if let Some(deps) = walker.get_cycling_dependencies(&self.graph, &sorted_indexes) {
-            let deps_props: Vec<(_)> = deps.iter().map(|i| {
+            let deps_props: Vec<_> = deps.iter().map(|i| {
                 let exp = &contract_analysis.expressions[*i];
                 self.find_expression_definition(&exp).unwrap()
             }).collect();

Diff for: src/vm/analysis/definition_sorter/tests.rs

@@ -26,7 +26,7 @@ fn should_succeed_sorting_contract_case_1() {
             (kv-del key))
         (define-private (kv-del (key int))
             (begin 
-                (map-delete! kv-store ((key key)))
+                (map-delete kv-store ((key key)))
                 key))
         (define-map kv-store ((key int)) ((value int)))
     "#;
@@ -110,7 +110,7 @@ fn should_raise_dependency_cycle_case_get() {
 fn should_not_raise_dependency_cycle_case_fetch_entry() {
     let contract = r#"
         (define-private (foo (x int)) (begin (bar 1) 1))
-        (define-private (bar (x int)) (map-get kv-store ((foo 1)))) 
+        (define-private (bar (x int)) (map-get? kv-store ((foo 1)))) 
         (define-map kv-store ((foo int)) ((bar int)))
     "#;
 
@@ -122,7 +122,7 @@ fn should_not_raise_dependency_cycle_case_fetch_entry() {
 fn should_raise_dependency_cycle_case_fetch_entry() {
     let contract = r#"
         (define-private (foo (x int)) (+ (bar x) x))
-        (define-private (bar (x int)) (map-get kv-store ((foo (foo 1))))) 
+        (define-private (bar (x int)) (map-get? kv-store ((foo (foo 1))))) 
         (define-map kv-store ((foo int)) ((bar int)))
     "#;
 
@@ -134,7 +134,7 @@ fn should_raise_dependency_cycle_case_fetch_entry() {
 fn should_not_raise_dependency_cycle_case_delete_entry() {
     let contract = r#"
         (define-private (foo (x int)) (begin (bar 1) 1))
-        (define-private (bar (x int)) (map-delete! kv-store (tuple (foo 1)))) 
+        (define-private (bar (x int)) (map-delete kv-store (tuple (foo 1)))) 
         (define-map kv-store ((foo int)) ((bar int)))
     "#;
 
@@ -146,7 +146,7 @@ fn should_not_raise_dependency_cycle_case_delete_entry() {
 fn should_raise_dependency_cycle_case_delete_entry() {
     let contract = r#"
         (define-private (foo (x int)) (+ (bar x) x))
-        (define-private (bar (x int)) (map-delete! kv-store (tuple (foo (foo 1))))) 
+        (define-private (bar (x int)) (map-delete kv-store (tuple (foo (foo 1))))) 
         (define-map kv-store ((foo int)) ((bar int)))
     "#;
 
@@ -158,7 +158,7 @@ fn should_raise_dependency_cycle_case_delete_entry() {
 fn should_not_raise_dependency_cycle_case_set_entry() {
     let contract = r#"
         (define-private (foo (x int)) (begin (bar 1) 1))
-        (define-private (bar (x int)) (map-set! kv-store ((foo 1)) ((bar 3)))) 
+        (define-private (bar (x int)) (map-set kv-store ((foo 1)) ((bar 3)))) 
         (define-map kv-store ((foo int)) ((bar int)))
     "#;
 
@@ -170,7 +170,7 @@ fn should_not_raise_dependency_cycle_case_set_entry() {
 fn should_raise_dependency_cycle_case_set_entry() {
     let contract = r#"
         (define-private (foo (x int)) (+ (bar x) x))
-        (define-private (bar (x int)) (map-set! kv-store ((foo 1)) ((bar (foo 1))))) 
+        (define-private (bar (x int)) (map-set kv-store ((foo 1)) ((bar (foo 1))))) 
         (define-map kv-store ((foo int)) ((bar int)))
     "#;
 
@@ -182,7 +182,7 @@ fn should_raise_dependency_cycle_case_set_entry() {
 fn should_not_raise_dependency_cycle_case_insert_entry() {
     let contract = r#"
         (define-private (foo (x int)) (begin (bar 1) 1))
-        (define-private (bar (x int)) (map-insert! kv-store ((foo 1)) ((bar 3)))) 
+        (define-private (bar (x int)) (map-insert kv-store ((foo 1)) ((bar 3)))) 
         (define-map kv-store ((foo int)) ((bar int)))
     "#;
 
@@ -194,7 +194,7 @@ fn should_not_raise_dependency_cycle_case_insert_entry() {
 fn should_raise_dependency_cycle_case_insert_entry() {
     let contract = r#"
         (define-private (foo (x int)) (+ (bar x) x))
-        (define-private (bar (x int)) (map-insert! kv-store ((foo (foo 1))) ((bar 3))))
+        (define-private (bar (x int)) (map-insert kv-store ((foo (foo 1))) ((bar 3))))
         (define-map kv-store ((foo int)) ((bar int)))
     "#;
 
@@ -206,7 +206,7 @@ fn should_raise_dependency_cycle_case_insert_entry() {
 fn should_not_raise_dependency_cycle_case_fetch_contract_entry() {
     let contract = r#"
         (define-private (foo (x int)) (begin (bar 1) 1))
-        (define-private (bar (x int)) (contract-map-get .contract1 kv-store ((foo 1)))) 
+        (define-private (bar (x int)) (contract-map-get? .contract1 kv-store ((foo 1)))) 
     "#;
 
     run_scoped_analysis_helper(contract).unwrap();
@@ -216,7 +216,7 @@ fn should_not_raise_dependency_cycle_case_fetch_contract_entry() {
 fn should_raise_dependency_cycle_case_fetch_contract_entry() {
     let contract = r#"
         (define-private (foo (x int)) (+ (bar x) x))
-        (define-private (bar (x int)) (map-get kv-store ((foo (foo 1))))) 
+        (define-private (bar (x int)) (map-get? kv-store ((foo (foo 1))))) 
     "#;
 
     let err = run_scoped_analysis_helper(contract).unwrap_err();

Diff for: src/vm/analysis/errors.rs

@@ -14,6 +14,11 @@ pub enum CheckErrors {
     ValueTooLarge,
     ExpectedName,
 
+    // match errors
+    BadMatchOptionSyntax(Box<CheckErrors>),
+    BadMatchResponseSyntax(Box<CheckErrors>),
+    BadMatchInput(TypeSignature),
+
     // list typing errors
     UnknownListConstructionFailure,
     ListTypesMustMatch,
@@ -34,11 +39,15 @@ pub enum CheckErrors {
 
     ExpectedOptionalType(TypeSignature),
     ExpectedResponseType(TypeSignature),
+    ExpectedOptionalOrResponseType(TypeSignature),
     ExpectedOptionalValue(Value),
     ExpectedResponseValue(Value),
+    ExpectedOptionalOrResponseValue(Value),
     CouldNotDetermineResponseOkType,
     CouldNotDetermineResponseErrType,
 
+    CouldNotDetermineMatchTypes,
+
     // Checker runtime failures
     TypeAlreadyAnnotatedFailure,
     TypeAnnotationExpectedFailure,
@@ -86,7 +95,7 @@ pub enum CheckErrors {
     ContractAlreadyExists(String),
     ContractCallExpectName,
 
-    // get-block-info errors
+    // get-block-info? errors
     NoSuchBlockInfoProperty(String),
     GetBlockInfoExpectPropertyName,
 
@@ -113,6 +122,7 @@ pub enum CheckErrors {
     RequiresAtLeastArguments(usize, usize),
     IncorrectArgumentCount(usize, usize),
     IfArmsMustMatch(TypeSignature, TypeSignature),
+    MatchArmsMustMatch(TypeSignature, TypeSignature),
     DefaultTypesMustMatch(TypeSignature, TypeSignature),
     TooManyExpressions,
     IllegalOrUnknownFunctionApplication(String),
@@ -215,6 +225,14 @@ impl DiagnosableError for CheckErrors {
 
     fn message(&self) -> String {
         match &self {
+            CheckErrors::BadMatchOptionSyntax(source) =>
+                format!("match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: {}",
+                        source.message()),
+            CheckErrors::BadMatchResponseSyntax(source) =>
+                format!("match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: {}",
+                        source.message()),
+            CheckErrors::BadMatchInput(t) =>
+                format!("match requires an input of either a response or optional, found input: '{}'", t),
             CheckErrors::TypeAnnotationExpectedFailure => "analysis expected type to already be annotated for expression".into(),
             CheckErrors::CostOverflow => "contract execution cost overflowed cost counter".into(),
             CheckErrors::InvalidTypeDescription => "supplied type description is invalid".into(),
@@ -233,11 +251,14 @@ impl DiagnosableError for CheckErrors {
             CheckErrors::UnionTypeError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type),
             CheckErrors::UnionTypeValueError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type),
             CheckErrors::ExpectedOptionalType(found_type) => format!("expecting expression of type 'optional', found '{}'", found_type),
+            CheckErrors::ExpectedOptionalOrResponseType(found_type) => format!("expecting expression of type 'optional' or 'response', found '{}'", found_type),
+            CheckErrors::ExpectedOptionalOrResponseValue(found_type) =>  format!("expecting expression of type 'optional' or 'response', found '{}'", found_type),
             CheckErrors::ExpectedResponseType(found_type) => format!("expecting expression of type 'response', found '{}'", found_type),
             CheckErrors::ExpectedOptionalValue(found_type) => format!("expecting expression of type 'optional', found '{}'", found_type),
             CheckErrors::ExpectedResponseValue(found_type) => format!("expecting expression of type 'response', found '{}'", found_type),
             CheckErrors::CouldNotDetermineResponseOkType => format!("attempted to obtain 'ok' value from response, but 'ok' type is indeterminate"),
             CheckErrors::CouldNotDetermineResponseErrType => format!("attempted to obtain 'err' value from response, but 'err' type is indeterminate"),
+            CheckErrors::CouldNotDetermineMatchTypes => format!("attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead."),
             CheckErrors::BadTupleFieldName => format!("invalid tuple field name"),
             CheckErrors::ExpectedTuple(type_signature) => format!("expecting tuple, found '{}'", type_signature),
             CheckErrors::NoSuchTupleField(field_name, tuple_signature) => format!("cannot find field '{}' in tuple '{}'", field_name, tuple_signature),
@@ -275,6 +296,7 @@ impl DiagnosableError for CheckErrors {
             CheckErrors::RequiresAtLeastArguments(expected, found) => format!("expecting >= {} argument, got {}", expected, found),
             CheckErrors::IncorrectArgumentCount(expected_count, found_count) => format!("expecting {} arguments, got {}", expected_count, found_count),
             CheckErrors::IfArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'if' must match (got '{}' and '{}')", type_1, type_2),
+            CheckErrors::MatchArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'match' must match (got '{}' and '{}')", type_1, type_2),
             CheckErrors::DefaultTypesMustMatch(type_1, type_2) => format!("expression types passed in 'default-to' must match (got '{}' and '{}')", type_1, type_2),
             CheckErrors::TooManyExpressions => format!("reached limit of expressions"),
             CheckErrors::IllegalOrUnknownFunctionApplication(function_name) => format!("use of illegal / unresolved function '{}", function_name),

Diff for: src/vm/analysis/read_only_checker/mod.rs

@@ -161,8 +161,9 @@ impl <'a, 'b> ReadOnlyChecker <'a, 'b> {
             Add | Subtract | Divide | Multiply | CmpGeq | CmpLeq | CmpLess | CmpGreater |
             Modulo | Power | BitwiseXOR | And | Or | Not | Hash160 | Sha256 | Keccak256 | Equals | If |
             Sha512 | Sha512Trunc256 |
-            ConsSome | ConsOkay | ConsError | DefaultTo | Expects | ExpectsErr | IsOkay | IsNone | Asserts |
-            ToUInt | ToInt | Append | Concat | AssertsMaxLen |
+            ConsSome | ConsOkay | ConsError | DefaultTo | UnwrapRet | UnwrapErrRet | IsOkay | IsNone | Asserts |
+            Unwrap | UnwrapErr | Match | IsErr | IsSome | TryRet |
+            ToUInt | ToInt | Append | Concat | AsMaxLen |
             ListCons | GetBlockInfo | TupleGet | Len | Print | AsContract | Begin | FetchVar | GetTokenBalance | GetAssetOwner => {
                 self.check_all_read_only(args)
             },