From aa4c19b6abb86d93077fa63d3f0f893f8a3cb355 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 12 Mar 2013 22:39:32 -0700
Subject: librustc: Allow path-qualified constants in patterns

---
 src/librustc/middle/resolve.rs | 40 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 37 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 975f699021e..16f3db6a00e 100644
--- a/src/librustc/middle/resolve.rs
+++ b/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);
                 }
-- 
cgit 1.4.1-3-g733a5