Implement a new wfcheck to replace the old wf; this new code only issues

warnings. It also checks more conditions than the old code.  Keep the
old wf code around unchanged so that we can continue to issue errors for
the cases where we used to report errors.

As part of this, remove the where-clauses-must-reference-parameter rule,
which is easily circumvented.

Author: nikomatsakis

src/librustc_typeck/check/method/confirm.rs

@@ -432,7 +432,9 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
             traits::ObligationCause::misc(self.span, self.fcx.body_id),
             method_predicates);
 
-        self.fcx.add_default_region_param_bounds(
+        // this is a projection from a trait reference, so we have to
+        // make sure that the trait reference inputs are well-formed.
+        self.fcx.add_wf_bounds(
             all_substs,
             self.call_expr);
     }

src/librustc_typeck/check/method/probe.rs

@@ -480,6 +480,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
                     ty::Predicate::Equate(..) |
                     ty::Predicate::Projection(..) |
                     ty::Predicate::RegionOutlives(..) |
+                    ty::Predicate::WellFormed(..) |
+                    ty::Predicate::ObjectSafe(..) |
                     ty::Predicate::TypeOutlives(..) => {
                         None
                     }

src/librustc_typeck/check/mod.rs

@@ -90,7 +90,7 @@ use middle::infer;
 use middle::infer::type_variable;
 use middle::pat_util::{self, pat_id_map};
 use middle::privacy::{AllPublic, LastMod};
-use middle::region::{self, CodeExtent};
+use middle::region::{self};
 use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace, TypeSpace};
 use middle::traits::{self, report_fulfillment_errors};
 use middle::ty::{FnSig, GenericPredicates, TypeScheme};
@@ -133,7 +133,8 @@ pub mod coercion;
 pub mod demand;
 pub mod method;
 mod upvar;
-pub mod wf;
+mod wf;
+mod wfcheck;
 mod cast;
 mod closure;
 mod callee;
@@ -382,25 +383,47 @@ impl<'a, 'tcx> Visitor<'tcx> for CheckItemBodiesVisitor<'a, 'tcx> {
     }
 }
 
