Merge branch 'next' into feat/4354-aggregate-key

clarity/src/vm/analysis/mod.rs

@@ -117,7 +117,7 @@ pub fn type_check(
 
 pub fn run_analysis(
     contract_identifier: &QualifiedContractIdentifier,
-    expressions: &mut [SymbolicExpression],
+    expressions: &[SymbolicExpression],
     analysis_db: &mut AnalysisDatabase,
     save_contract: bool,
     cost_tracker: LimitedCostTracker,

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

@@ -168,7 +168,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> {
         body: &SymbolicExpression,
     ) -> CheckResult<(ClarityName, bool)> {
         let function_name = signature
-            .get(0)
+            .first()
             .ok_or(CheckErrors::DefineFunctionBadSignature)?
             .match_atom()
             .ok_or(CheckErrors::BadFunctionName)?;

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

@@ -49,7 +49,7 @@ impl TraitChecker {
 
     pub fn run(
         &mut self,
-        contract_analysis: &mut ContractAnalysis,
+        contract_analysis: &ContractAnalysis,
         analysis_db: &mut AnalysisDatabase,
     ) -> CheckResult<()> {
         for trait_identifier in &contract_analysis.implemented_traits {

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

@@ -394,7 +394,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         }
     }
 
-    pub fn run(&mut self, contract_analysis: &mut ContractAnalysis) -> CheckResult<()> {
+    pub fn run(&mut self, contract_analysis: &ContractAnalysis) -> CheckResult<()> {
         // charge for the eventual storage cost of the analysis --
         //  it is linear in the size of the AST.
         let mut size: u64 = 0;
@@ -562,7 +562,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         let function_name = function_name
             .match_atom()
             .ok_or(CheckErrors::BadFunctionName)?;
-        let mut args = parse_name_type_pairs::<()>(StacksEpochId::Epoch2_05, args, &mut ())
+        let args = parse_name_type_pairs::<()>(StacksEpochId::Epoch2_05, args, &mut ())
             .map_err(|_| CheckErrors::BadSyntaxBinding)?;
 
         if self.function_return_tracker.is_some() {
@@ -618,7 +618,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                 self.function_return_tracker = None;
 
                 let func_args: Vec<FunctionArg> = args
-                    .drain(..)
+                    .into_iter()
                     .map(|(arg_name, arg_type)| FunctionArg::new(arg_type, arg_name))
                     .collect();
 

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

@@ -320,10 +320,10 @@ fn check_special_equals(
 ) -> TypeResult {
     check_arguments_at_least(1, args)?;
 
-    let mut arg_types = checker.type_check_all(args, context)?;
+    let arg_types = checker.type_check_all(args, context)?;
 
     let mut arg_type = arg_types[0].clone();
-    for x_type in arg_types.drain(..) {
+    for x_type in arg_types.into_iter() {
         analysis_typecheck_cost(checker, &x_type, &arg_type)?;
         arg_type = TypeSignature::least_supertype(&StacksEpochId::Epoch2_05, &x_type, &arg_type)
             .map_err(|_| CheckErrors::TypeError(x_type, arg_type))?;

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

@@ -932,7 +932,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         }
     }
 
-    pub fn run(&mut self, contract_analysis: &mut ContractAnalysis) -> CheckResult<()> {
+    pub fn run(&mut self, contract_analysis: &ContractAnalysis) -> CheckResult<()> {
         // charge for the eventual storage cost of the analysis --
         //  it is linear in the size of the AST.
         let mut size: u64 = 0;
@@ -1066,7 +1066,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         let function_name = function_name
             .match_atom()
             .ok_or(CheckErrors::BadFunctionName)?;
-        let mut args = parse_name_type_pairs::<()>(StacksEpochId::Epoch21, args, &mut ())
+        let args = parse_name_type_pairs::<()>(StacksEpochId::Epoch21, args, &mut ())
             .map_err(|_| CheckErrors::BadSyntaxBinding)?;
 
         if self.function_return_tracker.is_some() {
@@ -1123,7 +1123,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                 self.function_return_tracker = None;
 
                 let func_args: Vec<FunctionArg> = args
-                    .drain(..)
+                    .into_iter()
                     .map(|(arg_name, arg_type)| FunctionArg::new(arg_type, arg_name))
                     .collect();
 

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

@@ -325,10 +325,10 @@ fn check_special_equals(
 ) -> TypeResult {
     check_arguments_at_least(1, args)?;
 
-    let mut arg_types = checker.type_check_all(args, context)?;
+    let arg_types = checker.type_check_all(args, context)?;
 
     let mut arg_type = arg_types[0].clone();
-    for x_type in arg_types.drain(..) {
+    for x_type in arg_types.into_iter() {
         analysis_typecheck_cost(checker, &x_type, &arg_type)?;
         arg_type = TypeSignature::least_supertype(&StacksEpochId::Epoch21, &x_type, &arg_type)
             .map_err(|_| CheckErrors::TypeError(x_type, arg_type))?;

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

@@ -1690,8 +1690,8 @@ fn test_replace_at_buff() {
         CheckErrors::IncorrectArgumentCount(3, 4),
         CheckErrors::IncorrectArgumentCount(3, 2),
         CheckErrors::TypeError(
-            SequenceType(BufferType(buff_len.clone())),
-            SequenceType(BufferType(buff_len_two.clone())),
+            SequenceType(BufferType(buff_len)),
+            SequenceType(BufferType(buff_len_two)),
         ),
     ];
     for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) {
@@ -1746,8 +1746,8 @@ fn test_replace_at_ascii() {
         CheckErrors::IncorrectArgumentCount(3, 4),
         CheckErrors::IncorrectArgumentCount(3, 2),
         CheckErrors::TypeError(
-            SequenceType(StringType(ASCII(buff_len.clone()))),
-            SequenceType(StringType(ASCII(buff_len_two.clone()))),
+            SequenceType(StringType(ASCII(buff_len))),
+            SequenceType(StringType(ASCII(buff_len_two))),
         ),
     ];
     for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) {
@@ -1796,14 +1796,14 @@ fn test_replace_at_utf8() {
         ),
         CheckErrors::TypeError(
             SequenceType(StringType(UTF8(str_len.clone()))),
-            SequenceType(BufferType(buff_len.clone())),
+            SequenceType(BufferType(buff_len)),
         ),
         CheckErrors::TypeError(UIntType, IntType),
         CheckErrors::IncorrectArgumentCount(3, 4),
         CheckErrors::IncorrectArgumentCount(3, 2),
         CheckErrors::TypeError(
-            SequenceType(StringType(UTF8(str_len.clone()))),
-            SequenceType(StringType(UTF8(str_len_two.clone()))),
+            SequenceType(StringType(UTF8(str_len))),
+            SequenceType(StringType(UTF8(str_len_two))),
         ),
     ];
     for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) {
@@ -3399,7 +3399,7 @@ fn test_trait_args() {
         },
         TraitIdentifier {
             name: ClarityName::from("trait-bar"),
-            contract_identifier: contract_identifier.clone(),
+            contract_identifier: contract_identifier,
         },
     )];
 

clarity/src/vm/analysis/types.rs

@@ -367,7 +367,7 @@ mod test {
         {
             assert_eq!(
                 fixed.args[1].signature,
-                TypeSignature::CallableType(CallableSubtype::Trait(trait_id.clone()))
+                TypeSignature::CallableType(CallableSubtype::Trait(trait_id))
             );
         } else {
             panic!("Expected fixed function type");

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

@@ -385,8 +385,8 @@ impl DefinitionSorter {
             DefineFunctions::lookup_by_name(function_name)?;
             Some(args)
         }?;
-        let defined_name = match args.get(0)?.match_list() {
-            Some(list) => list.get(0)?,
+        let defined_name = match args.first()?.match_list() {
+            Some(list) => list.first()?,
             _ => &args[0],
         };
         let tle_name = defined_name.match_atom()?;

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

@@ -38,7 +38,7 @@ fn test_clarity_versions_definition_sorter(#[case] version: ClarityVersion) {}
 fn run_scoped_parsing_helper(contract: &str, version: ClarityVersion) -> ParseResult<ContractAST> {
     let contract_identifier = QualifiedContractIdentifier::transient();
     let pre_expressions = parser::v1::parse(contract)?;
-    let mut contract_ast = ContractAST::new(contract_identifier.clone(), pre_expressions);
+    let mut contract_ast = ContractAST::new(contract_identifier, pre_expressions);
     ExpressionIdentifier::run_pre_expression_pass(&mut contract_ast, version)?;
     DefinitionSorter::run_pass(&mut contract_ast, &mut (), version)?;
     Ok(contract_ast)

clarity/src/vm/ast/parser/v1.rs

@@ -509,12 +509,12 @@ fn handle_expression(
     }
 }
 
-pub fn parse_lexed(mut input: Vec<(LexItem, u32, u32)>) -> ParseResult<Vec<PreSymbolicExpression>> {
+pub fn parse_lexed(input: Vec<(LexItem, u32, u32)>) -> ParseResult<Vec<PreSymbolicExpression>> {
     let mut parse_stack = Vec::new();
 
     let mut output_list = Vec::new();
 
-    for (item, line_pos, column_pos) in input.drain(..) {
+    for (item, line_pos, column_pos) in input.into_iter() {
         match item {
             LexItem::LeftParen => {
                 // start new list.

clarity/src/vm/ast/parser/v2/mod.rs

@@ -262,7 +262,7 @@ impl<'a> Parser<'a> {
                             // Report an error, then skip this token
                             self.add_diagnostic(
                                 ParseErrors::UnexpectedToken(token.token.clone()),
-                                token.span.clone(),
+                                token.span,
                             )?;
                             *whitespace = self.ignore_whitespace();
                             Ok(None)
@@ -376,7 +376,7 @@ impl<'a> Parser<'a> {
                                 // This indicates we have reached the end of the input.
                                 // Create a placeholder value so that parsing can continue,
                                 // then return.
-                                let eof_span = last_token.span.clone();
+                                let eof_span = last_token.span;
 
                                 self.add_diagnostic(
                                     ParseErrors::TupleValueExpected,
@@ -428,9 +428,7 @@ impl<'a> Parser<'a> {
                         return Ok(Some(e));
                     }
                     Token::Eof => (),
-                    _ => {
-                        self.add_diagnostic(ParseErrors::TupleCommaExpectedv2, token.span.clone())?
-                    }
+                    _ => self.add_diagnostic(ParseErrors::TupleCommaExpectedv2, token.span)?,
                 }
 
                 let mut comments = self.ignore_whitespace_and_comments();
@@ -463,7 +461,7 @@ impl<'a> Parser<'a> {
     fn open_tuple(&mut self, lbrace: PlacedToken) -> ParseResult<SetupTupleResult> {
         let mut open_tuple = OpenTuple {
             nodes: vec![],
-            span: lbrace.span.clone(),
+            span: lbrace.span,
             expects: OpenTupleStatus::ParseKey,
             diagnostic_token: self.peek_next_token(),
         };
@@ -474,10 +472,7 @@ impl<'a> Parser<'a> {
         let token = self.peek_next_token();
         match token.token {
             Token::Comma => {
-                self.add_diagnostic(
-                    ParseErrors::UnexpectedToken(token.token),
-                    token.span.clone(),
-                )?;
+                self.add_diagnostic(ParseErrors::UnexpectedToken(token.token), token.span)?;
                 self.next_token();
             }
             Token::Rbrace => {
@@ -548,10 +543,7 @@ impl<'a> Parser<'a> {
                 }) => {
                     span.end_line = token_span.end_line;
                     span.end_column = token_span.end_column;
-                    self.add_diagnostic(
-                        ParseErrors::ExpectedContractIdentifier,
-                        token_span.clone(),
-                    )?;
+                    self.add_diagnostic(ParseErrors::ExpectedContractIdentifier, token_span)?;
                     let mut placeholder = PreSymbolicExpression::placeholder(format!(
                         "'{}.{}",
                         principal,
@@ -561,7 +553,7 @@ impl<'a> Parser<'a> {
                     return Ok(placeholder);
                 }
                 None => {
-                    self.add_diagnostic(ParseErrors::ExpectedContractIdentifier, dot.span.clone())?;
+                    self.add_diagnostic(ParseErrors::ExpectedContractIdentifier, dot.span)?;
                     let mut placeholder =
                         PreSymbolicExpression::placeholder(format!("'{}.", principal));
                     placeholder.copy_span(&span);
@@ -572,7 +564,7 @@ impl<'a> Parser<'a> {
             if name.len() > MAX_CONTRACT_NAME_LEN {
                 self.add_diagnostic(
                     ParseErrors::ContractNameTooLong(name.clone()),
-                    contract_span.clone(),
+                    contract_span,
                 )?;
                 let mut placeholder =
                     PreSymbolicExpression::placeholder(format!("'{}.{}", principal, name));
@@ -584,7 +576,7 @@ impl<'a> Parser<'a> {
                 Err(_) => {
                     self.add_diagnostic(
                         ParseErrors::IllegalContractName(name.clone()),
-                        contract_span.clone(),
+                        contract_span,
                     )?;
                     let mut placeholder =
                         PreSymbolicExpression::placeholder(format!("'{}.{}", principal, name));
@@ -639,10 +631,7 @@ impl<'a> Parser<'a> {
                     }
                 };
                 if name.len() > MAX_STRING_LEN {
-                    self.add_diagnostic(
-                        ParseErrors::NameTooLong(name.clone()),
-                        trait_span.clone(),
-                    )?;
+                    self.add_diagnostic(ParseErrors::NameTooLong(name.clone()), trait_span)?;
                     let mut placeholder =
                         PreSymbolicExpression::placeholder(format!("'{}.{}", contract_id, name,));
                     placeholder.copy_span(&span);
@@ -653,7 +642,7 @@ impl<'a> Parser<'a> {
                     Err(_) => {
                         self.add_diagnostic(
                             ParseErrors::IllegalTraitName(name.clone()),
-                            trait_span.clone(),
+                            trait_span,
                         )?;
                         let mut placeholder = PreSymbolicExpression::placeholder(format!(
                             "'{}.{}",
@@ -728,7 +717,7 @@ impl<'a> Parser<'a> {
             Err(_) => {
                 self.add_diagnostic(
                     ParseErrors::IllegalContractName(name.clone()),
-                    contract_span.clone(),
+                    contract_span,
                 )?;
                 let mut placeholder = PreSymbolicExpression::placeholder(format!(".{}", name));
                 placeholder.copy_span(&span);
@@ -775,7 +764,7 @@ impl<'a> Parser<'a> {
                 }
             };
             if name.len() > MAX_STRING_LEN {
-                self.add_diagnostic(ParseErrors::NameTooLong(name.clone()), trait_span.clone())?;
+                self.add_diagnostic(ParseErrors::NameTooLong(name.clone()), trait_span)?;
                 let mut placeholder =
                     PreSymbolicExpression::placeholder(format!(".{}.{}", contract_name, name));
                 placeholder.copy_span(&span);
@@ -784,10 +773,7 @@ impl<'a> Parser<'a> {
             let trait_name = match ClarityName::try_from(name.clone()) {
                 Ok(id) => id,
                 Err(_) => {
-                    self.add_diagnostic(
-                        ParseErrors::IllegalTraitName(name.clone()),
-                        trait_span.clone(),
-                    )?;
+                    self.add_diagnostic(ParseErrors::IllegalTraitName(name.clone()), trait_span)?;
                     let mut placeholder =
                         PreSymbolicExpression::placeholder(format!(".{}.{}", contract_name, name));
                     placeholder.copy_span(&span);