Allow early fallback of diverging type variables in typeck

Previously, we issue "type annotations needed" when types
must be known at some point but the resolution failed,
even if the type variables are just some diverging ones.
A typical example is `{ return }.foo()`.

With this commit, the information about diverging is recorded
in the unification table, so that we can check whether
performing the fallback affects other non-diverging type
variables. If it doesn't, we will safely perform the fallback
and we won't issue "type annotations needed" anymore.

Note lots of auxiliary type variables should be ignored during
the check, which is done with the help of `TypeVariableOriginKind`.

As a result, "type annotations needed" will be issued for
```rust
let a = return;
{ if true { a } else { return } }.foo();
```
but not for
```rust
let a: ! = return;
{ if true { a } else { return } }.foo();
```

Author: lrh2000

compiler/rustc_infer/src/infer/mod.rs

@@ -1275,6 +1275,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         }
     }
 
+    /// Returns `false` if all non-auxiliary type variables unified with
+    /// `vid` is diverging. Returns `true` otherwise.
+    pub fn probe_ty_diverging(&self, vid: TyVid) -> bool {
+        let mut inner = self.inner.borrow_mut();
+        inner.type_variables().var_diverges_with_unification(vid)
+    }
+
     /// Resolve any type variables found in `value` -- but only one
     /// level.  So, if the variable `?X` is bound to some type
     /// `Foo<?Y>`, then this would return `Foo<?Y>` (but `?Y` may

compiler/rustc_infer/src/infer/type_variable.rs

@@ -16,7 +16,7 @@ use rustc_data_structures::undo_log::{Rollback, UndoLogs};
 /// Represents a single undo-able action that affects a type inference variable.
 pub(crate) enum UndoLog<'tcx> {
     EqRelation(sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>),
-    SubRelation(sv::UndoLog<ut::Delegate<ty::TyVid>>),
+    SubRelation(sv::UndoLog<ut::Delegate<TyVidSubKey>>),
     Values(sv::UndoLog<Delegate>),
 }
 
@@ -28,8 +28,8 @@ impl<'tcx> From<sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>> for UndoLog<'tcx> {
 }
 
 /// Convert from a specific kind of undo to the more general UndoLog
-impl<'tcx> From<sv::UndoLog<ut::Delegate<ty::TyVid>>> for UndoLog<'tcx> {
-    fn from(l: sv::UndoLog<ut::Delegate<ty::TyVid>>) -> Self {
+impl<'tcx> From<sv::UndoLog<ut::Delegate<TyVidSubKey>>> for UndoLog<'tcx> {
+    fn from(l: sv::UndoLog<ut::Delegate<TyVidSubKey>>) -> Self {
         UndoLog::SubRelation(l)
     }
 }
@@ -83,7 +83,7 @@ pub struct TypeVariableStorage<'tcx> {
     /// This is reasonable because, in Rust, subtypes have the same
     /// "skeleton" and hence there is no possible type such that
     /// (e.g.)  `Box<?3> <: ?3` for any `?3`.
-    sub_relations: ut::UnificationTableStorage<ty::TyVid>,
+    sub_relations: ut::UnificationTableStorage<TyVidSubKey>,
 }
 
 pub struct TypeVariableTable<'a, 'tcx> {
@@ -169,6 +169,16 @@ impl<'tcx> TypeVariableStorage<'tcx> {
 }
 
 impl<'tcx> TypeVariableTable<'_, 'tcx> {
+    /// Returns `false` if all non-auxiliary type variables unified with
+    /// `vid` is diverging. Returns `true` otherwise.
+    ///
+    /// Precondition: `vid` should be unknown.
+    pub fn var_diverges_with_unification(&mut self, vid: ty::TyVid) -> bool {
+        debug_assert!(self.probe(vid).is_unknown());
+        let kind = self.sub_relations().inlined_probe_value(vid);
+        matches!(kind, TyVarUnifiedDiverging::Yes)
+    }
+
     /// Returns the diverges flag given when `vid` was created.
     ///
     /// Note that this function does not return care whether
@@ -243,8 +253,9 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     ) -> ty::TyVid {
         let eq_key = self.eq_relations().new_key(TypeVariableValue::Unknown { universe });
 
-        let sub_key = self.sub_relations().new_key(());
-        assert_eq!(eq_key.vid, sub_key);
+        let diverging_kind = TyVarUnifiedDiverging::from(diverging, origin.kind);
+        let sub_key = self.sub_relations().new_key(diverging_kind);
+        assert_eq!(eq_key.vid, sub_key.vid);
 
         let index = self.values().push(TypeVariableData { origin, diverging });
         assert_eq!(eq_key.vid.index, index as u32);
@@ -279,7 +290,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     ///
     ///     exists X. (a <: X || X <: a) && (b <: X || X <: b)
     pub fn sub_root_var(&mut self, vid: ty::TyVid) -> ty::TyVid {
-        self.sub_relations().find(vid)
+        self.sub_relations().find(vid).vid
     }
 
     /// Returns `true` if `a` and `b` have same "sub-root" (i.e., exists some
@@ -326,7 +337,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     }
 
     #[inline]
-    fn sub_relations(&mut self) -> super::UnificationTable<'_, 'tcx, ty::TyVid> {
+    fn sub_relations(&mut self) -> super::UnificationTable<'_, 'tcx, TyVidSubKey> {
         self.storage.sub_relations.with_log(self.undo_log)
     }
 
@@ -443,3 +454,84 @@ impl<'tcx> ut::UnifyValue for TypeVariableValue<'tcx> {
         }
     }
 }
