Allow T::C syntax in match patterns to refer to trait-assosociated constants.

Author: quantheory

src/librustc_resolve/lib.rs

@@ -2519,15 +2519,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                 // If anything ends up here entirely resolved,
                                 // it's an error. If anything ends up here
                                 // partially resolved, that's OK, because it may
-                                // be a `T::CONST` that typeck will resolve to
-                                // an inherent impl.
+                                // be a `T::CONST` that typeck will resolve.
                                 if path_res.depth == 0 {
                                     self.resolve_error(
                                         path.span,
                                         &format!("`{}` is not an enum variant, struct or const",
                                                  token::get_ident(
                                                      path.segments.last().unwrap().identifier)));
                                 } else {
+                                    let const_name = path.segments.last().unwrap()
+                                                         .identifier.name;
+                                    let traits = self.get_traits_containing_item(const_name);
+                                    self.trait_map.insert(pattern.id, traits);
                                     self.record_def(pattern.id, path_res);
                                 }
                             }

src/test/run-pass/associated-const-match-patterns.rs

@@ -41,6 +41,10 @@ fn main() {
         _ => false,
     });
     // Trait impl
+    assert!(match Bar::Var1 {
+        Foo::THEBAR => true,
+        _ => false,
+    });
     assert!(match Bar::Var1 {
         <Foo>::THEBAR => true,
         _ => false,