---

yaml
---
r: 44876
b: refs/heads/master
c: 10faa52
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b662d3c922f1922da55d324aa65dfe268c2bb971
+refs/heads/master: 10faa521aef3721effc2ac9c2df0ceca4d825f98
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/CONTRIBUTING.md

@@ -11,7 +11,7 @@ You're not off the hook even if you just stick to documentation; code examples i
 Pull requests will be treated as "review requests",
 and we will give feedback we expect to see corrected on [style](https://github.com/mozilla/rust/wiki/Note-style-guide) and substance before pulling.
 Changes contributed via pull request should focus on a single issue at a time, like any other.
-We will not look accept pull-requests that try to "sneak" unrelated changes in.
+We will not accept pull-requests that try to "sneak" unrelated changes in.
 
 Normally, all pull requests must include regression tests (see [Note-testsuite](https://github.com/mozilla/rust/wiki/Note-testsuite)) that test your change.
 Occasionally, a change will be very difficult to test for.

trunk/doc/rust.md

@@ -908,6 +908,11 @@ function defined above on `[1, 2]` will instantiate type parameter `T`
 with `int`, and require the closure parameter to have type
 `fn(int)`.
 
+The type parameters can also be explicitly supplied in a trailing
+[path](#paths) component after the function name. This might be necessary
+if there is not sufficient context to determine the type parameters. For
+example, `sys::size_of::<u32>() == 4`.
+
 Since a parameter type is opaque to the generic function, the set of
 operations that can be performed on it is limited. Values of parameter
 type can always be moved, but they can only be copied when the
@@ -1085,6 +1090,15 @@ let p = Point(10, 11);
 let px: int = match p { Point(x, _) => x };
 ~~~~
 
+A _unit-like struct_ is a structure without any fields, defined by leaving off the fields list entirely.
+Such types will have a single value, just like the [unit value `()`](#unit-and-boolean-literals) of the unit type.
+For example:
+
+~~~~
+struct Cookie;
+let c = [Cookie, Cookie, Cookie, Cookie];
+~~~~
+
 ### Enumerations
 
 An _enumeration_ is a simultaneous definition of a nominal [enumerated type](#enumerated-types) as well as a set of *constructors*,
@@ -1590,7 +1604,8 @@ struct_expr : expr_path '{' ident ':' expr
                       [ ',' ident ':' expr ] *
                       [ ".." expr ] '}' |
               expr_path '(' expr
-                      [ ',' expr ] * ')'
+                      [ ',' expr ] * ')' |
+              expr_path
 ~~~~~~~~
 
 There are several forms of structure expressions.
@@ -1600,23 +1615,28 @@ providing the field values of a new instance of the structure.
 A field name can be any identifier, and is separated from its value expression by a colon.
 To indicate that a field is mutable, the `mut` keyword is written before its name.
 
-A _tuple structure expression_ constists of the [path](#paths) of a [structure item](#structures),
+A _tuple structure expression_ consists of the [path](#paths) of a [structure item](#structures),
 followed by a parenthesized list of one or more comma-separated expressions
 (in other words, the path of a structured item followed by a tuple expression).
 The structure item must be a tuple structure item.
 
+A _unit-like structure expression_ consists only of the [path](#paths) of a [structure item](#structures).
+
 The following are examples of structure expressions:
 
 ~~~~
 # struct Point { x: float, y: float }
 # struct TuplePoint(float, float);
 # mod game { pub struct User { name: &str, age: uint, score: uint } }
+# struct Cookie; fn some_fn<T>(t: T) {}
 Point {x: 10f, y: 20f};
 TuplePoint(10f, 20f);
 let u = game::User {name: "Joe", age: 35u, score: 100_000};
+some_fn::<Cookie>(Cookie);
 ~~~~
 
 A structure expression forms a new value of the named structure type.
+Note that for a given *unit-like* structure type, this will always be the same value.
 
 A structure expression can terminate with the syntax `..` followed by an expression to denote a functional update.
 The expression following `..` (the base) must be of the same structure type as the new structure type being formed.
@@ -2040,12 +2060,14 @@ an optional reference slot to serve as the function's output, bound to the
 `lval` on the right hand side of the call. If the function eventually returns,
 then the expression completes.
 
-An example of a call expression:
+Some examples of call expressions:
 
 ~~~~
 # fn add(x: int, y: int) -> int { 0 }
+# use core::from_str::FromStr::from_str;
 
 let x: int = add(1, 2);
+let pi = from_str::<f32>("3.14");
 ~~~~
 
 ### Lambda expressions
@@ -2643,7 +2665,10 @@ the resulting `struct` value will always be laid out in memory in the order spec
 The fields of a `struct` may be qualified by [visibility modifiers](#visibility-modifiers),
 to restrict access to implementation-private data in a structure.
 
-A `tuple struct` type is just like a structure type, except that the fields are anonymous.
+A _tuple struct_ type is just like a structure type, except that the fields are anonymous.
+
+A _unit-like struct_ type is like a structure type, except that it has no fields.
+The one value constructed by the associated [structure expression](#structure-expression) is the only value that inhabits such a type.
 
 ### Enumerated types
 

trunk/src/librustc/middle/kind.rs

@@ -234,7 +234,7 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
                        "explicit copy requires a copyable argument");
         }
         expr_repeat(element, count_expr, _) => {
-            let count = ty::eval_repeat_count(cx.tcx, count_expr);
+            let count = ty::eval_repeat_count(cx.tcx, count_expr, e.span);
             if count > 1 {
                 let element_ty = ty::expr_ty(cx.tcx, element);
                 check_copy(cx, element_ty, element.span,

trunk/src/librustc/middle/trans/tvec.rs

@@ -410,7 +410,8 @@ pub fn write_content(bcx: block,
                     return expr::trans_into(bcx, element, Ignore);
                 }
                 SaveIn(lldest) => {
-                    let count = ty::eval_repeat_count(bcx.tcx(), count_expr);
+                    let count = ty::eval_repeat_count(bcx.tcx(), count_expr,
+                                                      count_expr.span);
                     if count == 0 {
                         return bcx;
                     }
@@ -475,7 +476,7 @@ pub fn elements_required(bcx: block, content_expr: @ast::expr) -> uint {
         },
         ast::expr_vec(es, _) => es.len(),
         ast::expr_repeat(_, count_expr, _) => {
-            ty::eval_repeat_count(bcx.tcx(), count_expr)
+            ty::eval_repeat_count(bcx.tcx(), count_expr, content_expr.span)
         }
         _ => bcx.tcx().sess.span_bug(content_expr.span,
                                      ~"Unexpected evec content")

trunk/src/librustc/middle/ty.rs

@@ -4247,32 +4247,35 @@ pub fn normalize_ty(cx: ctxt, t: t) -> t {
 }
 
 // Returns the repeat count for a repeating vector expression.
-pub fn eval_repeat_count(tcx: ctxt, count_expr: @ast::expr) -> uint {
+pub fn eval_repeat_count(tcx: ctxt,
+                         count_expr: @ast::expr,
+                         span: span)
+                      -> uint {
     match const_eval::eval_const_expr_partial(tcx, count_expr) {
       Ok(ref const_val) => match *const_val {
         const_eval::const_int(count) => return count as uint,
         const_eval::const_uint(count) => return count as uint,
         const_eval::const_float(count) => {
-            tcx.sess.span_err(count_expr.span,
+            tcx.sess.span_err(span,
                               ~"expected signed or unsigned integer for \
                                 repeat count but found float");
             return count as uint;
         }
         const_eval::const_str(_) => {
-            tcx.sess.span_err(count_expr.span,
+            tcx.sess.span_err(span,
                               ~"expected signed or unsigned integer for \
                                 repeat count but found string");
             return 0;
         }
         const_eval::const_bool(_) => {
-            tcx.sess.span_err(count_expr.span,
+            tcx.sess.span_err(span,
                               ~"expected signed or unsigned integer for \
                                 repeat count but found boolean");
             return 0;
         }
       },
       Err(*) => {
-        tcx.sess.span_err(count_expr.span,
+        tcx.sess.span_err(span,
                           ~"expected constant integer for repeat count \
                             but found variable");
         return 0;

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -2147,7 +2147,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
             ty::mk_evec(tcx, ty::mt {ty: t, mutbl: mutability}, tt)
           }
           ast::expr_repeat(element, count_expr, mutbl) => {
-            let count = ty::eval_repeat_count(tcx, count_expr);
+            let count = ty::eval_repeat_count(tcx, count_expr, expr.span);
             fcx.write_ty(count_expr.id, ty::mk_uint(tcx));
             let tt = ast_expr_vstore_to_vstore(fcx, ev, count, vst);
             let t: ty::t = fcx.infcx().next_ty_var();
@@ -2474,7 +2474,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         fcx.write_ty(id, typ);
       }
       ast::expr_repeat(element, count_expr, mutbl) => {
-        let count = ty::eval_repeat_count(tcx, count_expr);
+        let count = ty::eval_repeat_count(tcx, count_expr, expr.span);
         fcx.write_ty(count_expr.id, ty::mk_uint(tcx));
         let t: ty::t = fcx.infcx().next_ty_var();
         bot |= check_expr_has_type(fcx, element, t);