+
+///////////////////////////////////////////////////////////////////////////
+
+/// These structs (a newtyped TyVid) are used as the unification key
+/// for the `sub_relations`; they carry a `TyVarUnifiedDiverging`
+/// along with them.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) struct TyVidSubKey {
+    vid: ty::TyVid,
+}
+
+/// This enum denotes whether unified type variables are all diverging
+/// variables. Note auxiliary type variables (guessed with the help of
+/// `TypeVariableOriginKind`) should be ignored.
+#[derive(Copy, Clone, Debug)]
+pub enum TyVarUnifiedDiverging {
+    /// All unified type variables are diverging.
+    Yes,
+    /// Some unified type variable are not diverging.
+    No,
+    /// We don't know the final result at all because we haven't seen
+    /// any non-auxiliary type variables yet.
+    Maybe,
+}
+
+impl From<ty::TyVid> for TyVidSubKey {
+    fn from(vid: ty::TyVid) -> Self {
+        TyVidSubKey { vid }
+    }
+}
+
+impl ut::UnifyKey for TyVidSubKey {
+    type Value = TyVarUnifiedDiverging;
+    fn index(&self) -> u32 {
+        self.vid.index
+    }
+    fn from_index(i: u32) -> Self {
+        TyVidSubKey::from(ty::TyVid { index: i })
+    }
+    fn tag() -> &'static str {
+        "TyVidSubKey"
+    }
+}
+
+impl ut::UnifyValue for TyVarUnifiedDiverging {
+    type Error = ut::NoError;
+
+    fn unify_values(value1: &Self, value2: &Self) -> Result<Self, ut::NoError> {
+        match (*value1, *value2) {
+            // Auxiliary type variables should be ignored.
+            (TyVarUnifiedDiverging::Maybe, other) => Ok(other),
+            (other, TyVarUnifiedDiverging::Maybe) => Ok(other),
+
+            // We've found some non-diverging type variables.
+            (TyVarUnifiedDiverging::No, _) => Ok(TyVarUnifiedDiverging::No),
+            (_, TyVarUnifiedDiverging::No) => Ok(TyVarUnifiedDiverging::No),
+
+            // All type variables are diverging yet.
+            (TyVarUnifiedDiverging::Yes, TyVarUnifiedDiverging::Yes) => {
+                Ok(TyVarUnifiedDiverging::Yes)
+            }
+        }
+    }
+}
+
+impl TyVarUnifiedDiverging {
+    #[inline]
+    fn from(diverging: bool, origin: TypeVariableOriginKind) -> Self {
+        if diverging {
+            return TyVarUnifiedDiverging::Yes;
+        }
+
+        // FIXME: Is it a complete list? Probably not.
+        match origin {
+            TypeVariableOriginKind::MiscVariable | TypeVariableOriginKind::LatticeVariable => {
+                TyVarUnifiedDiverging::Maybe
+            }
+            _ => TyVarUnifiedDiverging::No,
+        }
+    }
+}

compiler/rustc_infer/src/infer/undo_log.rs

