remove unused CheckErrors' variants

Author: Jiloc

clarity-types/src/errors/analysis.rs

@@ -165,24 +165,20 @@ pub enum CheckErrors {
     BadMatchInput(TypeSignature),
 
     // list typing errors
-    UnknownListConstructionFailure,
     ListTypesMustMatch,
     ConstructedListTooLarge,
 
     // simple type expectation mismatch
     TypeError(TypeSignature, TypeSignature),
-    TypeLiteralError(TypeSignature, TypeSignature),
     TypeValueError(TypeSignature, Value),
 
-    NoSuperType(TypeSignature, TypeSignature),
     InvalidTypeDescription,
     UnknownTypeName(String),
 
     // union type mismatch
     UnionTypeError(Vec<TypeSignature>, TypeSignature),
     UnionTypeValueError(Vec<TypeSignature>, Value),
 
-    ExpectedLiteral,
     ExpectedOptionalType(TypeSignature),
     ExpectedResponseType(TypeSignature),
     ExpectedOptionalOrResponseType(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(TypeSignature, TypeSignature),
     MatchArmsMustMatch(TypeSignature, TypeSignature),
     DefaultTypesMustMatch(TypeSignature, 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,
@@ -499,7 +491,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) =>
@@ -510,7 +501,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:?}"),
@@ -521,12 +511,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),
@@ -591,21 +578,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

@@ -977,8 +977,7 @@ impl TypeSignature {
     ///
     /// 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
+    /// - 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))