---

yaml
---
r: 31466
b: refs/heads/dist-snap
c: b6aadf5
h: refs/heads/master
v: v3

Author: catamorphism

[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: 300f54ebc0aaecb05cf4b7efd5bc17d326ec9535
+refs/heads/dist-snap: b6aadf56c8a6e603c79a8924e6a92398471de8cf
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -32,7 +32,7 @@ import syntax::ast::{required, provided};
 import syntax::ast_util::{def_id_of_def, dummy_sp, local_def, new_def_hash};
 import syntax::ast_util::{walk_pat};
 import syntax::attr::{attr_metas, contains_name};
-import syntax::print::pprust::path_to_str;
+import syntax::print::pprust::{pat_to_str, path_to_str};
 import syntax::codemap::span;
 import syntax::visit::{default_visitor, fk_method, mk_vt, visit_block};
 import syntax::visit::{visit_crate, visit_expr, visit_expr_opt, visit_fn};
@@ -3658,9 +3658,12 @@ class Resolver {
     fn resolve_pattern(pattern: @pat,
                        mode: PatternBindingMode,
                        mutability: Mutability,
-                       bindings_list: option<hashmap<Atom,()>>,
+                       // Maps idents to the node ID for the (outermost)
+                       // pattern that binds them
+                       bindings_list: option<hashmap<Atom,node_id>>,
                        visitor: ResolveVisitor) {
 
+        let pat_id = pattern.id;
         do walk_pat(pattern) |pattern| {
             alt pattern.node {
                 pat_ident(path, _)
@@ -3705,19 +3708,18 @@ class Resolver {
 
                             let is_mutable = mutability == Mutable;
 
-                            let mut def;
-                            alt mode {
+                            let def = alt mode {
                                 RefutableMode {
                                     // For pattern arms, we must use
                                     // `def_binding` definitions.
 
-                                    def = def_binding(pattern.id);
+                                    def_binding(pattern.id)
                                 }
                                 IrrefutableMode {
                                     // But for locals, we use `def_local`.
-                                    def = def_local(pattern.id, is_mutable);
+                                    def_local(pattern.id, is_mutable)
                                 }
-                            }
+                            };
 
                             // Record the definition so that later passes
                             // will be able to distinguish variants from
@@ -3737,10 +3739,19 @@ class Resolver {
                                     let last_rib = (*self.value_ribs).last();
                                     last_rib.bindings.insert(atom,
                                                              dl_def(def));
-                                    bindings_list.insert(atom, ());
+                                    bindings_list.insert(atom, pat_id);
                                 }
-                                some(_) {
-                                    // Do nothing.
+                                some(b) {
+                                  if b.find(atom) == some(pat_id) {
+                                      // Then this is a duplicate variable
+                                      // in the same disjunct, which is an
+                                      // error
+                                     self.session.span_err(pattern.span,
+                                       #fmt("Identifier %s is bound more \
+                                             than once in the same pattern",
+                                            path_to_str(path)));
+                                  }
+                                  // Not bound in the same pattern: do nothing
                                 }
                                 none {
                                     let last_rib = (*self.value_ribs).last();

branches/dist-snap/src/test/compile-fail/issue-3038.rs

@@ -0,0 +1,25 @@
+enum f { g(int, int) }
+
+enum h { i(j, k) }
+
+enum j { l(int, int) }
+enum k { m(int, int) }
+
+fn main()
+{
+
+    let _z = alt g(1, 2) {
+      g(x, x) { log(debug, x + x); }
+      //~^ ERROR Identifier x is bound more than once in the same pattern
+    };
+
+    let _z = alt i(l(1, 2), m(3, 4)) {
+      i(l(x, _), m(_, x))  //~ ERROR Identifier x is bound more than once in the same pattern
+        { log(error, x + x); }
+    };
+
+    let _z = alt (1, 2) {
+        (x, x) { x } //~ ERROR Identifier x is bound more than once in the same pattern
+    };
+
+}