---

yaml
---
r: 31726
b: refs/heads/dist-snap
c: 3196586
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 5ce3281a624c0620f1b6f4e21c15e4a6a17a1dc5
+refs/heads/dist-snap: 31965860c797d07bc5f9d217874323b4f361bc0c
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/rustc/middle/resolve3.rs

@@ -33,7 +33,8 @@ import syntax::ast::{lt, method, mul, ne, neg, node_id, pat, pat_enum};
 import syntax::ast::{pat_ident, path, prim_ty, pat_box, pat_uniq, pat_lit};
 import syntax::ast::{pat_range, pat_rec, pat_struct, pat_tup, pat_wild};
 import syntax::ast::{provided, required, rem, self_ty_, shl, stmt_decl};
-import syntax::ast::{sty_static, subtract, ty};
+import syntax::ast::{struct_variant_kind, sty_static, subtract};
+import syntax::ast::{tuple_variant_kind, ty};
 import syntax::ast::{ty_bool, ty_char, ty_f, ty_f32, ty_f64, ty_float, ty_i};
 import syntax::ast::{ty_i16, ty_i32, ty_i64, ty_i8, ty_int, ty_param};
 import syntax::ast::{ty_path, ty_str, ty_u, ty_u16, ty_u32, ty_u64, ty_u8};
@@ -1114,10 +1115,8 @@ class Resolver {
         }
     }
 
-    /**
-     * Constructs the reduced graph for one variant. Variants exist in the
-     * type namespace.
-     */
+    // Constructs the reduced graph for one variant. Variants exist in the
+    // type and/or value namespaces.
     fn build_reduced_graph_for_variant(variant: variant,
                                        item_id: def_id,
                                        parent: ReducedGraphParent,
@@ -1127,8 +1126,19 @@ class Resolver {
         let (child, _) = self.add_child(atom, parent, ~[ValueNS],
                                         variant.span);
 
-        (*child).define_value(def_variant(item_id,
-                                local_def(variant.node.id)), variant.span);
+        match variant.node.kind {
+            tuple_variant_kind(_) => {
+                (*child).define_value(def_variant(item_id,
+                                                  local_def(variant.node.id)),
+                                      variant.span);
+            }
+            struct_variant_kind(_) => {
+                (*child).define_type(def_variant(item_id,
+                                                 local_def(variant.node.id)),
+                                     variant.span);
+                self.structs.insert(local_def(variant.node.id), false);
+            }
+        }
     }
 
     /**
@@ -4018,13 +4028,17 @@ class Resolver {
 
                 pat_struct(path, _, _) => {
                     match self.resolve_path(path, TypeNS, false, visitor) {
-                        some(definition @ def_ty(class_id))
+                        some(def_ty(class_id))
                                 if self.structs.contains_key(class_id) => {
                             let has_constructor = self.structs.get(class_id);
                             let class_def = def_class(class_id,
                                                       has_constructor);
                             self.record_def(pattern.id, class_def);
                         }
+                        some(definition @ def_variant(_, variant_id))
+                                if self.structs.contains_key(variant_id) => {
+                            self.record_def(pattern.id, definition);
+                        }
                         _ => {
                             self.session.span_err(path.span,
                                                   fmt!("`%s` does not name a \
@@ -4450,13 +4464,16 @@ class Resolver {
                 //    let bar = Bar { ... } // no type parameters
 
                 match self.resolve_path(path, TypeNS, false, visitor) {
-                    some(definition @ def_ty(class_id))
+                    some(def_ty(class_id))
                             if self.structs.contains_key(class_id) => {
-
                         let has_constructor = self.structs.get(class_id);
                         let class_def = def_class(class_id, has_constructor);
                         self.record_def(expr.id, class_def);
                     }
+                    some(definition @ def_variant(_, class_id))
+                            if self.structs.contains_key(class_id) => {
+                        self.record_def(expr.id, definition);
+                    }
                     _ => {
                         self.session.span_err(path.span,
                                               fmt!{"`%s` does not name a \