Revert support for the never type partially

Author: lrh2000

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

@@ -626,17 +626,28 @@ class TypeCheckExpr : public TypeCheckBase
     auto else_blk_resolved
       = TypeCheckExpr::Resolve (expr.get_else_block (), inside_loop);
 
-    infered = if_blk_resolved->unify (else_blk_resolved);
+    if (if_blk_resolved->get_kind () == TyTy::NEVER)
+      infered = else_blk_resolved;
+    else if (else_blk_resolved->get_kind () == TyTy::NEVER)
+      infered = if_blk_resolved;
+    else
+      infered = if_blk_resolved->unify (else_blk_resolved);
   }
 
   void visit (HIR::IfExprConseqIf &expr) override
   {
     TypeCheckExpr::Resolve (expr.get_if_condition (), false);
-    auto if_blk = TypeCheckExpr::Resolve (expr.get_if_block (), inside_loop);
-    auto else_blk
+    auto if_blk_resolved
+      = TypeCheckExpr::Resolve (expr.get_if_block (), inside_loop);
+    auto else_blk_resolved
       = TypeCheckExpr::Resolve (expr.get_conseq_if_expr (), inside_loop);
 
-    infered = if_blk->unify (else_blk);
+    if (if_blk_resolved->get_kind () == TyTy::NEVER)
+      infered = else_blk_resolved;
+    else if (else_blk_resolved->get_kind () == TyTy::NEVER)
+      infered = if_blk_resolved;
+    else
+      infered = if_blk_resolved->unify (else_blk_resolved);
   }
 
   void visit (HIR::BlockExpr &expr) override;

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

@@ -82,7 +82,8 @@ class TypeCheckItem : public TypeCheckBase
 
     context->pop_return_type ();
 
-    expected_ret_tyty->unify (block_expr_ty);
+    if (block_expr_ty->get_kind () != TyTy::NEVER)
+      expected_ret_tyty->unify (block_expr_ty);
   }
 
 private:

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