-pub fn check_item_types(ccx: &CrateCtxt) {
+pub fn check_wf_old(ccx: &CrateCtxt) {
+    // FIXME(#25759). The new code below is much more reliable but (for now)
+    // only generates warnings. So as to ensure that we continue
+    // getting errors where we used to get errors, we run the old wf
+    // code first and abort if it encounters any errors. If no abort
+    // comes, we run the new code and issue warnings.
     let krate = ccx.tcx.map.krate();
     let mut visit = wf::CheckTypeWellFormedVisitor::new(ccx);
     visit::walk_crate(&mut visit, krate);
 
     // If types are not well-formed, it leads to all manner of errors
     // downstream, so stop reporting errors at this point.
     ccx.tcx.sess.abort_if_errors();
+}
 
-    let mut visit = CheckItemTypesVisitor { ccx: ccx };
+pub fn check_wf_new(ccx: &CrateCtxt) {
+    let krate = ccx.tcx.map.krate();
+    let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(ccx);
     visit::walk_crate(&mut visit, krate);
 
+    // If types are not well-formed, it leads to all manner of errors
+    // downstream, so stop reporting errors at this point.
     ccx.tcx.sess.abort_if_errors();
+}
 
+pub fn check_item_types(ccx: &CrateCtxt) {
+    let krate = ccx.tcx.map.krate();
+    let mut visit = CheckItemTypesVisitor { ccx: ccx };
+    visit::walk_crate(&mut visit, krate);
+    ccx.tcx.sess.abort_if_errors();
+}
+
+pub fn check_item_bodies(ccx: &CrateCtxt) {
+    let krate = ccx.tcx.map.krate();
     let mut visit = CheckItemBodiesVisitor { ccx: ccx };
     visit::walk_crate(&mut visit, krate);
 
     ccx.tcx.sess.abort_if_errors();
+}
 
+pub fn check_drop_impls(ccx: &CrateCtxt) {
     for drop_method_did in ccx.tcx.destructors.borrow().iter() {
         if drop_method_did.krate == ast::LOCAL_CRATE {
             let drop_impl_did = ccx.tcx.map.get_parent_did(drop_method_did.node);
@@ -586,7 +609,7 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
 
     if let ty::FnConverging(ret_ty) = ret_ty {
         fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::ReturnType);
-        fn_sig_tys.push(ret_ty);
+        fn_sig_tys.push(ret_ty); // FIXME(#25759) just take implied bounds from the arguments
     }
 
     debug!("fn-sig-map: fn_id={} fn_sig_tys={:?}",
@@ -600,6 +623,14 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
 
         // Add formal parameters.
         for (arg_ty, input) in arg_tys.iter().zip(&decl.inputs) {
+            // The type of the argument must be well-formed.
+            //
+            // NB -- this is now checked in wfcheck, but that
+            // currently only results in warnings, so we issue an
+            // old-style WF obligation here so that we still get the
+            // errors that we used to get.
+            fcx.register_old_wf_obligation(arg_ty, input.ty.span, traits::MiscObligation);
+
             // Create type variables for each argument.
             pat_util::pat_bindings(
                 &tcx.def_map,
@@ -1507,10 +1538,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub fn to_ty(&self, ast_t: &ast::Ty) -> Ty<'tcx> {
         let t = ast_ty_to_ty(self, self, ast_t);
 
-        let mut bounds_checker = wf::BoundsChecker::new(self,
-                                                        self.body_id,
-                                                        None);
-        bounds_checker.check_ty(t, ast_t.span);
+        // Generally speaking, we must check that types entered by the
+        // user are well-formed. This is not true for `_`, since those
+        // types are generated by inference. Now, you might think that
+        // we could as well generate a WF obligation -- but
+        // unfortunately that breaks code like `foo as *const _`,
+        // because those type variables wind up being unconstrained
+        // until very late. Nasty. Probably it'd be best to refactor
+        // that code path, but that's tricky because of
+        // defaults. Argh!
+        match ast_t.node {
+            ast::TyInfer => { }
+            _ => { self.register_wf_obligation(t, ast_t.span, traits::MiscObligation); }
+        }
 
         t
     }
@@ -1629,15 +1669,38 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         fulfillment_cx.register_region_obligation(ty, region, cause);
     }
 
-    pub fn add_default_region_param_bounds(&self,
-                                           substs: &Substs<'tcx>,
-                                           expr: &ast::Expr)
+    /// Registers an obligation for checking later, during regionck, that the type `ty` must
+    /// outlive the region `r`.
+    pub fn register_wf_obligation(&self,
+                                  ty: Ty<'tcx>,
+                                  span: Span,
+                                  code: traits::ObligationCauseCode<'tcx>)
+    {
+        // WF obligations never themselves fail, so no real need to give a detailed cause:
+        let cause = traits::ObligationCause::new(span, self.body_id, code);
+        self.register_predicate(traits::Obligation::new(cause, ty::Predicate::WellFormed(ty)));
+    }
+
+    pub fn register_old_wf_obligation(&self,
+                                      ty: Ty<'tcx>,
+                                      span: Span,
+                                      code: traits::ObligationCauseCode<'tcx>)
+    {
+        // Registers an "old-style" WF obligation that uses the
+        // implicator code.  This is basically a buggy version of
+        // `register_wf_obligation` that is being kept around
+        // temporarily just to help with phasing in the newer rules.
+        //
+        // FIXME(#27579) all uses of this should be migrated to register_wf_obligation eventually
+        let cause = traits::ObligationCause::new(span, self.body_id, code);
+        self.register_region_obligation(ty, ty::ReEmpty, cause);
+    }
+
+    /// Registers obligations that all types appearing in `substs` are well-formed.
+    pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &ast::Expr)
     {
         for &ty in &substs.types {
-            let default_bound = ty::ReScope(CodeExtent::from_node_id(expr.id));
-            let cause = traits::ObligationCause::new(expr.span, self.body_id,
-                                                     traits::MiscObligation);
-            self.register_region_obligation(ty, default_bound, cause);
+            self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
         }
     }
 
@@ -2477,7 +2540,8 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                     Expectation::rvalue_hint(fcx.tcx(), ty)
                 });
 
-                check_expr_with_unifier(fcx, &**arg,
+                check_expr_with_unifier(fcx,
+                                        &**arg,
                                         expected.unwrap_or(ExpectHasType(formal_ty)),
                                         NoPreference, || {
                     // 2. Coerce to the most detailed type that could be coerced
@@ -3362,7 +3426,9 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
 
           // We always require that the type provided as the value for
           // a type parameter outlives the moment of instantiation.
-          constrain_path_type_parameters(fcx, expr);
+          fcx.opt_node_ty_substs(expr.id, |item_substs| {
+              fcx.add_wf_bounds(&item_substs.substs, expr);
+          });
       }
       ast::ExprInlineAsm(ref ia) => {
           for &(_, ref input) in &ia.inputs {
@@ -3903,14 +3969,6 @@ pub fn resolve_ty_and_def_ufcs<'a, 'b, 'tcx>(fcx: &FnCtxt<'b, 'tcx>,
     }
 }
 
-fn constrain_path_type_parameters(fcx: &FnCtxt,
-                                  expr: &ast::Expr)
-{
-    fcx.opt_node_ty_substs(expr.id, |item_substs| {
-        fcx.add_default_region_param_bounds(&item_substs.substs, expr);
-    });
-}
-
 impl<'tcx> Expectation<'tcx> {
     /// Provide an expectation for an rvalue expression given an *optional*
     /// hint, which is not required for type safety (the resulting type might