fix had_erros

Author: rahxephon89

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

@@ -42,6 +42,18 @@ error: unable to infer type: `M::G0<?4>`
 26 │         G0{} != G0{};
    │         ^^^^
 
+error: unable to infer type: `M::G1<?10>`
+   ┌─ tests/checking/typing/neq_invalid.move:27:9
+   │
+27 │         G1{} != G1{};
+   │         ^^^^
+
+error: unable to infer type: `M::G2<?16>`
+   ┌─ tests/checking/typing/neq_invalid.move:28:9
+   │
+28 │         G2{} != G2{};
+   │         ^^^^
+
 error: invalid call of `!=`: tuples have different arity (3 != 2) for argument 2
    ┌─ tests/checking/typing/neq_invalid.move:34:22
    │

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

@@ -5,3 +5,15 @@ error: invalid type instantiation `(u64, u64)`: only structs, vectors, and primi
   │
 5 │         Box { f: (0, 1) };
   │         ^^^^^^^^^^^^^^^^^
+
+error: invalid type instantiation `(u64, u64, u64)`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/pack_multiple.move:6:9
+  │
+6 │         Box { f: (0, 1, 2) };
+  │         ^^^^^^^^^^^^^^^^^^^^
+
+error: invalid type instantiation `(bool, M::Box<u64>)`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/pack_multiple.move:7:9
+  │
+7 │         Box { f: (true, Box { f: 0 }) };
+  │         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

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

@@ -5,3 +5,9 @@ error: invalid type instantiation `&u64`: only structs, vectors, and primitive t
   │
 5 │         Box { f: r_imm };
   │         ^^^^^^^^^^^^^^^^
+
+error: invalid type instantiation `&mut u64`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/pack_reference.move:6:9
+  │
+6 │         Box { f: r_mut };
+  │         ^^^^^^^^^^^^^^^^

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

@@ -1,7 +1,49 @@
 
 Diagnostics:
+error: invalid type instantiation `&u64`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type.move:4:13
+  │
+4 │         let v = vector<&u64>[];
+  │             ^
+
 error: invalid type instantiation `&u64`: only structs, vectors, and primitive types allowed
   ┌─ tests/checking/typing/vector_with_non_base_type.move:4:17
   │
 4 │         let v = vector<&u64>[];
   │                 ^^^^^^
+
+error: invalid type instantiation `&mut u64`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type.move:5:13
+  │
+5 │         let v = vector<&mut u64>[];
+  │             ^
+
+error: invalid type instantiation `&mut u64`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type.move:5:17
+  │
+5 │         let v = vector<&mut u64>[];
+  │                 ^^^^^^
+
+error: invalid type instantiation `()`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type.move:6:13
+  │
+6 │         let v = vector<()>[];
+  │             ^
+
+error: invalid type instantiation `()`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type.move:6:17
+  │
+6 │         let v = vector<()>[];
+  │                 ^^^^^^
+
+error: invalid type instantiation `(u64, bool)`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type.move:7:13
+  │
+7 │         let v = vector<(u64, bool)>[];
+  │             ^
+
+error: invalid type instantiation `(u64, bool)`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type.move:7:17
+  │
+7 │         let v = vector<(u64, bool)>[];
+  │                 ^^^^^^

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

@@ -5,3 +5,33 @@ error: invalid type instantiation `&u64`: only structs, vectors, and primitive t
   │
 4 │         vector[&0];
   │         ^^^^^^
+
+error: invalid type instantiation `&mut u64`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type_inferred.move:5:9
+  │
+5 │         vector[&mut 0];
+  │         ^^^^^^
+
+error: invalid type instantiation `()`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type_inferred.move:6:9
+  │
+6 │         vector[()];
+  │         ^^^^^^
+
+error: invalid type instantiation `(u64, bool)`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type_inferred.move:7:9
+  │
+7 │         vector[(0, false)];
+  │         ^^^^^^
+
+error: invalid type instantiation `&u64`: only structs, vectors, and primitive types allowed
+  ┌─ tests/checking/typing/vector_with_non_base_type_inferred.move:9:9
+  │
+9 │         vector[&0, &mut 0];
+  │         ^^^^^^
+
+error: invalid type instantiation `&u64`: only structs, vectors, and primitive types allowed
+   ┌─ tests/checking/typing/vector_with_non_base_type_inferred.move:10:9
+   │
+10 │         vector[&mut 0, &0];
+   │         ^^^^^^

