Fixed a few small bugs.

Author: ibabushkin

src/semcheck/traverse.rs

@@ -801,6 +801,9 @@ fn cmp_types<'a, 'tcx>(changes: &mut ChangeSet<'tcx>,
             compcx.check_type_error(tcx, target_def_id, target_param_env, orig, target)
         {
             changes.add_change(TypeChanged { error: err }, orig_def_id, None);
+
+            // bail out after a type error
+            return;
         }
 
         compcx.check_bounds_bidirectional(changes,
@@ -944,6 +947,9 @@ fn match_inherent_impl<'a, 'tcx>(changes: &mut ChangeSet<'tcx>,
 
         if let Some(err) = error {
             changes.add_change(TypeChanged { error: err }, orig_item_def_id, None);
+
+            // bail out after a type error
+            return true;
         }
 
         compcx.check_bounds_bidirectional(changes,

src/semcheck/typeck.rs

@@ -205,6 +205,10 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
         -> Option<Vec<Predicate<'tcx2>>>
     {
         use rustc::ty::Lift;
+        debug!("check_bounds_error: orig env: {:?}, target did: {:?}, target substs: {:?}",
+               orig_param_env,
+               target_def_id,
+               target_substs);
 
         let mut bound_cx = BoundContext::new(self.infcx, orig_param_env);
         bound_cx.register(target_def_id, target_substs);

tests/cases/infer_regress/new.rs

@@ -0,0 +1,3 @@
+pub fn abc<A>(_: A) { }
+
+pub struct Abc<A>(A, ());

tests/cases/infer_regress/old.rs

@@ -0,0 +1,5 @@
+pub fn abc<A>(a: A) -> A {
+    a
+}
+
+pub struct Abc<A>(A, A);

tests/cases/infer_regress/stdout

@@ -0,0 +1,17 @@
+version bump: 1.0.0 -> (breaking) -> 2.0.0
+warning: breaking changes in `abc`
+ --> $REPO_PATH/tests/cases/infer_regress/new.rs:1:1
+  |
+1 | pub fn abc<A>(_: A) { }
+  | ^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = warning: type error: expected type parameter, found () (breaking)
+
+warning: breaking changes in `Abc`
+ --> $REPO_PATH/tests/cases/infer_regress/new.rs:3:1
+  |
+3 | pub struct Abc<A>(A, ());
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = warning: type error: expected type parameter, found () (breaking)
+

tests/dump

@@ -0,0 +1,28 @@
+<eddyb> we can't use the trait system for inherent impls
+    you have to basically have a (DefId, AssociatedKind, hir::Name) => Vec</*impl*/ DefId> map
+    and manually do what the trait system does for trait impls
+    namely, generate fresh infer vars for the impl you want to match *against*, substitute that
+    in its type_of (which is its Self) and then eq the type you want to check against that
+    if it didn't error, the substs containing infer vars which you substituted in type_of are
+    the params of the impl which you can then substitute in the associated items' signature
+    sooo example
+    old: impl Foo<u8> { fn foo() {} }
+    new: impl<T> Foo<T> { fn foo() {} }
+    (Foo, Method, "foo") => the one foo method in each
+    or rather
+    (old::Foo, Method, "foo") => old::...::foo
+    (new::Foo, Method, "foo") => new::...::foo
+    checking if old::...::foo is still valid means translating its "owner" (old::Foo), then
+    pairing it with the fact that it's a Method and its name, to get (new::Foo, Method, "foo")
+    which means for each in [new::...::foo] (well it's one element but you get the idea)
+    you generate fresh substs. in this case T => $1
+    substitute, so you get new::Foo<$1>
+    match that against translate(old::Foo<u8>), i.e. new::Foo<u8>
+    that will succeed and leave $1 equal to u8
+    which means your substs are now T => u8
+    oh I should've given it a signature. image it's -> u8 in old and -> T in new
+    so the signature of the new method, substituted, is still -> u8
+    and when you compare them that will succeed
+    but if the new method were -> Option<T> then for T => u8 it'd be -> Option<u8> which is wrong
+    and you'd notice the mismatch
+    it's not that hard as long as you keep your code modular

tests/examples.rs

@@ -103,6 +103,7 @@ test!(bounds, "tests/cases/bounds");
 test!(enums, "tests/cases/enums");
 test!(func, "tests/cases/func");
 test!(infer, "tests/cases/infer");
+test!(infer_regress, "tests/cases/infer_regress");
 test!(inherent_impls, "tests/cases/inherent_impls");
 test!(kind_change, "tests/cases/kind_change");
 test!(macros, "tests/cases/macros");