@@ -43,7 +43,7 @@ class TypeCheckStmt : public TypeCheckBase
   {
     infered = TypeCheckExpr::Resolve (stmt.get_expr (), inside_loop);
 
-    if (stmt.is_unit_check_needed ())
+    if (stmt.is_unit_check_needed () && infered->get_kind () != TyTy::NEVER)
       {
 	auto unit = new TyTy::TupleType (stmt.get_mappings ().get_hirid ());
 	infered = unit->unify (infered);

gcc/rust/typecheck/rust-tyty-cmp.h

@@ -84,7 +84,7 @@ class BaseCmp : public TyVisitor
 
   virtual void visit (StrType &) override { ok = false; }
 
-  virtual void visit (NeverType &) override { ok = true; }
+  virtual void visit (NeverType &) override { ok = false; }
 
 protected:
   BaseCmp (BaseType *base)
@@ -815,40 +815,6 @@ class NeverCmp : public BaseCmp
 public:
   NeverCmp (NeverType *base) : BaseCmp (base), base (base) {}
 
-  void visit (TupleType &type) override { ok = true; }
-
-  void visit (ADTType &type) override { ok = true; }
-
-  void visit (InferType &type) override { ok = true; }
-
-  void visit (FnType &type) override { ok = true; }
-
-  void visit (FnPtr &type) override { ok = true; }
-
-  void visit (ArrayType &type) override { ok = true; }
-
-  void visit (BoolType &type) override { ok = true; }
-
-  void visit (IntType &type) override { ok = true; }
-
-  void visit (UintType &type) override { ok = true; }
-
-  void visit (USizeType &type) override { ok = true; }
-
-  void visit (ISizeType &type) override { ok = true; }
-
-  void visit (FloatType &type) override { ok = true; }
-
-  void visit (ErrorType &type) override { ok = true; }
-
-  void visit (CharType &type) override { ok = true; }
-
-  void visit (ReferenceType &type) override { ok = true; }
-
-  void visit (ParamType &type) override { ok = true; }
-
-  void visit (StrType &type) override { ok = true; }
-
   void visit (NeverType &type) override { ok = true; }
 
 private:

gcc/rust/typecheck/rust-tyty-rules.h

@@ -244,7 +244,10 @@ class BaseRules : public TyVisitor
 
   virtual void visit (NeverType &type) override
   {
-    resolved = get_base ()->clone ();
+    Location ref_locus = mappings->lookup_location (type.get_ref ());
+    rust_error_at (ref_locus, "expected [%s] got [%s]",
+		   get_base ()->as_string ().c_str (),
+		   type.as_string ().c_str ());
   }
 
 protected:
@@ -1099,43 +1102,6 @@ class NeverRules : public BaseRules
 public:
   NeverRules (NeverType *base) : BaseRules (base), base (base) {}
 
-  virtual void visit (TupleType &type) override { resolved = type.clone (); }
-
-  virtual void visit (ADTType &type) override { resolved = type.clone (); }
-
-  virtual void visit (InferType &type) override { resolved = type.clone (); }
-
-  virtual void visit (FnType &type) override { resolved = type.clone (); }
-
-  virtual void visit (FnPtr &type) override { resolved = type.clone (); }
-
-  virtual void visit (ArrayType &type) override { resolved = type.clone (); }
-
-  virtual void visit (BoolType &type) override { resolved = type.clone (); }
-
-  virtual void visit (IntType &type) override { resolved = type.clone (); }
-
-  virtual void visit (UintType &type) override { resolved = type.clone (); }
-
-  virtual void visit (USizeType &type) override { resolved = type.clone (); }
-
-  virtual void visit (ISizeType &type) override { resolved = type.clone (); }
-
-  virtual void visit (FloatType &type) override { resolved = type.clone (); }
-
-  virtual void visit (ErrorType &type) override { resolved = type.clone (); }
-
-  virtual void visit (CharType &type) override { resolved = type.clone (); }
-
-  virtual void visit (ReferenceType &type) override
-  {
-    resolved = type.clone ();
-  }
-
-  virtual void visit (ParamType &type) override { resolved = type.clone (); }
-
-  virtual void visit (StrType &type) override { resolved = type.clone (); }
-
   virtual void visit (NeverType &type) override { resolved = type.clone (); }
 
 private:

gcc/rust/typecheck/rust-tyty.h

@@ -1219,6 +1219,15 @@ class StrType : public BaseType
 };
 
 // https://doc.rust-lang.org/std/primitive.never.html
+//
+// Since the `!` type is really complicated and it is even still unstable
+// in rustc, only fairly limited support for this type is introduced here.
+// Unification between `!` and ANY other type (including `<T?>`) is simply
+// not allowed. If it is needed, it should be handled manually. For example,
+// unifying `!` with other types are very necessary when resolving types of
+// `if/else` expressions.
+//
+// See related discussion at https://github.com/Rust-GCC/gccrs/pull/364
 class NeverType : public BaseType
 {
 public:

gcc/testsuite/rust.test/compile/never_type1.rs

@@ -1,10 +1,18 @@
-fn test(x: i32) -> i32 {
+fn test1(x: i32) -> i32 {
     // { dg-error "expected .i32. got .bool." "" { target *-*-*} .-1 }
     return 1;
     // { dg-warning "unreachable expression" "" { target *-*-* } .+1 }
     true
 }
 
+fn test2(x: bool) -> bool {
+    // { dg-error "expected .bool. got ...." "" { target *-*-*} .-1 }
+    return x;
+    // { dg-warning "unreachable expression" "" { target *-*-* } .+1 }
+    ()
+}
+
 fn main() {
-    let a = test(1);
+    let a = test1(1);
+    let a = test2(true);
 }

gcc/testsuite/rust.test/xfail_compile/implicit_returns_err2.rs

@@ -0,0 +1,4 @@
+// FIXME: Unimplemented features
+fn foo() -> ! { // { dg-error "unresolved type" }
+    let a: !; // { dg-error "unresolved type" }
+}

gcc/testsuite/rust.test/xfail_compile/never_type_err2.rs

@@ -0,0 +1,61 @@
+fn foo() -> i32 {
+    let c;
+    let d;
+
+    c = if false {
+        return 1;
+    } else {
+        0.0
+    };
+
+    d = if true {
+        0.0;
+    } else {
+        return 1;
+    };
+
+    0
+}
+
+fn bar() -> i32 {
+    let a;
+    let b;
+
+    // FIXME: Unimplemented features
+    a = if true { // { dg-error "expected .T.. got .!." }
+    // { dg-error "type resolution failure in AssignmentExpr" "" { target { *-*-* } } .-1 }
+        return 0;
+    } else {
+        return 0;
+    };
+
+    // FIXME: Unimplemented features
+    b = return 0; // { dg-error "expected .T.. got .!." }
+    // { dg-error "type resolution failure in AssignmentExpr" "" { target { *-*-* } } .-1 }
+    // { dg-warning "unreachable statement" "" { target { *-*-* } } .-2 }
+}
+
+fn baz() -> i32 {
+    let mut x = (1.0, return 1, 2.0);
+
+    x.1 = return 2;
+    // { dg-warning "unreachable statement" "" { target { *-*-* } } .-1 }
+
+    x.1 = 3; // { dg-error "expected .!. got .<integer>." }
+    // { dg-error "type resolution failure in AssignmentExpr" "" { target { *-*-* } } .-1 }
+    // { dg-warning "unreachable statement" "" { target { *-*-* } } .-2 }
+
+    x.0 = -1.0;
+    // { dg-warning "unreachable statement" "" { target { *-*-* } } .-1 }
+
+    // FIXME: Unimplemented features
+    x.0 = return -1; // { dg-error "expected .<float>. got .!." }
+    // { dg-error "type resolution failure in AssignmentExpr" "" { target { *-*-* } } .-1 }
+    // { dg-warning "unreachable statement" "" { target { *-*-* } } .-2 }
+}
+
+fn main() {
+    foo();
+    bar();
+    baz();
+}