third_party/move/move-compiler-v2/tests/checking/typing/vector_with_non_base_type_2.move

@@ -348,19 +348,21 @@ impl<'env, 'translator, 'module_translator> ExpTranslator<'env, 'translator, 'mo
     /// Finalizes types in this translator, producing errors if some could not be inferred
     /// and remained incomplete.
     pub fn finalize_types(&mut self) {
-        for i in self.node_counter_start..self.parent.parent.env.next_free_node_number() {
-            let node_id = NodeId::new(i);
+        if !self.had_errors {
+            for i in self.node_counter_start..self.parent.parent.env.next_free_node_number() {
+                let node_id = NodeId::new(i);
 
-            if let Some(ty) = self.get_node_type_opt(node_id) {
-                let ty = self.finalize_type(node_id, &ty);
-                self.update_node_type(node_id, ty);
-            }
-            if let Some(inst) = self.get_node_instantiation_opt(node_id) {
-                let inst = inst
-                    .iter()
-                    .map(|ty| self.finalize_type(node_id, ty))
-                    .collect_vec();
-                self.update_node_instantiation(node_id, inst);
+                if let Some(ty) = self.get_node_type_opt(node_id) {
+                    let ty = self.finalize_type(node_id, &ty);
+                    self.update_node_type(node_id, ty);
+                }
+                if let Some(inst) = self.get_node_instantiation_opt(node_id) {
+                    let inst = inst
+                        .iter()
+                        .map(|ty| self.finalize_type(node_id, ty))
+                        .collect_vec();
+                    self.update_node_instantiation(node_id, inst);
+                }
             }
         }
     }
@@ -369,39 +371,36 @@ impl<'env, 'translator, 'module_translator> ExpTranslator<'env, 'translator, 'mo
     /// invalid type instantiations are found.
     fn finalize_type(&mut self, node_id: NodeId, ty: &Type) -> Type {
         let ty = self.subs.specialize_with_defaults(ty);
-        // Report error only if there are no other errors in this builder,
-        // to avoid noisy followup errors.
-        if !self.had_errors {
-            let loc = self.parent.parent.env.get_node_loc(node_id);
-            let mut incomplete = false;
-            let mut visitor = |t: &Type| {
-                use Type::*;
-                match t {
-                    Var(_) => {
-                        incomplete = true;
-                    },
-                    Struct(_, _, inst) => {
-                        for i in inst {
-                            self.check_valid_instantiation(&loc, i)
-                        }
-                    },
-                    Vector(t) => self.check_valid_instantiation(&loc, t),
-                    _ => {},
-                }
-            };
-            ty.visit(&mut visitor);
-
-            if incomplete {
-                // This type could not be fully inferred.
-                self.error(
-                    &loc,
-                    &format!(
-                        "unable to infer type: `{}`",
-                        ty.display(&self.type_display_context())
-                    ),
-                );
+        let loc = self.parent.parent.env.get_node_loc(node_id);
+        let mut visitor = |t: &Type| {
+            use Type::*;
+            match t {
+                Var(_) => {
+                    self.error(
+                        &loc,
+                        &format!(
+                            "unable to infer type: `{}`",
+                            ty.display(&self.type_display_context())
+                        ),
+                    );
+                    let _ = self.subs.unify(
+                        &self.unification_context,
+                        self.type_variance(),
+                        WideningOrder::RightToLeft,
+                        t,
+                        &Error,
+                    );
+                },
+                Struct(_, _, inst) => {
+                    for i in inst {
+                        self.check_valid_instantiation(&loc, i)
+                    }
+                },
+                Vector(t) => self.check_valid_instantiation(&loc, t),
+                _ => {},
             }
-        }
+        };
+        ty.visit(&mut visitor);
         ty
     }