types: remove one calls to ResolvedType::as_inner

Our goal is to reduce/eliminate the places outside of the `types` module
that use the `TypeInner` type, since this is (ideally) an implementation
detail of `ResolvedType`.

There aren't a lot of these places, it turns out. This commit removes
one "easy" one, in pattern.rs. There, previously we were matching arrays
and using a wildcard _ match to return an error on mismatches. By adding
a bit of code repetiton (the 'return error' line 3 times) and calling
TypeDestructible::as_list and as_array, we can get rid of the wildcard
match, which eliminates the `TypeInner` but also is more robust against
extensions to the Pattern enum.

This leaves the use in ast.rs in `cast_preserves_enum_identity` which
seems quite difficult to remove correctly (the existing code is not
correct either, but ok, let's leave it alone unless we can fix it
completely). We want to make this nonrecursive and correct, but it will
have to wait for a later PR.

Aside from that, the only parts of the code, outside the ResolvedType
module itself, that now need to know the internals of ResolvedType are
in value.rs. Since the structure of Value mirrors the structure of
ResolvedType probably we will just have to live with this; when we
change the representation of ResolvedType we will need to make parallel
changes in value.rs.

Author: apoelstra

src/pattern.rs

@@ -9,7 +9,7 @@ use crate::array::BTreeSlice;
 use crate::error::Error;
 use crate::named::{CoreExt, PairBuilder, SelectorBuilder};
 use crate::str::Identifier;
-use crate::types::{ResolvedType, TypeInner};
+use crate::types::{ResolvedType, TypeDeconstructible};
 use crate::unstable::impl_require_feature;
 
 /// Pattern for binding values to variables.
@@ -51,25 +51,37 @@ impl Pattern {
         let mut stack = vec![(self, ty)];
         let mut output = HashMap::new();
         while let Some((pattern, ty)) = stack.pop() {
-            match (pattern, ty.as_inner()) {
-                (Pattern::Identifier(i), _) => match output.entry(i.clone()) {
+            let unexpected_err = || Err(Error::ExpressionUnexpectedType { ty: ty.clone() });
+            match pattern {
+                Pattern::Identifier(i) => match output.entry(i.clone()) {
                     Entry::Occupied(..) => {
                         return Err(Error::VariableReuseInPattern {
                             identifier: i.clone(),
-                        })
+                        });
                     }
                     Entry::Vacant(entry) => {
                         entry.insert(ty.clone());
                     }
                 },
-                (Pattern::Ignore, _) => {}
-                (Pattern::Tuple(pats), TypeInner::Tuple(types)) => {
-                    stack.extend(pats.iter().zip(types.iter().map(Arc::as_ref)));
+                Pattern::Ignore => {}
+                Pattern::Tuple(pats) => {
+                    if let Some(types) = ty.as_tuple() {
+                        stack.extend(pats.iter().zip(types.iter().map(Arc::as_ref)));
+                    } else {
+                        return unexpected_err();
+                    }
                 }
-                (Pattern::Array(pats), TypeInner::Array(ty, size)) if pats.len() == *size => {
-                    stack.extend(pats.iter().zip(std::iter::repeat(ty.as_ref())));
+                Pattern::Array(pats) => {
+                    if let Some((ty, size)) = ty.as_array() {
+                        if pats.len() == size {
+                            stack.extend(pats.iter().zip(std::iter::repeat(ty)));
+                        } else {
+                            return unexpected_err();
+                        }
+                    } else {
+                        return unexpected_err();
+                    }
                 }
-                _ => return Err(Error::ExpressionUnexpectedType { ty: ty.clone() }),
             }
         }
         Ok(output)