Merge pull request #6913 from federico-stacks/aac/static-expect-to-unrechable

aac: convert static check "expectable" errors to "unrechable"

Author: jacinta-stacks

clarity-types/src/errors/analysis.rs

@@ -249,13 +249,8 @@ pub enum StaticCheckErrorKind {
     /// Supertype (i.e. common denominator between two types) exceeds the maximum allowed size or complexity.
     SupertypeTooLarge,
 
-    // Unexpected interpreter behavior
     /// Unexpected condition or failure in the type-checker, indicating a bug or invalid state.
-    ExpectsRejectable(String),
-    // Unexpected interpreter behavior
-    /// Unexpected condition or failure in the type-checker, indicating a bug or invalid state.
-    /// This error does NOT indicate a transaction would invalidate a block if included.
-    ExpectsAcceptable(String),
+    Unreachable(String),
 
     // Match expression errors
     /// Invalid syntax in an `option` match expression.
@@ -660,7 +655,7 @@ impl StaticCheckErrorKind {
     pub fn rejectable_in_epoch(&self, epoch: StacksEpochId) -> bool {
         match self {
             StaticCheckErrorKind::SupertypeTooLarge => epoch.rejects_supertype_too_large(),
-            StaticCheckErrorKind::ExpectsRejectable(_) => true,
+            StaticCheckErrorKind::Unreachable(_) => true,
             _ => false,
         }
     }
@@ -724,22 +719,20 @@ impl From<ClarityTypeError> for StaticCheckErrorKind {
             | ClarityTypeError::TypeMismatchValue(_, _)
             | ClarityTypeError::ResponseTypeMismatch { .. }
             | ClarityTypeError::InvalidAsciiCharacter(_)
-            | ClarityTypeError::InvalidUtf8Encoding => Self::ExpectsAcceptable(format!(
-                "Unexpected error type during static analysis: {err}"
-            )),
-            ClarityTypeError::InvariantViolation(_)
-            | ClarityTypeError::InvalidPrincipalVersion(_) => Self::ExpectsRejectable(format!(
+            | ClarityTypeError::InvalidUtf8Encoding
+            | ClarityTypeError::InvariantViolation(_)
+            | ClarityTypeError::InvalidPrincipalVersion(_) => Self::Unreachable(format!(
                 "Unexpected error type during static analysis: {err}"
             )),
             ClarityTypeError::CouldNotDetermineSerializationType => {
                 Self::CouldNotDetermineSerializationType
             }
             ClarityTypeError::CouldNotDetermineType => Self::CouldNotDetermineType,
             ClarityTypeError::UnsupportedTypeInEpoch(ty, epoch) => {
-                Self::ExpectsRejectable(format!("{ty} should not be used in {epoch}"))
+                Self::Unreachable(format!("{ty} should not be used in {epoch}"))
             }
             ClarityTypeError::UnsupportedEpoch(epoch) => {
-                Self::ExpectsRejectable(format!("{epoch} is not supported"))
+                Self::Unreachable(format!("{epoch} is not supported"))
             }
         }
     }
@@ -875,10 +868,10 @@ impl From<CostErrors> for StaticCheckErrorKind {
             CostErrors::CostContractLoadFailure => {
                 StaticCheckErrorKind::CostComputationFailed("Failed to load cost contract".into())
             }
-            CostErrors::InterpreterFailure => StaticCheckErrorKind::ExpectsRejectable(
+            CostErrors::InterpreterFailure => StaticCheckErrorKind::Unreachable(
                 "Unexpected interpreter failure in cost computation".into(),
             ),
-            CostErrors::Expect(s) => StaticCheckErrorKind::ExpectsRejectable(s),
+            CostErrors::Expect(s) => StaticCheckErrorKind::Unreachable(s),
             CostErrors::ExecutionTimeExpired => StaticCheckErrorKind::ExecutionTimeExpired,
         }
     }
@@ -1101,8 +1094,7 @@ impl DiagnosableError for StaticCheckErrorKind {
     fn message(&self) -> String {
         match &self {
             StaticCheckErrorKind::SupertypeTooLarge => "supertype of two types is too large".into(),
-            StaticCheckErrorKind::ExpectsRejectable(s) => format!("unexpected and unacceptable interpreter behavior: {s}"),
-            StaticCheckErrorKind::ExpectsAcceptable(s) => format!("unexpected but acceptable interpreter behaviour: {s}"),
+            StaticCheckErrorKind::Unreachable(s) => format!("unexpected and unacceptable interpreter behavior: {s}"),
             StaticCheckErrorKind::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()),

clarity/src/vm/analysis/analysis_db.rs

@@ -51,11 +51,11 @@ impl<'a> AnalysisDatabase<'a> {
         self.begin();
         let result = f(self).or_else(|e| {
             self.roll_back()
-                .map_err(|e| StaticCheckErrorKind::ExpectsRejectable(format!("{e:?}")))?;
+                .map_err(|e| StaticCheckErrorKind::Unreachable(format!("{e:?}")))?;
             Err(e)
         })?;
         self.commit()
-            .map_err(|e| StaticCheckErrorKind::ExpectsRejectable(format!("{e:?}")))?;
+            .map_err(|e| StaticCheckErrorKind::Unreachable(format!("{e:?}")))?;
         Ok(result)
     }
 
@@ -66,13 +66,13 @@ impl<'a> AnalysisDatabase<'a> {
     pub fn commit(&mut self) -> Result<(), StaticCheckError> {
         self.store
             .commit()
-            .map_err(|e| StaticCheckErrorKind::ExpectsRejectable(format!("{e:?}")).into())
+            .map_err(|e| StaticCheckErrorKind::Unreachable(format!("{e:?}")).into())
     }
 
     pub fn roll_back(&mut self) -> Result<(), StaticCheckError> {
         self.store
             .rollback()
-            .map_err(|e| StaticCheckErrorKind::ExpectsRejectable(format!("{e:?}")).into())
+            .map_err(|e| StaticCheckErrorKind::Unreachable(format!("{e:?}")).into())
     }
 
     pub fn storage_key() -> &'static str {
@@ -108,8 +108,7 @@ impl<'a> AnalysisDatabase<'a> {
             .flatten()
             .map(|x| {
                 ContractAnalysis::deserialize(&x).map_err(|_| {
-                    StaticCheckErrorKind::ExpectsRejectable("Bad data deserialized from DB".into())
-                        .into()
+                    StaticCheckErrorKind::Unreachable("Bad data deserialized from DB".into()).into()
                 })
             })
             .transpose()
@@ -129,7 +128,7 @@ impl<'a> AnalysisDatabase<'a> {
             .flatten()
             .map(|x| {
                 ContractAnalysis::deserialize(&x).map_err(|_| {
-                    StaticCheckErrorKind::ExpectsRejectable("Bad data deserialized from DB".into())
+                    StaticCheckErrorKind::Unreachable("Bad data deserialized from DB".into())
                 })
             })
             .transpose()?
@@ -154,7 +153,7 @@ impl<'a> AnalysisDatabase<'a> {
 
         self.store
             .insert_metadata(contract_identifier, key, &contract.serialize())
-            .map_err(|e| StaticCheckErrorKind::ExpectsRejectable(format!("{e:?}")))?;
+            .map_err(|e| StaticCheckErrorKind::Unreachable(format!("{e:?}")))?;
         Ok(())
     }
 

clarity/src/vm/analysis/contract_interface_builder/mod.rs

@@ -278,7 +278,7 @@ impl ContractInterfaceFunction {
                             FunctionType::Fixed(FixedFunction { returns, .. }) => {
                                 ContractInterfaceAtomType::from_type_signature(returns)
                             }
-                            _ => return Err(StaticCheckErrorKind::ExpectsRejectable(
+                            _ => return Err(StaticCheckErrorKind::Unreachable(
                                 "Contract functions should only have fixed function return types!"
                                     .into(),
                             )
@@ -290,7 +290,7 @@ impl ContractInterfaceFunction {
                             ContractInterfaceFunctionArg::from_function_args(args)
                         }
                         _ => {
-                            return Err(StaticCheckErrorKind::ExpectsRejectable(
+                            return Err(StaticCheckErrorKind::Unreachable(
                                 "Contract functions should only have fixed function arguments!"
                                     .into(),
                             )
@@ -402,7 +402,7 @@ impl ContractInterface {
 
     pub fn serialize(&self) -> Result<String, StaticCheckError> {
         serde_json::to_string(self).map_err(|_| {
-            StaticCheckErrorKind::ExpectsRejectable("Failed to serialize contract interface".into())
+            StaticCheckErrorKind::Unreachable("Failed to serialize contract interface".into())
                 .into()
         })
     }

clarity/src/vm/analysis/mod.rs

@@ -57,7 +57,7 @@ pub fn mem_type_check(
 ) -> Result<(Option<TypeSignature>, ContractAnalysis), StaticCheckError> {
     let contract_identifier = QualifiedContractIdentifier::transient();
     let contract = build_ast(&contract_identifier, snippet, &mut (), version, epoch)
-        .map_err(|e| StaticCheckErrorKind::ExpectsRejectable(format!("Failed to build AST: {e}")))?
+        .map_err(|e| StaticCheckErrorKind::Unreachable(format!("Failed to build AST: {e}")))?
         .expressions;
 
     let mut marf = MemoryBackingStore::new();
@@ -79,11 +79,9 @@ pub fn mem_type_check(
             let first_type = x
                 .type_map
                 .as_ref()
-                .ok_or_else(|| {
-                    StaticCheckErrorKind::ExpectsRejectable("Should be non-empty".into())
-                })?
+                .ok_or_else(|| StaticCheckErrorKind::Unreachable("Should be non-empty".into()))?
                 .get_type_expected(x.expressions.last().ok_or_else(|| {
-                    StaticCheckErrorKind::ExpectsRejectable("Should be non-empty".into())
+                    StaticCheckErrorKind::Unreachable("Should be non-empty".into())
                 })?)
                 .cloned();
             Ok((first_type, x))
@@ -155,7 +153,7 @@ pub fn run_analysis(
                 TypeChecker2_1::run_pass(&epoch, &mut contract_analysis, db, build_type_map)
             }
             StacksEpochId::Epoch10 => {
-                return Err(StaticCheckErrorKind::ExpectsRejectable(
+                return Err(StaticCheckErrorKind::Unreachable(
                     "Epoch 1.0 is not a valid epoch for analysis".into(),
                 )
                 .into());

clarity/src/vm/analysis/type_checker/mod.rs

@@ -49,10 +49,9 @@ impl FunctionType {
             | StacksEpochId::Epoch32
             | StacksEpochId::Epoch33
             | StacksEpochId::Epoch34 => self.check_args_2_1(accounting, args, clarity_version),
-            StacksEpochId::Epoch10 => Err(StaticCheckErrorKind::ExpectsRejectable(
-                "Epoch10 is not supported".into(),
-            )
-            .into()),
+            StacksEpochId::Epoch10 => {
+                Err(StaticCheckErrorKind::Unreachable("Epoch10 is not supported".into()).into())
+            }
         }
     }
 
@@ -79,10 +78,9 @@ impl FunctionType {
             | StacksEpochId::Epoch34 => {
                 self.check_args_by_allowing_trait_cast_2_1(db, clarity_version, func_args)
             }
-            StacksEpochId::Epoch10 => Err(StaticCheckErrorKind::ExpectsRejectable(
-                "Epoch10 is not supported".into(),
-            )
-            .into()),
+            StacksEpochId::Epoch10 => {
+                Err(StaticCheckErrorKind::Unreachable("Epoch10 is not supported".into()).into())
+            }
         }
     }
 }

clarity/src/vm/analysis/type_checker/v2_05/mod.rs

@@ -249,7 +249,7 @@ impl FunctionType {
 
                 Ok(TypeSignature::BoolType)
             }
-            FunctionType::Binary(_, _, _) => Err(StaticCheckErrorKind::ExpectsRejectable(
+            FunctionType::Binary(_, _, _) => Err(StaticCheckErrorKind::Unreachable(
                 "Binary type should not be reached in 2.05".into(),
             )
             .into()),
@@ -264,10 +264,9 @@ impl FunctionType {
         let (expected_args, returns) = match self {
             FunctionType::Fixed(FixedFunction { args, returns }) => (args, returns),
             _ => {
-                return Err(StaticCheckErrorKind::ExpectsRejectable(
-                    "Unexpected function type".into(),
-                )
-                .into());
+                return Err(
+                    StaticCheckErrorKind::Unreachable("Unexpected function type".into()).into(),
+                );
             }
         };
         check_argument_count(expected_args.len(), func_args)?;
@@ -340,13 +339,13 @@ fn type_reserved_variable(variable_name: &str) -> Result<Option<TypeSignature>,
             BlockHeight => TypeSignature::UIntType,
             BurnBlockHeight => TypeSignature::UIntType,
             NativeNone => TypeSignature::new_option(no_type())
-                .map_err(|_| StaticCheckErrorKind::ExpectsRejectable("Bad constructor".into()))?,
+                .map_err(|_| StaticCheckErrorKind::Unreachable("Bad constructor".into()))?,
             NativeTrue => TypeSignature::BoolType,
             NativeFalse => TypeSignature::BoolType,
             TotalLiquidMicroSTX => TypeSignature::UIntType,
             Regtest => TypeSignature::BoolType,
             TxSponsor | Mainnet | ChainId | StacksBlockHeight | TenureHeight | StacksBlockTime | CurrentContract => {
-                return Err(StaticCheckErrorKind::ExpectsRejectable(
+                return Err(StaticCheckErrorKind::Unreachable(
                     "tx-sponsor, mainnet, chain-id, stacks-block-height, tenure-height, stacks-block-time, and current-contract should not reach here in 2.05".into(),
                 )
                 .into())
@@ -437,9 +436,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                 }
                 Err(e) => Err(e),
             })?
-            .ok_or_else(|| {
-                StaticCheckErrorKind::ExpectsRejectable("Expected a depth result".into())
-            })?;
+            .ok_or_else(|| StaticCheckErrorKind::Unreachable("Expected a depth result".into()))?;
         }
 
         runtime_cost(ClarityCostFunction::AnalysisStorage, self, size)?;
@@ -610,7 +607,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         )?;
 
         if self.function_return_tracker.is_some() {
-            return Err(StaticCheckErrorKind::ExpectsRejectable(
+            return Err(StaticCheckErrorKind::Unreachable(
                 "Interpreter error: Previous function define left dirty typecheck state.".into(),
             )
             .into());