Implemented runtime remove and insert functions for dynamic arrays in move and added runtime test

Author: jessicalally

src/moveir/call.rs

@@ -5,6 +5,7 @@ use super::ir::{MoveIRExpression, MoveIRFunctionCall};
 use crate::ast::calls::FunctionArgument;
 use crate::ast::{Expression, ExternalCall, FunctionCall, Identifier};
 use crate::environment::{CallableInformation, FunctionCallMatchResult};
+use crate::moveir::MovePosition;
 
 pub(crate) struct MoveExternalCall {
     pub external_call: ExternalCall,

src/moveir/identifier.rs

@@ -61,13 +61,14 @@ impl MoveIdentifier {
         if let Some(identifier_type) = function_context
             .scope_context
             .type_for(&self.identifier.token)
-        {
+        { 
             if identifier_type.is_currency_type(&libra::currency()) && f_call {
                 return MoveIRExpression::Transfer(MoveIRTransfer::Move(Box::from(ir_identifier)));
             }
             if identifier_type.is_currency_type(&libra::currency()) {
                 return ir_identifier;
             }
+
             if identifier_type.is_inout_type() && identifier_type.is_user_defined_type() {
                 if f_call {
                     return MoveIRExpression::Transfer(MoveIRTransfer::Move(Box::from(

src/moveir/preprocessor/mod.rs

@@ -956,6 +956,14 @@ impl Visitor for MovePreProcessor {
                     MovePreProcessor::CALLER_PROTECTIONS_PARAM,
                 ));
             }
+
+           if call.identifier.token.eq("Flint_array_remove") {
+                // TODO: change to element type
+                call.identifier.token = "Flint_array_remove<u64>".to_string();
+            } else if call.identifier.token.eq("Flint_array_insert") {
+                call.identifier.token = "Flint_array_insert<u64>".to_string();
+            }
+
             return Ok(());
         }
 
@@ -1229,7 +1237,7 @@ impl Visitor for MovePreProcessor {
     ) -> VResult {
         let mut borrow_local = false;
         let function_argument = _t.clone();
-        let mut expression;
+        let mut expression = function_argument.expression.clone();
         if let Expression::InoutExpression(i) = function_argument.expression.clone() {
             expression = *i.expression;
 
@@ -1250,6 +1258,11 @@ impl Visitor for MovePreProcessor {
                         &scope,
                     );
 
+                    if let Type::ArrayType(_) = expression_type {
+                        _t.expression = expression;
+                        return Ok(());
+                    }
+
                     if !expression_type.is_currency_type(&_ctx.target.currency)
                         && !expression_type.is_external_resource(_ctx.environment.clone())
                     {
@@ -1284,6 +1297,7 @@ impl Visitor for MovePreProcessor {
         }
 
         _t.expression = expression;
+        dbg!(_t.clone());
         Ok(())
     }
 

src/moveir/preprocessor/utils.rs

@@ -642,6 +642,8 @@ pub fn pre_assign(
             }
         };
 
+        dbg!(declaration.clone());
+        dbg!(expression.clone());
         if struct_is_mutable_reference(&mut expression, &temp_identifier, ctx) {
             ctx.pre_statements
                 .push(Statement::Expression(Expression::BinaryExpression(

src/moveir/runtime_function.rs

@@ -88,6 +88,34 @@ impl MoveRuntimeFunction {
 
             return;
         }
+
+        public Flint_array_remove<S: copyable>(nums: &mut vector<S>, i: u64) {
+            let result: S;
+            result = Vector.remove<S>(move(nums), move(i));
+            _ = move(result);
+            return;
+        }
+
+        public Flint_array_length<S: copyable>(nums: vector<S>): u64 {
+            let length: u64;
+            length = Vector.length<S>(&nums);
+            return move(length); 
+        }
+          
+        public Flint_array_insert<S: copyable>(nums: &mut vector<S>, i: u64, value: S) {
+            let length: u64;
+            let index: u64;
+            index = move(i);
+            Vector.push_back<S>(copy(nums), copy(value));
+            length = Self.Flint_array_length<S>(*copy(nums));
+            
+            while(copy(index) < copy(length) - 1) {
+                Vector.swap<S>(copy(nums), copy(index), copy(length) - 1);
+                index = copy(index) + 1;
+            }
+            
+            return;
+        }
         "
         .to_string()
     }

tests/behaviour_tests/dynamic_arrays.flint

@@ -0,0 +1,23 @@
+contract DynamicArrays {
+  var nums: [Int] = [1, 2, 3]
+}
+
+DynamicArrays :: (any) {
+  public init() {}
+
+  public func get(x: Int) -> Int {
+    return nums[x]
+  }
+
+  public func set(i: Int, val: Int) mutates(nums) {
+    nums[i] = val
+  }
+
+  public func insert(i: Int, val: Int) mutates(nums) {
+      Flint_array_insert(&nums, i, val)
+  }
+
+  public func remove(i: Int) mutates(nums) {
+      Flint_array_remove(&nums, i)
+  }
+}

tests/behaviour_tests/move_tests/dynamic_arrays.mvir

@@ -0,0 +1,22 @@
+import {{default}}.DynamicArrays;
+import 0x1.Signer;
+
+main(account: &signer) {
+    DynamicArrays.publish(copy(account));
+    assert(DynamicArrays.get(Signer.address_of(copy(account)), 0, copy(account)) == 1, 1);
+    assert(DynamicArrays.get(Signer.address_of(copy(account)), 1, copy(account)) == 2, 2);
+    assert(DynamicArrays.get(Signer.address_of(copy(account)), 2, copy(account)) == 3, 3);
+
+    DynamicArrays.remove(Signer.address_of(copy(account)), 0, copy(account));
+
+    assert(DynamicArrays.get(Signer.address_of(copy(account)), 0, copy(account)) == 2, 4);
+    assert(DynamicArrays.get(Signer.address_of(copy(account)), 1, copy(account)) == 3, 5);
+
+    DynamicArrays.insert(Signer.address_of(copy(account)), 0, 5, copy(account));
+
+    assert(DynamicArrays.get(Signer.address_of(copy(account)), 0, copy(account)) == 5, 6);
+    assert(DynamicArrays.get(Signer.address_of(copy(account)), 1, copy(account)) == 2, 6);
+    assert(DynamicArrays.get(Signer.address_of(copy(account)), 2, copy(account)) == 3, 6);
+    
+    return;
+}