Merge branch 'aac-client-breaking' of https://github.com/stacks-network/stacks-core into chore/aac-rename-check-errors

Author: jferrant

.github/workflows/clippy.yml

@@ -13,6 +13,7 @@ on:
   pull_request:
     branches:
       - develop
+      - aac-client-breaking # temp branch for aac work
     types:
       - opened
       - reopened

clarity-types/src/types/mod.rs

@@ -562,10 +562,10 @@ impl SequenceData {
     pub fn concat(&mut self, epoch: &StacksEpochId, other_seq: SequenceData) -> Result<()> {
         match (self, other_seq) {
             (SequenceData::List(inner_data), SequenceData::List(other_inner_data)) => {
-                inner_data.append(epoch, other_inner_data)
+                inner_data.append(epoch, other_inner_data)?;
             }
             (SequenceData::Buffer(inner_data), SequenceData::Buffer(ref mut other_inner_data)) => {
-                inner_data.append(other_inner_data)
+                inner_data.append(other_inner_data);
             }
             (
                 SequenceData::String(CharType::ASCII(inner_data)),
@@ -575,8 +575,8 @@ impl SequenceData {
                 SequenceData::String(CharType::UTF8(inner_data)),
                 SequenceData::String(CharType::UTF8(ref mut other_inner_data)),
             ) => inner_data.append(other_inner_data),
-            _ => Err(RuntimeErrorType::BadTypeConstruction.into()),
-        }?;
+            _ => return Err(RuntimeErrorType::BadTypeConstruction.into()),
+        };
         Ok(())
     }
 
@@ -1242,9 +1242,8 @@ impl BuffData {
         self.data.as_slice()
     }
 
-    fn append(&mut self, other_seq: &mut BuffData) -> Result<()> {
+    fn append(&mut self, other_seq: &mut BuffData) {
         self.data.append(&mut other_seq.data);
-        Ok(())
     }
 
     pub fn empty() -> Self {
@@ -1281,9 +1280,8 @@ impl ListData {
 }
 
 impl ASCIIData {
-    fn append(&mut self, other_seq: &mut ASCIIData) -> Result<()> {
+    fn append(&mut self, other_seq: &mut ASCIIData) {
         self.data.append(&mut other_seq.data);
-        Ok(())
     }
 
     pub fn len(&self) -> Result<BufferLength> {
@@ -1295,9 +1293,8 @@ impl ASCIIData {
 }
 
 impl UTF8Data {
-    fn append(&mut self, other_seq: &mut UTF8Data) -> Result<()> {
+    fn append(&mut self, other_seq: &mut UTF8Data) {
         self.data.append(&mut other_seq.data);
-        Ok(())
     }
 
     pub fn len(&self) -> Result<BufferLength> {
@@ -1530,12 +1527,11 @@ impl TupleData {
     fn new(
         type_signature: TupleTypeSignature,
         data_map: BTreeMap<ClarityName, Value>,
-    ) -> Result<TupleData> {
-        let t = TupleData {
+    ) -> TupleData {
+        TupleData {
             type_signature,
             data_map,
-        };
-        Ok(t)
+        }
     }
 
     /// Return the number of fields in this tuple value
@@ -1565,7 +1561,7 @@ impl TupleData {
             data_map.insert(name, value);
         }
 
-        Self::new(TupleTypeSignature::try_from(type_map)?, data_map)
+        Ok(Self::new(TupleTypeSignature::try_from(type_map)?, data_map))
     }
 
     // TODO: add tests from mutation testing results #4834
@@ -1585,7 +1581,7 @@ impl TupleData {
             }
             data_map.insert(name, value);
         }
-        Self::new(expected.clone(), data_map)
+        Ok(Self::new(expected.clone(), data_map))
     }
 
     pub fn get(&self, name: &str) -> Result<&Value> {

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

@@ -173,12 +173,8 @@ impl ContractContext {
         Ok(())
     }
 
-    pub fn add_implemented_trait(
-        &mut self,
-        trait_identifier: TraitIdentifier,
-    ) -> Result<(), CheckError> {
+    pub fn add_implemented_trait(&mut self, trait_identifier: TraitIdentifier) {
         self.implemented_traits.insert(trait_identifier);
-        Ok(())
     }
 
     pub fn get_trait(&self, trait_name: &str) -> Option<&BTreeMap<ClarityName, FunctionSignature>> {

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

@@ -1014,7 +1014,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                 }
                 DefineFunctionsParsed::ImplTrait { trait_identifier } => {
                     self.contract_context
-                        .add_implemented_trait(trait_identifier.clone())?;
+                        .add_implemented_trait(trait_identifier.clone());
                 }
             };
             Ok(Some(()))

clarity/src/vm/analysis/type_checker/v2_1/contexts.rs

@@ -61,7 +61,7 @@ impl TraitContext {
         contract_identifier: QualifiedContractIdentifier,
         trait_name: ClarityName,
         trait_signature: BTreeMap<ClarityName, FunctionSignature>,
-    ) -> Result<(), CheckError> {
+    ) {
         match self {
             Self::Clarity1(map) => {
                 map.insert(trait_name, trait_signature);
@@ -77,15 +77,14 @@ impl TraitContext {
                 );
             }
         }
-        Ok(())
     }
 
     pub fn add_used_trait(
         &mut self,
         alias: ClarityName,
         trait_id: TraitIdentifier,
         trait_signature: BTreeMap<ClarityName, FunctionSignature>,
-    ) -> Result<(), CheckError> {
+    ) {
         match self {
             Self::Clarity1(map) => {
                 map.insert(trait_id.name, trait_signature);
@@ -95,7 +94,6 @@ impl TraitContext {
                 all.insert(trait_id, trait_signature);
             }
         }
-        Ok(())
     }
 
     pub fn get_trait(
@@ -295,7 +293,8 @@ impl ContractContext {
             self.contract_identifier.clone(),
             trait_name,
             trait_signature,
-        )
+        );
+        Ok(())
     }
 
     pub fn add_used_trait(
@@ -308,15 +307,12 @@ impl ContractContext {
             self.check_name_used(&alias)?;
         }
 
-        self.traits.add_used_trait(alias, trait_id, trait_signature)
+        self.traits.add_used_trait(alias, trait_id, trait_signature);
+        Ok(())
     }
 
-    pub fn add_implemented_trait(
-        &mut self,
-        trait_identifier: TraitIdentifier,
-    ) -> Result<(), CheckError> {
+    pub fn add_implemented_trait(&mut self, trait_identifier: TraitIdentifier) {
         self.implemented_traits.insert(trait_identifier);
-        Ok(())
     }
 
     pub fn get_trait(

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

@@ -1897,7 +1897,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                         self.add_memory(trait_identifier.name.len().into())?;
                     }
                     self.contract_context
-                        .add_implemented_trait(trait_identifier.clone())?;
+                        .add_implemented_trait(trait_identifier.clone());
                 }
             };
             Ok(Some(()))

clarity/src/vm/ast/definition_sorter/mod.rs

@@ -87,7 +87,7 @@ impl DefinitionSorter {
         )?;
 
         let mut walker = GraphWalker::new();
-        let sorted_indexes = walker.get_sorted_dependencies(&self.graph)?;
+        let sorted_indexes = walker.get_sorted_dependencies(&self.graph);
 
         if let Some(deps) = walker.get_cycling_dependencies(&self.graph, &sorted_indexes) {
             let functions_names = deps
@@ -461,13 +461,12 @@ impl GraphWalker {
     }
 
     /// Depth-first search producing a post-order sort
-    fn get_sorted_dependencies(&mut self, graph: &Graph) -> ParseResult<Vec<usize>> {
+    fn get_sorted_dependencies(&mut self, graph: &Graph) -> Vec<usize> {
         let mut sorted_indexes = Vec::<usize>::new();
         for expr_index in 0..graph.nodes_count() {
             self.sort_dependencies_recursion(expr_index, graph, &mut sorted_indexes);
         }
-
-        Ok(sorted_indexes)
+        sorted_indexes
     }
 
     fn sort_dependencies_recursion(

clarity/src/vm/functions/define.rs

@@ -263,18 +263,12 @@ fn handle_define_trait(
     Ok(DefineResult::Trait(name.clone(), trait_signature))
 }
 
-fn handle_use_trait(
-    name: &ClarityName,
-    trait_identifier: &TraitIdentifier,
-) -> Result<DefineResult> {
-    Ok(DefineResult::UseTrait(
-        name.clone(),
-        trait_identifier.clone(),
-    ))
+fn handle_use_trait(name: &ClarityName, trait_identifier: &TraitIdentifier) -> DefineResult {
+    DefineResult::UseTrait(name.clone(), trait_identifier.clone())
 }
 
-fn handle_impl_trait(trait_identifier: &TraitIdentifier) -> Result<DefineResult> {
-    Ok(DefineResult::ImplTrait(trait_identifier.clone()))
+fn handle_impl_trait(trait_identifier: &TraitIdentifier) -> DefineResult {
+    DefineResult::ImplTrait(trait_identifier.clone())
 }
 
 impl DefineFunctions {
@@ -454,9 +448,9 @@ pub fn evaluate_define(
             DefineFunctionsParsed::UseTrait {
                 name,
                 trait_identifier,
-            } => handle_use_trait(name, trait_identifier),
+            } => Ok(handle_use_trait(name, trait_identifier)),
             DefineFunctionsParsed::ImplTrait { trait_identifier } => {
-                handle_impl_trait(trait_identifier)
+                Ok(handle_impl_trait(trait_identifier))
             }
         }
     } else {

stacks-common/src/bitvec.rs

@@ -141,7 +141,7 @@ impl<const MAX_SIZE: u16> Iterator for BitVecIter<'_, MAX_SIZE> {
         self.index = self.index.saturating_add(1);
         if self.index < self.bitvec.len {
             // check if byte needs to be incremented
-            if self.index % 8 == 0 {
+            if self.index.is_multiple_of(8) {
                 let vec_index = usize::from(self.index / 8);
                 self.byte = self.bitvec.data.get(vec_index);
             }
@@ -190,7 +190,7 @@ impl<const MAX_SIZE: u16> BitVec<MAX_SIZE> {
 
     /// Return the number of bytes needed to store `len` bits.
     fn data_len(len: u16) -> u16 {
-        len / 8 + if len % 8 == 0 { 0 } else { 1 }
+        len / 8 + if len.is_multiple_of(8) { 0 } else { 1 }
     }
 
     /// Get a u8 with the (index % 8)th bit set to 1.

stacks-common/src/deps_common/ctrlc/tests.rs

@@ -52,7 +52,7 @@ mod platform {
         Cached(Vec<u8>),
     }
 
-    static mut OLD_OUT: *mut Output = 0 as *mut Output;
+    static mut OLD_OUT: *mut Output = ptr::null_mut();
 
     impl io::Write for Output {
         fn write(&mut self, buf: &[u8]) -> io::Result<usize> {