@@ -45,7 +45,7 @@ impl_from! {
     TypeVariables(type_variable::UndoLog<'tcx>),
 
     TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'tcx>>>),
-    TypeVariables(sv::UndoLog<ut::Delegate<ty::TyVid>>),
+    TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidSubKey>>),
     TypeVariables(sv::UndoLog<type_variable::Delegate>),
     TypeVariables(type_variable::Instantiate),
 

compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

@@ -1567,17 +1567,44 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// Numeric inference variables may be left unresolved.
     pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
         let ty = self.resolve_vars_with_obligations(ty);
-        if !ty.is_ty_var() {
-            ty
+        if let ty::Infer(ty::TyVar(vid)) = ty.kind() {
+            // If we get a type variable here, we may not want to issue "type
+            // annotations needed". For example, the code can be something like
+            // `panic!().foo()` or `{ return }.foo()`.
+            //
+            // However, we must issue the error message if we found the type
+            // variable is related to some non-auxiliary non-diverging ones.
+            //
+            // We'll issue the error message for this
+            // ```
+            // let a = return;
+            // { if true { a } else { return } }.foo();
+            // ```
+            // but we won't for this
+            // ```
+            // let a: ! = return;
+            // { if true { a } else { return } }.foo();
+            // ```
+
+            let new_ty = if self.infcx.probe_ty_diverging(*vid) {
+                if self.tcx.features().never_type_fallback {
+                    self.tcx.types.never
+                } else {
+                    self.tcx.types.unit
+                }
+            } else {
+                if !self.is_tainted_by_errors() {
+                    self.emit_inference_failure_err((**self).body_id, sp, ty.into(), vec![], E0282)
+                        .note("type must be known at this point")
+                        .emit();
+                }
+                self.tcx.ty_error()
+            };
+
+            self.demand_suptype(sp, new_ty, ty);
+            new_ty
         } else {
-            if !self.is_tainted_by_errors() {
-                self.emit_inference_failure_err((**self).body_id, sp, ty.into(), vec![], E0282)
-                    .note("type must be known at this point")
-                    .emit();
-            }
-            let err = self.tcx.ty_error();
-            self.demand_suptype(sp, err, ty);
-            err
+            ty
         }
     }
 

src/test/ui/asm/type-check-2.rs

@@ -1,6 +1,6 @@
 // only-x86_64
 
-#![feature(asm, global_asm, repr_simd, never_type)]
+#![feature(asm, global_asm, repr_simd, never_type, never_type_fallback)]
 
 #[repr(simd)]
 struct SimdNonCopy(f32, f32, f32, f32);
@@ -86,9 +86,8 @@ fn main() {
 
         // Type checks ignore never type
 
-        // FIXME: ERROR type annotations needed
-        // let u: ! = unreachable!();
-        // asm!("{}", in(reg) u);
+        let u: ! = unreachable!();
+        asm!("{}", in(reg) u);
     }
 }
 

src/test/ui/index-bot.rs

@@ -1,3 +1,3 @@
 fn main() {
-    (return)[0]; //~ ERROR type annotations needed
+    (return)[0]; //~ ERROR cannot index into a value of type `()`
 }

src/test/ui/index-bot.stderr

@@ -1,11 +1,9 @@
-error[E0282]: type annotations needed
+error[E0608]: cannot index into a value of type `()`
   --> $DIR/index-bot.rs:2:5
    |
 LL |     (return)[0];
-   |     ^^^^^^^^ cannot infer type
-   |
-   = note: type must be known at this point
+   |     ^^^^^^^^^^^ help: to access tuple elements, use: `(return).0`
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0608`.

src/test/ui/issues/issue-13847.rs

@@ -1,3 +1,3 @@
 fn main() {
-    return.is_failure //~ ERROR type annotations needed
+    return.is_failure //~ ERROR no field `is_failure` on type `()`
 }

src/test/ui/issues/issue-13847.stderr

@@ -1,11 +1,9 @@
-error[E0282]: type annotations needed
-  --> $DIR/issue-13847.rs:2:5
+error[E0609]: no field `is_failure` on type `()`
+  --> $DIR/issue-13847.rs:2:12
    |
 LL |     return.is_failure
-   |     ^^^^^^ cannot infer type
-   |
-   = note: type must be known at this point
+   |            ^^^^^^^^^^
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0609`.

src/test/ui/issues/issue-15207.rs

@@ -1,6 +1,6 @@
 fn main() {
     loop {
-        break.push(1) //~ ERROR type annotations needed
+        break.push(1) //~ ERROR no method named `push` found for unit type `()`
         ;
     }
 }