Fix marker trait winnowing depending on impl order

The `TypeOutlives` handler in `evaluate_predicate_recursively` checks
whether a type in a `T: 'a` predicate has free regions, bound regions,
or inference variables -- and if so, returns
`EvaluatedToOkModuloRegions` rather than `EvaluatedToOk`.  The comment
says "no free lifetimes or generic parameters", but the code checked
`has_non_region_infer()` twice instead of checking
`has_non_region_param()` for the second condition.

This meant that `TypeOutlives(T, 'static)` where `T` is a type
parameter returned `EvaluatedToOk` -- claiming the result holds
unconditionally -- when the correct answer is
`EvaluatedToOkModuloRegions`.

The distinction matters during marker trait winnowing in
`prefer_lhs_over_victim`, which uses
`must_apply_considering_regions()` (true only for `EvaluatedToOk`) to
decide whether one overlapping impl beats another.  With the bug, a
`T: 'static`-bounded impl appeared equally strong as an unrestricted
impl, making the winner depend on source order.  This caused spurious
E0310 errors when the more-constrained impl happened to appear after
the less-constrained one.

Fixes Rust issue 109481.

This same symptom was originally filed as issue 84917 and fixed in PR
88139.  Then PR 102472 rewrote the `TypeOutlives` handler, introducing
the duplicate `has_non_region_infer()` and losing the param check,
regressing this.  Shortly after, issue 109481 was filed.  It noted the
connection to PR 102472 -- that it was only relevant after it -- but
apparently no one noticed the duplicate condition.

Author: traviscross

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -750,7 +750,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     if pred.0.has_free_regions()
                         || pred.0.has_bound_regions()
                         || pred.0.has_non_region_infer()
-                        || pred.0.has_non_region_infer()
+                        || pred.0.has_non_region_param()
                     {
                         Ok(EvaluatedToOkModuloRegions)
                     } else {

tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.rs

@@ -1,17 +1,19 @@
-//@ known-bug: #109481
+//@ check-pass
 //
-// While the `T: Copy` is always applicable when checking
-// that the impl `impl<T: Copy> F for T {}` is well formed,
-// the old trait solver can only approximate this by checking
-// that there are no inference variables in the obligation and
-// no region constraints in the evaluation result.
+// Regression test for #109481 and #84917.
 //
-// Because of this we end up with ambiguity here.
+// Overlapping marker trait impls where one has a `T: 'static` bound
+// should be accepted.  A bug previously made marker trait winnowing
+// order-dependent, producing a spurious E0310 here.
 #![feature(marker_trait_attr)]
 
 #[marker]
 pub trait F {}
 impl<T: Copy> F for T {}
 impl<T: 'static> F for T {}
+fn f<T: F>() {}
+fn g<T>() { f::<T>() }
 
-fn main() {}
+fn main() {
+    g::<()>();
+}