---

yaml
---
r: 156251
b: refs/heads/snap-stage3
c: 0c48c57
h: refs/heads/master
i:
  156249: adaeb41
  156247: a67d91a
v: v3

Author: Jakub Wieczorek

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 38517d0eba2ee69443449fbe6b1ce7dea7deca7b
+refs/heads/snap-stage3: 0c48c5712dc52bb1f9e70181f1b68feff75269c2
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/reference.md

@@ -1328,6 +1328,23 @@ let c = [Cookie, Cookie, Cookie, Cookie];
 The precise memory layout of a structure is not specified. One can specify a
 particular layout using the [`repr` attribute](#ffi-attributes).
 
+By using the `struct_inherit` feature gate, structures may use single
+inheritance. A Structure may only inherit from a single other structure, called
+the _super-struct_. The inheriting structure (sub-struct) acts as if all fields
+in the super-struct were present in the sub-struct. Fields declared in a
+sub-struct must not have the same name as any field in any (transitive)
+super-struct. All fields (both declared and inherited) must be specified in any
+initializers. Inheritance between structures does not give subtyping or
+coercion. The super-struct and sub-struct must be defined in the same crate.
+The super-struct must be declared using the `virtual` keyword. For example:
+
+```{.ignore}
+virtual struct Sup { x: int }
+struct Sub : Sup { y: int }
+let s = Sub {x: 10, y: 11};
+let sx = s.x;
+```
+
 ### Enumerations
 
 An _enumeration_ is a simultaneous definition of a nominal [enumerated

branches/snap-stage3/src/librustc/diagnostics.rs

@@ -56,6 +56,7 @@ register_diagnostics!(
     E0038,
     E0039,
     E0040,
+    E0041,
     E0044,
     E0045,
     E0046,
@@ -122,6 +123,7 @@ register_diagnostics!(
     E0121,
     E0122,
     E0124,
+    E0126,
     E0127,
     E0128,
     E0129,
@@ -139,6 +141,9 @@ register_diagnostics!(
     E0141,
     E0152,
     E0153,
+    E0154,
+    E0155,
+    E0156,
     E0157,
     E0158,
     E0159,

branches/snap-stage3/src/librustc/middle/check_match.rs

@@ -638,15 +638,15 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
         PatEnum(..) =>
             match cx.tcx.def_map.borrow().find(&pat.id) {
                 Some(&DefConst(..)) =>
-                    cx.tcx.sess.span_bug(pat.span, "static pattern should've \
+                    cx.tcx.sess.span_bug(pat.span, "const pattern should've \
                                                     been rewritten"),
                 Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
                 _ => vec!(Single)
             },
         PatStruct(..) =>
             match cx.tcx.def_map.borrow().find(&pat.id) {
                 Some(&DefConst(..)) =>
-                    cx.tcx.sess.span_bug(pat.span, "static pattern should've \
+                    cx.tcx.sess.span_bug(pat.span, "const pattern should've \
                                                     been rewritten"),
                 Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
                 _ => vec!(Single)

branches/snap-stage3/src/librustc/middle/pat_util.rs

@@ -25,11 +25,25 @@ pub type PatIdMap = HashMap<Ident, NodeId>;
 pub fn pat_id_map(dm: &resolve::DefMap, pat: &Pat) -> PatIdMap {
     let mut map = HashMap::new();
     pat_bindings(dm, pat, |_bm, p_id, _s, path1| {
-      map.insert(path1.node, p_id);
+        map.insert(path1.node, p_id);
     });
     map
 }
 
+pub fn pat_is_refutable(dm: &resolve::DefMap, pat: &Pat) -> bool {
+    match pat.node {
+        PatLit(_) | PatRange(_, _) => true,
+        PatEnum(_, _) | PatIdent(_, _, None) | PatStruct(..) => {
+            match dm.borrow().find(&pat.id) {
+                Some(&DefVariant(..)) => true,
+                _ => false
+            }
+        }
+        PatVec(_, _, _) => true,
+        _ => false
+    }
+}
+
 pub fn pat_is_variant_or_struct(dm: &resolve::DefMap, pat: &Pat) -> bool {
     match pat.node {
         PatEnum(_, _) | PatIdent(_, _, None) | PatStruct(..) => {

branches/snap-stage3/src/librustc/middle/resolve.rs

@@ -54,6 +54,7 @@ use syntax::parse::token::special_idents;
 use syntax::parse::token;
 use syntax::codemap::{Span, DUMMY_SP, Pos};
 use syntax::owned_slice::OwnedSlice;
+use syntax::ptr::P;
 use syntax::visit;
 use syntax::visit::Visitor;
 
@@ -4178,6 +4179,7 @@ impl<'a> Resolver<'a> {
             ItemStruct(ref struct_def, ref generics) => {
                 self.resolve_struct(item.id,
                                     generics,
+                                    &struct_def.super_struct,
                                     struct_def.fields.as_slice());
             }
 
@@ -4503,6 +4505,7 @@ impl<'a> Resolver<'a> {
     fn resolve_struct(&mut self,
                       id: NodeId,
                       generics: &Generics,
+                      super_struct: &Option<P<Ty>>,
                       fields: &[StructField]) {
         // If applicable, create a rib for the type parameters.
         self.with_type_parameter_rib(HasTypeParameters(generics,
@@ -4514,6 +4517,42 @@ impl<'a> Resolver<'a> {
             this.resolve_type_parameters(&generics.ty_params);
             this.resolve_where_clause(&generics.where_clause);
 
+            // Resolve the super struct.
+            match *super_struct {
+                Some(ref t) => match t.node {
+                    TyPath(ref path, None, path_id) => {
+                        match this.resolve_path(id, path, TypeNS, true) {
+                            Some((DefTy(def_id, _), lp)) if this.structs.contains_key(&def_id) => {
+                                let def = DefStruct(def_id);
+                                debug!("(resolving struct) resolved `{}` to type {:?}",
+                                       token::get_ident(path.segments
+                                                            .last().unwrap()
+                                                            .identifier),
+                                       def);
+                                debug!("(resolving struct) writing resolution for `{}` (id {})",
+                                       this.path_idents_to_string(path),
+                                       path_id);
+                                this.record_def(path_id, (def, lp));
+                            }
+                            Some((DefStruct(_), _)) => {
+                                span_err!(this.session, t.span, E0154,
+                                    "super-struct is defined in a different crate");
+                            },
+                            Some(_) => {
+                                span_err!(this.session, t.span, E0155,
+                                    "super-struct is not a struct type");
+                            }
+                            None => {
+                                span_err!(this.session, t.span, E0156,
+                                    "super-struct could not be resolved");
+                            }
+                        }
+                    },
+                    _ => this.session.span_bug(t.span, "path not mapped to a TyPath")
+                },
+                None => {}
+            }
+
             // Resolve fields.
             for field in fields.iter() {
                 this.resolve_type(&*field.node.ty);

branches/snap-stage3/src/librustc/middle/trans/_match.rs

@@ -218,6 +218,7 @@ use util::ppaux::{Repr, vec_map_to_string};
 
 use std;
 use std::collections::HashMap;
+use std::iter::AdditiveIterator;
 use std::rc::Rc;
 use syntax::ast;
 use syntax::ast::{DUMMY_NODE_ID, Ident};
@@ -754,33 +755,41 @@ impl FailureHandler {
     }
 }
 
-fn pick_col(m: &[Match]) -> uint {
-    fn score(p: &ast::Pat) -> uint {
-        match p.node {
-          ast::PatLit(_) | ast::PatEnum(_, _) | ast::PatRange(_, _) => 1u,
-          ast::PatIdent(_, _, Some(ref p)) => score(&**p),
-          _ => 0u
+fn pick_column_to_specialize(def_map: &DefMap, m: &[Match]) -> Option<uint> {
+    fn pat_score(def_map: &DefMap, pat: &ast::Pat) -> uint {
+        match pat.node {
+            ast::PatIdent(_, _, Some(ref inner)) => pat_score(def_map, &**inner),
+            _ if pat_is_refutable(def_map, pat) => 1u,
+            _ => 0u
         }
     }
-    let mut scores = Vec::from_elem(m[0].pats.len(), 0u);
-    for br in m.iter() {
-        for (i, ref p) in br.pats.iter().enumerate() {
-            *scores.get_mut(i) += score(&***p);
+
+    let column_score: |&[Match], uint| -> uint = |m, col| {
+        let total_score = m.iter()
+            .map(|row| row.pats[col])
+            .map(|pat| pat_score(def_map, pat))
+            .sum();
+
+        // Irrefutable columns always go first, they'd only be duplicated in the branches.
+        if total_score == 0 {
+            std::uint::MAX
+        } else {
+            total_score
         }
-    }
-    let mut max_score = 0u;
-    let mut best_col = 0u;
-    for (i, score) in scores.iter().enumerate() {
-        let score = *score;
-
-        // Irrefutable columns always go first, they'd only be duplicated in
-        // the branches.
-        if score == 0u { return i; }
-        // If no irrefutable ones are found, we pick the one with the biggest
-        // branching factor.
-        if score > max_score { max_score = score; best_col = i; }
-    }
-    return best_col;
+    };
+
+    let column_contains_any_nonwild_patterns: |&uint| -> bool = |&col| {
+        m.iter().any(|row| match row.pats[col].node {
+            ast::PatWild(_) => false,
+            _ => true
+        })
+    };
+
+    range(0, m[0].pats.len())
+        .filter(column_contains_any_nonwild_patterns)
+        .map(|col| (col, column_score(m, col)))
+        .max_by(|&(_, score)| score)
+        .map(|(col, _)| col)
 }
 
 // Compiles a comparison between two things.
@@ -951,44 +960,45 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         return;
     }
 
-    let col_count = m[0].pats.len();
-    if col_count == 0u {
-        let data = &m[0].data;
-        for &(ref ident, ref value_ptr) in m[0].bound_ptrs.iter() {
-            let llmatch = data.bindings_map.get(ident).llmatch;
-            call_lifetime_start(bcx, llmatch);
-            Store(bcx, *value_ptr, llmatch);
+    let tcx = bcx.tcx();
+    let def_map = &tcx.def_map;
+    match pick_column_to_specialize(def_map, m) {
+        Some(col) => {
+            let val = vals[col];
+            if has_nested_bindings(m, col) {
+                let expanded = expand_nested_bindings(bcx, m, col, val);
+                compile_submatch_continue(bcx,
+                                          expanded.as_slice(),
+                                          vals,
+                                          chk,
+                                          col,
+                                          val,
+                                          has_genuine_default)
+            } else {
+                compile_submatch_continue(bcx, m, vals, chk, col, val, has_genuine_default)
+            }
         }
-        match data.arm.guard {
-            Some(ref guard_expr) => {
-                bcx = compile_guard(bcx,
-                                    &**guard_expr,
-                                    m[0].data,
-                                    m[1..m.len()],
-                                    vals,
-                                    chk,
-                                    has_genuine_default);
+        None => {
+            let data = &m[0].data;
+            for &(ref ident, ref value_ptr) in m[0].bound_ptrs.iter() {
+                let llmatch = data.bindings_map.get(ident).llmatch;
+                call_lifetime_start(bcx, llmatch);
+                Store(bcx, *value_ptr, llmatch);
             }
-            _ => ()
+            match data.arm.guard {
+                Some(ref guard_expr) => {
+                    bcx = compile_guard(bcx,
+                                        &**guard_expr,
+                                        m[0].data,
+                                        m[1..m.len()],
+                                        vals,
+                                        chk,
+                                        has_genuine_default);
+                }
+                _ => ()
+            }
+            Br(bcx, data.bodycx.llbb);
         }
-        Br(bcx, data.bodycx.llbb);
-        return;
-    }
-
-    let col = pick_col(m);
-    let val = vals[col];
-
-    if has_nested_bindings(m, col) {
-        let expanded = expand_nested_bindings(bcx, m, col, val);
-        compile_submatch_continue(bcx,
-                                  expanded.as_slice(),
-                                  vals,
-                                  chk,
-                                  col,
-                                  val,
-                                  has_genuine_default)
-    } else {
-        compile_submatch_continue(bcx, m, vals, chk, col, val, has_genuine_default)
     }
 }