Merge pull request #6494 from Jiloc/chore/remove-unused-check-errors-variants

chore: remove unused `CheckErrors`' variants

Author: Jiloc

clarity-types/src/errors/analysis.rs

@@ -165,24 +165,20 @@ pub enum CheckErrors {
     BadMatchInput(Box<TypeSignature>),
 
     // list typing errors
-    UnknownListConstructionFailure,
     ListTypesMustMatch,
     ConstructedListTooLarge,
 
     // simple type expectation mismatch
     TypeError(Box<TypeSignature>, Box<TypeSignature>),
-    TypeLiteralError(Box<TypeSignature>, Box<TypeSignature>),
     TypeValueError(Box<TypeSignature>, Box<Value>),
 
-    NoSuperType(Box<TypeSignature>, Box<TypeSignature>),
     InvalidTypeDescription,
     UnknownTypeName(String),
 
     // union type mismatch
     UnionTypeError(Vec<TypeSignature>, Box<TypeSignature>),
     UnionTypeValueError(Vec<TypeSignature>, Box<Value>),
 
-    ExpectedLiteral,
     ExpectedOptionalType(Box<TypeSignature>),
     ExpectedResponseType(Box<TypeSignature>),
     ExpectedOptionalOrResponseType(Box<TypeSignature>),
@@ -200,12 +196,10 @@ pub enum CheckErrors {
 
     // Checker runtime failures
     TypeAlreadyAnnotatedFailure,
-    TypeAnnotationExpectedFailure,
     CheckerImplementationFailure,
 
     // Assets
     BadTokenName,
-    DefineFTBadSignature,
     DefineNFTBadSignature,
     NoSuchNFT(String),
     NoSuchFT(String),
@@ -284,7 +278,6 @@ pub enum CheckErrors {
     IfArmsMustMatch(Box<TypeSignature>, Box<TypeSignature>),
     MatchArmsMustMatch(Box<TypeSignature>, Box<TypeSignature>),
     DefaultTypesMustMatch(Box<TypeSignature>, Box<TypeSignature>),
-    TooManyExpressions,
     IllegalOrUnknownFunctionApplication(String),
     UnknownFunction(String),
 
@@ -293,7 +286,6 @@ pub enum CheckErrors {
     TraitReferenceUnknown(String),
     TraitMethodUnknown(String, String),
     ExpectedTraitIdentifier,
-    ImportTraitBadSignature,
     TraitReferenceNotAllowed,
     BadTraitImplementation(String, String),
     DefineTraitBadSignature,
@@ -496,7 +488,6 @@ fn formatted_expected_types(expected_types: &[TypeSignature]) -> String {
 impl DiagnosableError for CheckErrors {
     fn message(&self) -> String {
         match &self {
-            CheckErrors::ExpectedLiteral => "expected a literal argument".into(),
             CheckErrors::SupertypeTooLarge => "supertype of two types is too large".into(),
             CheckErrors::Expects(s) => format!("unexpected interpreter behavior: {s}"),
             CheckErrors::BadMatchOptionSyntax(source) =>
@@ -507,7 +498,6 @@ impl DiagnosableError for CheckErrors {
                         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::CostBalanceExceeded(a, b) => format!("contract execution cost exceeded budget: {a:?} > {b:?}"),
             CheckErrors::MemoryBalanceExceeded(a, b) => format!("contract execution cost exceeded memory budget: {a:?} > {b:?}"),
@@ -518,12 +508,9 @@ impl DiagnosableError for CheckErrors {
             CheckErrors::ValueOutOfBounds => "created a type which value size was out of defined bounds".into(),
             CheckErrors::TypeSignatureTooDeep => "created a type which was deeper than maximum allowed type depth".into(),
             CheckErrors::ExpectedName => "expected a name argument to this function".into(),
-            CheckErrors::NoSuperType(a, b) => format!("unable to create a supertype for the two types: '{a}' and '{b}'"),
-            CheckErrors::UnknownListConstructionFailure => "invalid syntax for list definition".into(),
             CheckErrors::ListTypesMustMatch => "expecting elements of same type in a list".into(),
             CheckErrors::ConstructedListTooLarge => "reached limit of elements in a sequence".into(),
             CheckErrors::TypeError(expected_type, found_type) => format!("expecting expression of type '{expected_type}', found '{found_type}'"),
-            CheckErrors::TypeLiteralError(expected_type, found_type) => format!("expecting a literal of type '{expected_type}', found '{found_type}'"),
             CheckErrors::TypeValueError(expected_type, found_value) => format!("expecting expression of type '{expected_type}', found '{found_value}'"),
             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),
@@ -588,21 +575,18 @@ impl DiagnosableError for CheckErrors {
             CheckErrors::IfArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'if' must match (got '{type_1}' and '{type_2}')"),
             CheckErrors::MatchArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'match' must match (got '{type_1}' and '{type_2}')"),
             CheckErrors::DefaultTypesMustMatch(type_1, type_2) => format!("expression types passed in 'default-to' must match (got '{type_1}' and '{type_2}')"),
-            CheckErrors::TooManyExpressions => "reached limit of expressions".into(),
             CheckErrors::IllegalOrUnknownFunctionApplication(function_name) => format!("use of illegal / unresolved function '{function_name}"),
             CheckErrors::UnknownFunction(function_name) => format!("use of unresolved function '{function_name}'"),
             CheckErrors::TraitBasedContractCallInReadOnly => "use of trait based contract calls are not allowed in read-only context".into(),
             CheckErrors::WriteAttemptedInReadOnly => "expecting read-only statements, detected a writing operation".into(),
             CheckErrors::AtBlockClosureMustBeReadOnly => "(at-block ...) closures expect read-only statements, but detected a writing operation".into(),
             CheckErrors::BadTokenName => "expecting an token name as an argument".into(),
-            CheckErrors::DefineFTBadSignature => "(define-token ...) expects a token name as an argument".into(),
             CheckErrors::DefineNFTBadSignature => "(define-asset ...) expects an asset name and an asset identifier type signature as arguments".into(),
             CheckErrors::NoSuchNFT(asset_name) => format!("tried to use asset function with a undefined asset ('{asset_name}')"),
             CheckErrors::NoSuchFT(asset_name) => format!("tried to use token function with a undefined token ('{asset_name}')"),
             CheckErrors::NoSuchTrait(contract_name, trait_name) => format!("use of unresolved trait {contract_name}.{trait_name}"),
             CheckErrors::TraitReferenceUnknown(trait_name) => format!("use of undeclared trait <{trait_name}>"),
             CheckErrors::TraitMethodUnknown(trait_name, func_name) => format!("method '{func_name}' unspecified in trait <{trait_name}>"),
-            CheckErrors::ImportTraitBadSignature => "(use-trait ...) expects a trait name and a trait identifier".into(),
             CheckErrors::BadTraitImplementation(trait_name, func_name) => format!("invalid signature for method '{func_name}' regarding trait's specification <{trait_name}>"),
             CheckErrors::ExpectedTraitIdentifier => "expecting expression of type trait identifier".into(),
             CheckErrors::UnexpectedTraitOrFieldReference => "unexpected use of trait reference or field".into(),

clarity-types/src/types/signatures.rs

@@ -971,26 +971,43 @@ impl TypeSignature {
         }
     }
 
-    /// This function returns the most-restrictive type that admits _both_ A and B (something like a least common supertype),
-    /// or Errors if no such type exists. On error, it throws NoSuperType(A,B), unless a constructor error'ed -- in which case,
-    /// it throws the constructor's error.
+    /// Returns the most-restrictive type that admits _both_ A and B (something like a least common supertype),
+    /// or Errors if no such type exists. On error, it throws TypeError(A,B), unless a constructor error'ed,
+    /// in which case, it throws SupertypeTooLarge.
     ///
-    ///  For two Tuples:
-    ///      least_supertype(A, B) := (tuple \for_each(key k) least_supertype(type_a_k, type_b_k))
-    ///  For two Lists:
-    ///      least_supertype(A, B) := (list max_len: max(max_len A, max_len B), entry: least_supertype(entry_a, entry_b))
-    ///        if max_len A | max_len B is 0: entry := Non-empty list entry
-    ///  For two responses:
-    ///      least_supertype(A, B) := (response least_supertype(ok_a, ok_b), least_supertype(err_a, err_b))
-    ///        if any entries are NoType, use the other type's entry
-    ///  For two options:
-    ///      least_supertype(A, B) := (option least_supertype(some_a, some_b))
-    ///        if some_a | some_b is NoType, use the other type's entry.
-    ///  For buffers:
-    ///      least_supertype(A, B) := (buff len: max(len A, len B))
-    ///  For ints, uints, principals, bools:
-    ///      least_supertype(A, B) := if A != B, error, else A
+    /// The behavior varies by epoch:
+    /// - Epoch 2.0/2.05: Uses [`TypeSignature::least_supertype_v2_0`]
+    /// - Epoch 2.1+: Uses [`TypeSignature::least_supertype_v2_1`], Adds support for CallableTypes and ListUnionTypes
     ///
+    /// For two Tuples:
+    ///     least_supertype(A, B) := (tuple \for_each(key k) least_supertype(type_a_k, type_b_k))
+    ///     Note: `A`'s keys must be a subset of `B`'s.
+    /// For two Lists:
+    ///     least_supertype(A, B) := (list max_len: max(max_len A, max_len B), entry: least_supertype(entry_a, entry_b))
+    ///     If max_len A | max_len B is 0: entry := Non-empty list entry
+    /// For two Responses:
+    ///     least_supertype(A, B) := (response least_supertype(ok_a, ok_b), least_supertype(err_a, err_b))
+    ///     If any entries are NoType, use the other type's entry
+    /// For two Options:
+    ///     least_supertype(A, B) := (option least_supertype(some_a, some_b))
+    ///     If some_a | some_b is NoType, use the other type's entry
+    /// For Buffers:
+    ///     least_supertype(A, B) := (buff len: max(len A, len B))
+    /// For ASCII/UTF8 Strings:
+    ///     least_supertype(A, B) := (string len: max(len A, len B))
+    ///     Note: ASCII and UTF8 strings cannot be unified
+    /// For NoType:
+    ///     least_supertype(NoType, X) := X
+    /// For CallableTypes (v2.1+ only):
+    ///     - Two identical CallableTypes unify to themselves
+    ///     - Two different CallableTypes unify to a ListUnionType containing both
+    ///     - CallableType and ListUnionType unify by adding the callable to the union
+    ///     - Principal type unifies with CallableSubtype::Principal(_) to PrincipalType
+    ///     - Principal type unifies with ListUnionType if all members are principals
+    /// For ListUnionTypes (v2.1+ only):
+    ///     least_supertype(A, B) := ListUnionType with the union of both sets
+    /// For other types (ints, uints, principals, bools):
+    ///     least_supertype(A, B) := if A != B, error, else A
     pub fn least_supertype(
         epoch: &StacksEpochId,
         a: &TypeSignature,