---

yaml
---
r: 152758
b: refs/heads/try2
c: 654d644
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d6c1b85246f99b5485f3671bfca2a4657e0c37fd
+refs/heads/try2: 654d6444feafaa7bae17057d8b98823c7556ea14
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/rust.md

@@ -3004,7 +3004,7 @@ ten_times(|j| println!("hello, {}", j));
 ### While loops
 
 ~~~~ {.ebnf .gram}
-while_expr : "while" expr '{' block '}' ;
+while_expr : "while" no_struct_literal_expr '{' block '}' ;
 ~~~~
 
 A `while` loop begins by evaluating the boolean loop conditional expression.
@@ -3071,7 +3071,7 @@ A `continue` expression is only permitted in the body of a loop.
 ### For expressions
 
 ~~~~ {.ebnf .gram}
-for_expr : "for" pat "in" expr '{' block '}' ;
+for_expr : "for" pat "in" no_struct_literal_expr '{' block '}' ;
 ~~~~
 
 A `for` expression is a syntactic construct for looping over elements
@@ -3105,7 +3105,7 @@ for i in range(0u, 256) {
 ### If expressions
 
 ~~~~ {.ebnf .gram}
-if_expr : "if" expr '{' block '}'
+if_expr : "if" no_struct_literal_expr '{' block '}'
           else_tail ? ;
 
 else_tail : "else" [ if_expr
@@ -3126,7 +3126,7 @@ then any `else` block is executed.
 ### Match expressions
 
 ~~~~ {.ebnf .gram}
-match_expr : "match" expr '{' match_arm * '}' ;
+match_expr : "match" no_struct_literal_expr '{' match_arm * '}' ;
 
 match_arm : attribute * match_pat "=>" [ expr "," | '{' block '}' ] ;
 

branches/try2/src/librustc/middle/resolve.rs

@@ -3894,31 +3894,8 @@ impl<'a> Resolver<'a> {
                 self.resolve_error(trait_reference.path.span, msg.as_slice());
             }
             Some(def) => {
-                match def {
-                    (DefTrait(_), _) => {
-                        debug!("(resolving trait) found trait def: {:?}", def);
-                        self.record_def(trait_reference.ref_id, def);
-                    }
-                    (def, _) => {
-                        self.resolve_error(trait_reference.path.span,
-                                           format!("`{}` is not a trait",
-                                                   self.path_idents_to_str(
-                                                        &trait_reference.path)));
-
-                        // If it's a typedef, give a note
-                        match def {
-                            DefTy(_) => {
-                                self.session.span_note(
-                                                trait_reference.path.span,
-                                                format!("`type` aliases cannot \
-                                                        be used for traits")
-                                                        .as_slice());
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-
+                debug!("(resolving trait) found trait def: {:?}", def);
+                self.record_def(trait_reference.ref_id, def);
             }
         }
     }
@@ -4044,9 +4021,6 @@ impl<'a> Resolver<'a> {
 
                 this.with_current_self_type(self_type, |this| {
                     for method in methods.iter() {
-                        // If this is a trait impl, ensure the method exists in trait
-                        this.check_trait_method(&**method);
-
                         // We also need a new scope for the method-specific type parameters.
                         this.resolve_method(MethodRibKind(id, Provided(method.id)),
                                             &**method);
@@ -4056,21 +4030,6 @@ impl<'a> Resolver<'a> {
         });
     }
 
-    fn check_trait_method(&self, method: &Method) {
-        // If there is a TraitRef in scope for an impl, then the method must be in the trait.
-        for &(did, ref trait_ref) in self.current_trait_ref.iter() {
-            let method_name = method.ident.name;
-
-            if self.method_map.borrow().find(&(method_name, did)).is_none() {
-                let path_str = self.path_idents_to_str(&trait_ref.path);
-                self.resolve_error(method.span,
-                                    format!("method `{}` is not a member of trait `{}`",
-                                            token::get_name(method_name),
-                                            path_str).as_slice());
-            }
-        }
-    }
-
     fn resolve_module(&mut self, module: &Mod, _span: Span,
                       _name: Ident, id: NodeId) {
         // Write the implementations in scope into the module metadata.

branches/try2/src/librustc/middle/typeck/check/mod.rs

@@ -784,8 +784,7 @@ fn check_impl_methods_against_trait(ccx: &CrateCtxt,
                                     &impl_trait_ref.substs);
             }
             None => {
-                // This is span_bug as it should have already been caught in resolve.
-                tcx.sess.span_bug(
+                tcx.sess.span_err(
                     impl_method.span,
                     format!(
                         "method `{}` is not a member of trait `{}`",

branches/try2/src/libsyntax/parse/parser.rs

@@ -88,6 +88,7 @@ pub enum restriction {
     RESTRICT_STMT_EXPR,
     RESTRICT_NO_BAR_OP,
     RESTRICT_NO_BAR_OR_DOUBLEBAR_OP,
+    RESTRICT_NO_STRUCT_LITERAL,
 }
 
 type ItemInfo = (Ident, Item_, Option<Vec<Attribute> >);
@@ -2024,8 +2025,9 @@ impl<'a> Parser<'a> {
 
                 return self.mk_mac_expr(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT));
             } else if self.token == token::LBRACE {
-                // This might be a struct literal.
-                if self.looking_at_struct_literal() {
+                // This is a struct literal, unless we're prohibited from
+                // parsing struct literals here.
+                if self.restriction != RESTRICT_NO_STRUCT_LITERAL {
                     // It's a struct literal.
                     self.bump();
                     let mut fields = Vec::new();
@@ -2042,6 +2044,14 @@ impl<'a> Parser<'a> {
                                          &[token::COMMA], &[token::RBRACE]);
                     }
 
+                    if fields.len() == 0 && base.is_none() {
+                        let last_span = self.last_span;
+                        self.span_err(last_span,
+                                      "structure literal must either have at \
+                                       least one field or use functional \
+                                       structure update syntax");
+                    }
+
                     hi = self.span.hi;
                     self.expect(&token::RBRACE);
                     ex = ExprStruct(pth, fields, base);
@@ -2548,7 +2558,7 @@ impl<'a> Parser<'a> {
     // parse an 'if' expression ('if' token already eaten)
     pub fn parse_if_expr(&mut self) -> Gc<Expr> {
         let lo = self.last_span.lo;
-        let cond = self.parse_expr();
+        let cond = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
         let thn = self.parse_block();
         let mut els: Option<Gc<Expr>> = None;
         let mut hi = thn.span.hi;
@@ -2633,7 +2643,7 @@ impl<'a> Parser<'a> {
         let lo = self.last_span.lo;
         let pat = self.parse_pat();
         self.expect_keyword(keywords::In);
-        let expr = self.parse_expr();
+        let expr = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
         let loop_block = self.parse_block();
         let hi = self.span.hi;
 
@@ -2642,7 +2652,7 @@ impl<'a> Parser<'a> {
 
     pub fn parse_while_expr(&mut self) -> Gc<Expr> {
         let lo = self.last_span.lo;
-        let cond = self.parse_expr();
+        let cond = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
         let body = self.parse_block();
         let hi = body.span.hi;
         return self.mk_expr(lo, hi, ExprWhile(cond, body));
@@ -2655,17 +2665,9 @@ impl<'a> Parser<'a> {
         self.mk_expr(lo, hi, ExprLoop(body, opt_ident))
     }
 
-    // For distinguishing between struct literals and blocks
-    fn looking_at_struct_literal(&mut self) -> bool {
-        self.token == token::LBRACE &&
-        ((self.look_ahead(1, |t| token::is_plain_ident(t)) &&
-          self.look_ahead(2, |t| *t == token::COLON))
-         || self.look_ahead(1, |t| *t == token::DOTDOT))
-    }
-
     fn parse_match_expr(&mut self) -> Gc<Expr> {
         let lo = self.last_span.lo;
-        let discriminant = self.parse_expr();
+        let discriminant = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
         self.commit_expr_expecting(discriminant, token::LBRACE);
         let mut arms: Vec<Arm> = Vec::new();
         while self.token != token::RBRACE {

branches/try2/src/test/compile-fail/bind-struct-early-modifiers.rs

@@ -10,7 +10,7 @@
 
 fn main() {
     struct Foo { x: int }
-    match Foo { x: 10 } {
+    match (Foo { x: 10 }) {
         Foo { ref x: ref x } => {}, //~ ERROR unexpected `:`
         _ => {}
     }

branches/try2/src/test/compile-fail/borrowck-match-binding-is-assignment.rs

@@ -31,7 +31,7 @@ pub fn main() {
         }
     }
 
-    match S { bar: 1 } {
+    match (S { bar: 1 }) {
         S { bar: x } => {
             x += 1; //~ ERROR re-assignment of immutable variable `x`
         }

branches/try2/src/test/compile-fail/borrowck-move-error-with-note.rs

@@ -34,7 +34,7 @@ impl Drop for S {
 }
 
 fn move_in_match() {
-    match S {f: "foo".to_string(), g: "bar".to_string()} {
+    match (S {f: "foo".to_string(), g: "bar".to_string()}) {
         S {         //~ ERROR cannot move out of type `S`, which defines the `Drop` trait
             f: _s,  //~ NOTE attempting to move value to here
             g: _t   //~ NOTE and here

branches/try2/src/test/compile-fail/borrowck-move-out-of-struct-with-dtor.rs

@@ -14,7 +14,7 @@ impl Drop for S {
 }
 
 fn move_in_match() {
-    match S {f:"foo".to_string()} {
+    match (S {f:"foo".to_string()}) {
         S {f:_s} => {}
         //~^ ERROR cannot move out of type `S`, which defines the `Drop` trait
     }

branches/try2/src/test/compile-fail/issue-3907.rs

@@ -1,4 +1,4 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -11,14 +11,13 @@
 // aux-build:issue_3907.rs
 extern crate issue_3907;
 
-type Foo = issue_3907::Foo;
+type Foo = issue_3907::Foo; //~ ERROR: reference to trait
 
 struct S {
     name: int
 }
 
 impl Foo for S { //~ ERROR: `Foo` is not a trait
-    //~^ NOTE: `type` aliases cannot be used for traits
     fn bar() { }
 }
 

branches/try2/src/test/compile-fail/issue-3973.rs

@@ -8,29 +8,26 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// ignore-test
+
+use std::io;
+
 struct Point {
     x: f64,
     y: f64,
 }
 
-trait NewTrait {
-    fn a(&self) -> String;
-}
-
-impl NewTrait for Point {
+impl ToStr for Point { //~ ERROR implements a method not defined in the trait
     fn new(x: f64, y: f64) -> Point {
-    //~^ ERROR method `new` is not a member of trait `NewTrait`
         Point { x: x, y: y }
     }
 
-    fn a(&self) -> String {
+    fn to_str(&self) -> String {
         format!("({}, {})", self.x, self.y)
     }
 }
 
 fn main() {
     let p = Point::new(0.0, 0.0);
-    //~^ ERROR unresolved name `Point::new`
-    //~^^ ERROR failed to resolve. Use of undeclared module `Point`
-    println!("{}", p.a());
+    println!("{}", p.to_str());
 }

branches/try2/src/test/compile-fail/issue-5035.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 trait I {}
-type K = I;
+type K = I; //~ ERROR: reference to trait
 impl K for int {} //~ ERROR: `K` is not a trait
-//~^ NOTE: `type` aliases cannot be used for traits
 fn main() {}

branches/try2/src/test/compile-fail/match-struct.rs

@@ -13,7 +13,7 @@ struct S { a: int }
 enum E { C(int) }
 
 fn main() {
-    match S { a: 1 } {
+    match (S { a: 1 }) {
         C(_) => (), //~ ERROR mismatched types: expected `S` but found `E`
         _ => ()
     }

branches/try2/src/test/compile-fail/non-exhaustive-pattern-witness.rs

@@ -22,7 +22,7 @@ enum Color {
 }
 
 fn struct_with_a_nested_enum_and_vector() {
-    match Foo { first: true, second: None } {
+    match (Foo { first: true, second: None }) {
     //~^ ERROR non-exhaustive patterns: `Foo{first: false, second: Some([_, _, _, _])}` not covered
         Foo { first: true, second: None } => (),
         Foo { first: true, second: Some(_) } => (),
@@ -71,4 +71,4 @@ fn main() {
     struct_with_a_nested_enum_and_vector();
     enum_with_multiple_missing_variants();
     enum_struct_variant();
-}
+}

branches/try2/src/test/compile-fail/struct-literal-in-for.rs

@@ -0,0 +1,28 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Foo {
+    x: int,
+}
+
+impl Foo {
+    fn hi(&self) -> bool {
+        true
+    }
+}
+
+fn main() {
+    for x in Foo {
+        x: 3    //~ ERROR expected one of `;`, `}`
+    }.hi() {
+        println!("yo");
+    }
+}
+

branches/try2/src/test/compile-fail/issue-5035-2.rs renamed to branches/try2/src/test/compile-fail/struct-literal-in-if.rs

@@ -1,4 +1,4 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,7 +8,21 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait I {}
-type K = I; //~ ERROR: reference to trait
+struct Foo {
+    x: int,
+}
+
+impl Foo {
+    fn hi(&self) -> bool {
+        true
+    }
+}
+
+fn main() {
+    if Foo {
+        x: 3    //~ ERROR expected one of `;`, `}`
+    }.hi() {
+        println!("yo");
+    }
+}
 
-fn main() {}