comment

third_party/move/move-compiler-v2/tests/ability-check/index_ability_err_2.exp

@@ -1,6 +1,6 @@
 
 Diagnostics:
-error: resource indexing can only applied to a resource type
+error: resource indexing can only applied to a resource type (a struct type which has key ability)
   ┌─ tests/ability-check/index_ability_err_2.move:9:17
   │
 9 │         let _ = X<bool>[addr];

third_party/move/move-compiler-v2/tests/checking/typing/index_err.exp

@@ -1,12 +1,12 @@
 
 Diagnostics:
-error: indexing is only allowed for resource or vector
+error: indexing can only be applied to a vector or a resource type (a struct type which has key ability)
    ┌─ tests/checking/typing/index_err.move:14:9
    │
 14 │         UNUSED_Test[@0x1];
    │         ^^^^^^^^^^^^^^^^^
 
-error: indexing is only allowed for resource or vector
+error: indexing can only be applied to a vector or a resource type (a struct type which has key ability)
    ┌─ tests/checking/typing/index_err.move:19:9
    │
 19 │         &test::UNUSED_Test[@0x1];

third_party/move/move-compiler/src/expansion/ast.rs

@@ -488,7 +488,7 @@ pub enum Exp_ {
 
     Borrow(bool, Box<Exp>),
     ExpDotted(Box<ExpDotted>),
-    Index(Box<Exp>, Box<Exp>), // spec only for language version V1
+    Index(Box<Exp>, Box<Exp>), // spec only unless language >= v2
 
     Cast(Box<Exp>, Type),
     Annotate(Box<Exp>, Type),

third_party/move/move-model/src/builder/exp_builder.rs

@@ -25,6 +25,7 @@ use crate::{
         ReceiverFunctionInstance, ReferenceKind, Substitution, Type, TypeDisplayContext,
         TypeUnificationError, UnificationContext, Variance, WideningOrder, BOOL_TYPE,
     },
+    FunId,
 };
 use codespan_reporting::diagnostic::Severity;
 use itertools::Itertools;
@@ -3312,6 +3313,27 @@ impl<'env, 'translator, 'module_translator> ExpTranslator<'env, 'translator, 'mo
         }
     }
 
+    //TODO: make a Lazy const for mid and fid of vector functions
+    fn get_vector_borrow(&self, mutable: bool) -> (Option<ModuleId>, Option<FunId>) {
+        let target_str = if mutable {
+            "vector::borrow_mut"
+        } else {
+            "vector::borrow"
+        };
+        for m in self.env().get_modules() {
+            if m.is_std_vector() {
+                let mid = m.get_id();
+                for f in m.get_functions() {
+                    if f.get_full_name_str() == target_str {
+                        let fid = f.get_id();
+                        return (Some(mid), Some(fid));
+                    }
+                }
+            }
+        }
+        (None, None)
+    }
+
     fn call_to_vector_borrow_for_index_op(
         &mut self,
         loc: &Loc,
@@ -3343,35 +3365,21 @@ impl<'env, 'translator, 'module_translator> ExpTranslator<'env, 'translator, 'mo
         if self.had_errors {
             return self.new_error_exp();
         }
-        let target_str = if mutable {
-            "vector::borrow_mut"
-        } else {
-            "vector::borrow"
-        };
-        // TODO: comment out because of #13888
-        for m in self.env().get_modules() {
-            if m.is_std_vector() {
-                let mid = m.get_id();
-                for f in m.get_functions() {
-                    if f.get_full_name_str() == target_str {
-                        let fid = f.get_id();
-                        let instantiated_inner = self.subs.specialize(&inner_ty);
-                        let node_id = self.env().new_node(
-                            loc.clone(),
-                            Type::Reference(
-                                ReferenceKind::from_is_mut(mutable),
-                                Box::new(instantiated_inner.clone()),
-                            ),
-                        );
-                        self.set_node_instantiation(node_id, vec![inner_ty.clone()]);
-                        let call = ExpData::Call(node_id, Operation::MoveFunction(mid, fid), vec![
-                            vec_exp_e.into_exp(),
-                            idx_exp_e.clone().into_exp(),
-                        ]);
-                        return call;
-                    }
-                }
-            }
+        if let (Some(mid), Some(fid)) = self.get_vector_borrow(mutable) {
+            let instantiated_inner = self.subs.specialize(&inner_ty);
+            let node_id = self.env().new_node(
+                loc.clone(),
+                Type::Reference(
+                    ReferenceKind::from_is_mut(mutable),
+                    Box::new(instantiated_inner.clone()),
+                ),
+            );
+            self.set_node_instantiation(node_id, vec![inner_ty.clone()]);
+            let call = ExpData::Call(node_id, Operation::MoveFunction(mid, fid), vec![
+                vec_exp_e.into_exp(),
+                idx_exp_e.clone().into_exp(),
+            ]);
+            return call;
         }
         ExpData::Invalid(self.env().new_node_id())
     }
@@ -3413,7 +3421,7 @@ impl<'env, 'translator, 'module_translator> ExpTranslator<'env, 'translator, 'mo
                         loc, target, index, mutable, ty, context,
                     ));
                 } else {
-                    self.error(loc, "resource indexing can only applied to a resource type");
+                    self.error(loc, "resource indexing can only applied to a resource type (a struct type which has key ability)");
                     call = Some(self.new_error_exp());
                 }
             } else if self
@@ -3426,7 +3434,7 @@ impl<'env, 'translator, 'module_translator> ExpTranslator<'env, 'translator, 'mo
                     .language_version
                     .is_at_least(LanguageVersion::V2_0)
             {
-                self.error(loc, "indexing is only allowed for resource or vector");
+                self.error(loc, "indexing can only be applied to a vector or a resource type (a struct type which has key ability)");
                 call = Some(self.new_error_exp());
             }
         }