Merge #839

839: Add typechecking for match-expr r=philberty a=philberty

This adds in the type checking pass for the match expression including static
analysis for errors such as:

 - error[E0532]: expected tuple struct or tuple variant, found struct variant `Foo::D`
 - error[E0027]: pattern does not mention fields `x`, `y`
 - error[E0026]: variant `Foo::D` does not have a field named `b`
 - error[E0532]: expected tuple struct or tuple variant, found struct variant `Foo::D`

Addresses #190 

Co-authored-by: Philip Herron <[email protected]>

Author: bors[bot]

gcc/rust/Make-lang.in

@@ -89,6 +89,7 @@ GRS_OBJS = \
     rust/rust-hir-type-check-type.o \
     rust/rust-hir-type-check-struct.o \
     rust/rust-hir-address-taken.o \
+    rust/rust-hir-type-check-pattern.o \
     rust/rust-substitution-mapper.o \
     rust/rust-lint-marklive.o \
     rust/rust-hir-type-check-path.o \

gcc/rust/hir/tree/rust-hir-expr.h

@@ -3614,15 +3614,9 @@ struct MatchArm
 {
 private:
   AST::AttrVec outer_attrs;
-  // MatchArmPatterns patterns;
-  std::vector<std::unique_ptr<Pattern> > match_arm_patterns; // inlined
-
-  // bool has_match_arm_guard;
-  // inlined from MatchArmGuard
+  std::vector<std::unique_ptr<Pattern> > match_arm_patterns;
   std::unique_ptr<Expr> guard_expr;
 
-  // TODO: should this store location data?
-
 public:
   // Returns whether the MatchArm has a match arm guard expression
   bool has_match_arm_guard () const { return guard_expr != nullptr; }
@@ -3679,6 +3673,11 @@ struct MatchArm
   }
 
   std::string as_string () const;
+
+  std::vector<std::unique_ptr<Pattern> > &get_patterns ()
+  {
+    return match_arm_patterns;
+  }
 };
 
 /* A "match case" - a correlated match arm and resulting expression. Not
@@ -3718,6 +3717,9 @@ struct MatchCase
   std::string as_string () const;
 
   Analysis::NodeMapping get_mappings () const { return mappings; }
+
+  MatchArm &get_arm () { return arm; }
+  std::unique_ptr<Expr> &get_expr () { return expr; }
 };
 
 #if 0
@@ -3868,6 +3870,15 @@ class MatchExpr : public ExprWithBlock
 
   void accept_vis (HIRVisitor &vis) override;
 
+  std::unique_ptr<Expr> &get_scrutinee_expr ()
+  {
+    rust_assert (branch_value != nullptr);
+    return branch_value;
+  }
+
+  const std::vector<MatchCase> &get_match_cases () const { return match_arms; }
+  std::vector<MatchCase> &get_match_cases () { return match_arms; }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */

gcc/rust/resolve/rust-ast-resolve-pattern.cc

@@ -49,7 +49,7 @@ PatternDeclaration::visit (AST::TupleStructPattern &pattern)
 	for (auto &inner_pattern : items_no_range.get_patterns ())
 	  {
 	    PatternDeclaration::go (inner_pattern.get (),
-				    pattern.get_node_id ());
+				    inner_pattern->get_pattern_node_id ());
 	  }
       }
       break;
@@ -85,10 +85,10 @@ PatternDeclaration::visit (AST::StructPattern &pattern)
 	    resolver->get_name_scope ().insert (
 	      CanonicalPath::new_seg (ident.get_node_id (),
 				      ident.get_identifier ()),
-	      ident.get_node_id (), pattern.get_locus ());
-	    resolver->insert_new_definition (
-	      ident.get_node_id (),
-	      Definition{ident.get_node_id (), pattern.get_node_id ()});
+	      ident.get_node_id (), ident.get_locus ());
+	    resolver->insert_new_definition (ident.get_node_id (),
+					     Definition{ident.get_node_id (),
+							ident.get_node_id ()});
 	    resolver->mark_decl_mutability (ident.get_node_id (),
 					    ident.is_mut ());
 	  }

gcc/rust/typecheck/rust-hir-type-check-expr.h

@@ -32,6 +32,7 @@
 #include "rust-hir-type-bounds.h"
 #include "rust-hir-dot-operator.h"
 #include "rust-hir-address-taken.h"
