add span for AliasedType

This would allow make better error messages, which wouldn highlight only
problematic parts

Author: gerau

src/types.rs

@@ -6,6 +6,7 @@ use miniscript::iter::{Tree, TreeLike};
 use simplicity::types::{CompleteBound, Final};
 
 use crate::array::{BTreeSlice, Partition};
+use crate::error::Span;
 use crate::num::{NonZeroPow2Usize, Pow2Usize};
 use crate::str::AliasName;
 
@@ -486,7 +487,7 @@ impl<'a> arbitrary::Arbitrary<'a> for ResolvedType {
 
 /// SimplicityHL type with type aliases.
 #[derive(PartialEq, Eq, Hash, Clone)]
-pub struct AliasedType(AliasedInner);
+pub struct AliasedType(AliasedInner, Span);
 
 /// Type alias or primitive.
 ///
@@ -548,14 +549,26 @@ impl AliasedType {
         }
     }
 
+    const fn new(inner: AliasedInner) -> Self {
+        Self(inner, Span::new(0, 0))
+    }
+
+    pub fn span(&self) -> Span {
+        self.1
+    }
+
+    pub fn with_span(self, span: Span) -> Self {
+        Self(self.0, span)
+    }
+
     /// Create a type alias from the given `identifier`.
     pub const fn alias(name: AliasName) -> Self {
-        Self(AliasedInner::Alias(name))
+        Self::new(AliasedInner::Alias(name))
     }
 
     /// Create a builtin type alias.
     pub const fn builtin(builtin: BuiltinAlias) -> Self {
-        Self(AliasedInner::Builtin(builtin))
+        Self::new(AliasedInner::Builtin(builtin))
     }
 
     /// Resolve all aliases in the type based on the given map of `aliases` to types.
@@ -615,35 +628,35 @@ impl AliasedType {
 
 impl TypeConstructible for AliasedType {
     fn either(left: Self, right: Self) -> Self {
-        Self(AliasedInner::Inner(TypeInner::Either(
+        Self::new(AliasedInner::Inner(TypeInner::Either(
             Arc::new(left),
             Arc::new(right),
         )))
     }
 
     fn option(inner: Self) -> Self {
-        Self(AliasedInner::Inner(TypeInner::Option(Arc::new(inner))))
+        Self::new(AliasedInner::Inner(TypeInner::Option(Arc::new(inner))))
     }
 
     fn boolean() -> Self {
-        Self(AliasedInner::Inner(TypeInner::Boolean))
+        Self::new(AliasedInner::Inner(TypeInner::Boolean))
     }
 
     fn tuple<I: IntoIterator<Item = Self>>(elements: I) -> Self {
-        Self(AliasedInner::Inner(TypeInner::Tuple(
+        Self::new(AliasedInner::Inner(TypeInner::Tuple(
             elements.into_iter().map(Arc::new).collect(),
         )))
     }
 
     fn array(element: Self, size: usize) -> Self {
-        Self(AliasedInner::Inner(TypeInner::Array(
+        Self::new(AliasedInner::Inner(TypeInner::Array(
             Arc::new(element),
             size,
         )))
     }
 
     fn list(element: Self, bound: NonZeroPow2Usize) -> Self {
-        Self(AliasedInner::Inner(TypeInner::List(
+        Self::new(AliasedInner::Inner(TypeInner::List(
             Arc::new(element),
             bound,
         )))
@@ -737,7 +750,7 @@ impl fmt::Display for AliasedType {
 
 impl From<UIntType> for AliasedType {
     fn from(value: UIntType) -> Self {
-        Self(AliasedInner::Inner(TypeInner::UInt(value)))
+        Self::new(AliasedInner::Inner(TypeInner::UInt(value)))
     }
 }