---

yaml
---
r: 50678
b: refs/heads/try
c: aa4c19b
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: 2ccc6e0a57660aaf84c70208bb98c5eb4285de3a
+refs/heads/try: aa4c19b6abb86d93077fa63d3f0f893f8a3cb355
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/librustc/middle/resolve.rs

@@ -4290,17 +4290,24 @@ pub impl Resolver {
                     }
                 }
 
-                pat_ident(_, path, _) | pat_enum(path, _) => {
-                    // These two must be enum variants or structs.
+                pat_ident(binding_mode, path, _) => {
+                    // This must be an enum variant, struct, or constant.
                     match self.resolve_path(path, ValueNS, false, visitor) {
                         Some(def @ def_variant(*)) |
                                 Some(def @ def_struct(*)) => {
                             self.record_def(pattern.id, def);
                         }
+                        Some(def @ def_const(*)) => {
+                            self.enforce_default_binding_mode(
+                                pattern,
+                                binding_mode,
+                                "a constant");
+                            self.record_def(pattern.id, def);
+                        }
                         Some(_) => {
                             self.session.span_err(
                                 path.span,
-                                fmt!("not an enum variant: %s",
+                                fmt!("not an enum variant or constant: %s",
                                      *self.session.str_of(
                                          *path.idents.last())));
                         }
@@ -4316,6 +4323,33 @@ pub impl Resolver {
                     }
                 }
 
+                pat_enum(path, _) => {
+                    // This must be an enum variant or struct.
+                    match self.resolve_path(path, ValueNS, false, visitor) {
+                        Some(def @ def_variant(*)) |
+                                Some(def @ def_struct(*)) => {
+                            self.record_def(pattern.id, def);
+                        }
+                        Some(_) => {
+                            self.session.span_err(
+                                path.span,
+                                fmt!("not an enum variant or struct: %s",
+                                     *self.session.str_of(
+                                         *path.idents.last())));
+                        }
+                        None => {
+                            self.session.span_err(path.span,
+                                                  ~"unresolved enum variant \
+                                                    or struct");
+                        }
+                    }
+
+                    // Check the types in the path pattern.
+                    for path.types.each |ty| {
+                        self.resolve_type(*ty, visitor);
+                    }
+                }
+
                 pat_lit(expr) => {
                     self.resolve_expr(expr, visitor);
                 }