+#include "rust-hir-type-check-pattern.h"
 
 namespace Rust {
 namespace Resolver {
@@ -51,6 +52,9 @@ class TypeCheckExpr : public TypeCheckBase
 
     if (resolver.infered == nullptr)
       {
+	// FIXME
+	// this is an internal error message for debugging and should be removed
+	// at some point
 	rust_error_at (expr->get_locus (), "failed to type resolve expression");
 	return new TyTy::ErrorType (expr->get_mappings ().get_hirid ());
       }
@@ -540,6 +544,8 @@ class TypeCheckExpr : public TypeCheckBase
 	Definition def;
 	if (!resolver->lookup_definition (ref_node_id, &def))
 	  {
+	    // FIXME
+	    // this is an internal error
 	    rust_error_at (expr.get_locus (),
 			   "unknown reference for resolved name");
 	    return;
@@ -548,6 +554,8 @@ class TypeCheckExpr : public TypeCheckBase
       }
     else if (!resolver->lookup_resolved_type (ast_node_id, &ref_node_id))
       {
+	// FIXME
+	// this is an internal error
 	rust_error_at (expr.get_locus (),
 		       "Failed to lookup type reference for node: %s",
 		       expr.as_string ().c_str ());
@@ -556,6 +564,8 @@ class TypeCheckExpr : public TypeCheckBase
 
     if (ref_node_id == UNKNOWN_NODEID)
       {
+	// FIXME
+	// this is an internal error
 	rust_error_at (expr.get_locus (), "unresolved node: %s",
 		       expr.as_string ().c_str ());
 	return;
@@ -566,6 +576,8 @@ class TypeCheckExpr : public TypeCheckBase
     if (!mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (),
 				       ref_node_id, &ref))
       {
+	// FIXME
+	// this is an internal error
 	rust_error_at (expr.get_locus (), "123 reverse lookup failure");
 	return;
       }
@@ -574,6 +586,8 @@ class TypeCheckExpr : public TypeCheckBase
     TyTy::BaseType *lookup;
     if (!context->lookup_type (ref, &lookup))
       {
+	// FIXME
+	// this is an internal error
 	rust_error_at (mappings->lookup_location (ref),
 		       "Failed to resolve IdentifierExpr type: %s",
 		       expr.as_string ().c_str ());
@@ -1265,6 +1279,50 @@ class TypeCheckExpr : public TypeCheckBase
     infered = expr_to_convert->cast (tyty_to_convert_to);
   }
 
+  void visit (HIR::MatchExpr &expr) override
+  {
+    // this needs to perform a least upper bound coercion on the blocks and then
+    // unify the scruintee and arms
+    TyTy::BaseType *scrutinee_tyty
+      = TypeCheckExpr::Resolve (expr.get_scrutinee_expr ().get (), false);
+
+    std::vector<TyTy::BaseType *> kase_block_tys;
+    for (auto &kase : expr.get_match_cases ())
+      {
+	// lets check the arms
+	HIR::MatchArm &kase_arm = kase.get_arm ();
+	for (auto &pattern : kase_arm.get_patterns ())
+	  {
+	    TyTy::BaseType *kase_arm_ty
+	      = TypeCheckPattern::Resolve (pattern.get ());
+
+	    TyTy::BaseType *checked_kase = scrutinee_tyty->unify (kase_arm_ty);
+	    if (checked_kase->get_kind () == TyTy::TypeKind::ERROR)
+	      return;
+	  }
+
+	// check the kase type
+	TyTy::BaseType *kase_block_ty
+	  = TypeCheckExpr::Resolve (kase.get_expr ().get (), false);
+	kase_block_tys.push_back (kase_block_ty);
+      }
+
+    if (kase_block_tys.size () == 0)
+      {
+	infered = new TyTy::TupleType (expr.get_mappings ().get_hirid ());
+	return;
+      }
+
+    infered = kase_block_tys.at (0);
+    for (size_t i = 1; i < kase_block_tys.size (); i++)
+      {
+	TyTy::BaseType *kase_ty = kase_block_tys.at (i);
+	infered = infered->unify (kase_ty);
+	if (infered->get_kind () == TyTy::TypeKind::ERROR)
+	  return;
+      }
+  }
+
 protected:
   bool
   resolve_operator_overload (Analysis::RustLangItem::ItemType lang_item_type,