---

yaml
---
r: 44989
b: refs/heads/master
c: 704cd64
h: refs/heads/master
i:
  44987: eb36ec6
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 8bb537e68daf2a2794bacfe4bd39ac7fad6314fa
+refs/heads/master: 704cd648ac1160c5f02291e505697a6cf7e20945
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/librustc/front/test.rs

@@ -178,12 +178,14 @@ fn is_test_fn(i: @ast::item) -> bool {
 
     fn has_test_signature(i: @ast::item) -> bool {
         match &i.node {
-          &ast::item_fn(ref decl, _, ref tps, _) => {
+          &ast::item_fn(ref decl, _, ref generics, _) => {
             let no_output = match decl.output.node {
                 ast::ty_nil => true,
                 _ => false
             };
-            decl.inputs.is_empty() && no_output && tps.is_empty()
+            decl.inputs.is_empty()
+                && no_output
+                && !generics.is_parameterized()
           }
           _ => false
         }

trunk/src/librustc/metadata/encoder.rs

@@ -228,14 +228,16 @@ fn encode_type(ecx: @EncodeContext, ebml_w: writer::Encoder, typ: ty::t) {
 
 fn encode_symbol(ecx: @EncodeContext, ebml_w: writer::Encoder, id: node_id) {
     ebml_w.start_tag(tag_items_data_item_symbol);
-    let sym = match ecx.item_symbols.find(&id) {
-      Some(ref x) => (/*bad*/copy *x),
-      None => {
-        ecx.diag.handler().bug(
-            fmt!("encode_symbol: id not found %d", id));
-      }
-    };
-    ebml_w.writer.write(str::to_bytes(sym));
+    match ecx.item_symbols.find(&id) {
+        Some(ref x) => {
+            debug!("encode_symbol(id=%?, str=%s)", id, *x);
+            ebml_w.writer.write(str::to_bytes(*x));
+        }
+        None => {
+            ecx.diag.handler().bug(
+                fmt!("encode_symbol: id not found %d", id));
+        }
+    }
     ebml_w.end_tag();
 }
 
@@ -264,6 +266,8 @@ fn encode_enum_variant_info(ecx: @EncodeContext, ebml_w: writer::Encoder,
                             path: &[ast_map::path_elt],
                             index: @mut ~[entry<int>],
                             generics: &ast::Generics) {
+    debug!("encode_enum_variant_info(id=%?)", id);
+
     let mut disr_val = 0;
     let mut i = 0;
     let vi = ty::enum_variants(ecx.tcx,

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

@@ -2079,15 +2079,15 @@ pub fn trans_item(ccx: @CrateContext, item: ast::item) {
         _ => fail!(~"trans_item"),
     };
     match /*bad*/copy item.node {
-      ast::item_fn(ref decl, purity, ref tps, ref body) => {
+      ast::item_fn(ref decl, purity, ref generics, ref body) => {
         if purity == ast::extern_fn  {
             let llfndecl = get_item_val(ccx, item.id);
             foreign::trans_foreign_fn(ccx,
                                      vec::append(
                                          /*bad*/copy *path,
                                          ~[path_name(item.ident)]),
                                       decl, body, llfndecl, item.id);
-        } else if tps.is_empty() {
+        } else if !generics.is_type_parameterized() {
             let llfndecl = get_item_val(ccx, item.id);
             trans_fn(ccx,
                      vec::append(/*bad*/copy *path, ~[path_name(item.ident)]),
@@ -2111,8 +2111,8 @@ pub fn trans_item(ccx: @CrateContext, item: ast::item) {
       ast::item_mod(ref m) => {
         trans_mod(ccx, m);
       }
-      ast::item_enum(ref enum_definition, ref tps) => {
-        if tps.is_empty() {
+      ast::item_enum(ref enum_definition, ref generics) => {
+        if !generics.is_type_parameterized() {
             let degen = (*enum_definition).variants.len() == 1u;
             let vi = ty::enum_variants(ccx.tcx, local_def(item.id));
             let mut i = 0;
@@ -2128,8 +2128,8 @@ pub fn trans_item(ccx: @CrateContext, item: ast::item) {
         };
         foreign::trans_foreign_mod(ccx, foreign_mod, abi);
       }
-      ast::item_struct(struct_def, tps) => {
-        if tps.is_empty() {
+      ast::item_struct(struct_def, generics) => {
+        if !generics.is_type_parameterized() {
             trans_struct_def(ccx, struct_def, path, item.id);
         }
       }

trunk/src/librustc/middle/typeck/collect.rs

@@ -861,7 +861,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: @ast::item)
                 // like "foo<X>".  This is because otherwise ty_to_str will
                 // print the name as merely "foo", as it has no way to
                 // reconstruct the value of X.
-                if !generics.is_empty() { t0 } else {
+                if generics.is_parameterized() { t0 } else {
                     ty::mk_with_id(tcx, t0, def_id)
                 }
             };

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

@@ -315,7 +315,7 @@ fn check_main_fn_ty(ccx: @mut CrateCtxt,
                 Some(ast_map::node_item(it,_)) => {
                     match it.node {
                         ast::item_fn(_, _, ref ps, _)
-                        if !ps.is_empty() => {
+                        if ps.is_parameterized() => {
                             tcx.sess.span_err(
                                 main_span,
                                 ~"main function is not allowed \

trunk/src/libsyntax/ast.rs

@@ -105,10 +105,6 @@ pub struct Lifetime {
     ident: ident
 }
 
-// a "Path" is essentially Rust's notion of a name;
-// for instance: core::cmp::Eq  .  It's represented
-// as a sequence of identifiers, along with a bunch
-// of supporting information.
 #[auto_encode]
 #[auto_decode]
 #[deriving_eq]
@@ -165,8 +161,14 @@ pub struct Generics {
 }
 
 pub impl Generics {
-    fn is_empty(&self) -> bool {
-        self.lifetimes.len() + self.ty_params.len() == 0
+    fn is_parameterized(&self) -> bool {
+        self.lifetimes.len() + self.ty_params.len() > 0
+    }
+    fn is_lt_parameterized(&self) -> bool {
+        self.lifetimes.len() > 0
+    }
+    fn is_type_parameterized(&self) -> bool {
+        self.ty_params.len() > 0
     }
 }
 

trunk/src/libsyntax/ext/tt/transcribe.rs

@@ -36,7 +36,6 @@ struct TtFrame {
 pub struct TtReader {
     sp_diag: span_handler,
     interner: @ident_interner,
-    // the unzipped tree:
     cur: @mut TtFrame,
     /* for MBE-style macro transcription */
     interpolations: std::oldmap::HashMap<ident, @named_match>,

trunk/src/libsyntax/parse/common.rs

@@ -119,6 +119,10 @@ pub impl Parser {
                                                 id: self.get_id() })
     }
 
+    fn parse_value_ident(&self) -> ast::ident {
+        return self.parse_ident();
+    }
+
     // consume token 'tok' if it exists. Returns true if the given
     // token was present, false otherwise.
     fn eat(&self, tok: &token::Token) -> bool {

trunk/src/libsyntax/parse/parser.rs

@@ -457,7 +457,7 @@ pub impl Parser {
             let pur = p.parse_fn_purity();
             // NB: at the moment, trait methods are public by default; this
             // could change.
-            let ident = p.parse_ident();
+            let ident = p.parse_method_name();
 
             let generics = p.parse_generics();
 
@@ -893,9 +893,16 @@ pub impl Parser {
         codemap::spanned { node: lit, span: mk_sp(lo, self.last_span.hi) }
     }
 
-    // parse a path that doesn't have type parameters attached
-    fn parse_path_without_tps(&self)
-        -> @ast::path {
+    fn parse_path_without_tps(&self) -> @path {
+        self.parse_path_without_tps_(|p| p.parse_ident(),
+                                     |p| p.parse_ident())
+    }
+
+    fn parse_path_without_tps_(
+        &self,
+        parse_ident: fn(&Parser) -> ident,
+        parse_last_ident: fn(&Parser) -> ident
+    ) -> @path {
         maybe_whole!(self, nt_path);
         let lo = self.span.lo;
         let global = self.eat(&token::MOD_SEP);
@@ -906,10 +913,10 @@ pub impl Parser {
                 && self.look_ahead(1u) == token::MOD_SEP;
 
             if is_not_last {
-                ids.push(self.parse_ident());
+                ids.push(parse_ident(self));
                 self.expect(&token::MOD_SEP);
             } else {
-                ids.push(self.parse_ident());
+                ids.push(parse_last_ident(self));
                 break;
             }
         }
@@ -920,7 +927,12 @@ pub impl Parser {
                      types: ~[] }
     }
 
-    fn parse_path_with_tps(&self, colons: bool) -> @ast::path {
+    fn parse_value_path(&self) -> @path {
+        self.parse_path_without_tps_(|p| p.parse_ident(),
+                                     |p| p.parse_value_ident())
+    }
+
+    fn parse_path_with_tps(&self, colons: bool) -> @path {
         debug!("parse_path_with_tps(colons=%b)", colons);
 
         maybe_whole!(self, nt_path);
@@ -2102,7 +2114,11 @@ pub impl Parser {
             }
 
             let lo1 = self.last_span.lo;
-            let fieldname = self.parse_ident();
+            let fieldname = if self.look_ahead(1u) == token::COLON {
+                self.parse_ident()
+            } else {
+                self.parse_value_ident()
+            };
             let hi1 = self.last_span.lo;
             let fieldpath = ast_util::ident_to_path(mk_sp(lo1, hi1),
                                                     fieldname);
@@ -2266,7 +2282,7 @@ pub impl Parser {
                 }
 
                 if is_plain_ident(&*self.token) && cannot_be_enum_or_struct {
-                    let name = self.parse_path_without_tps();
+                    let name = self.parse_value_path();
                     let sub;
                     if self.eat(&token::AT) {
                         sub = Some(self.parse_pat(refutable));
@@ -2339,7 +2355,7 @@ pub impl Parser {
                 *self.last_span,
                 ~"expected identifier, found path");
         }
-        let name = self.parse_path_without_tps();
+        let name = self.parse_value_path();
         let sub = if self.eat(&token::AT) {
             Some(self.parse_pat(refutable))
         } else { None };
@@ -2437,7 +2453,7 @@ pub impl Parser {
 
             // Potential trouble: if we allow macros with paths instead of
             // idents, we'd need to look ahead past the whole path here...
-            let pth = self.parse_path_without_tps();
+            let pth = self.parse_value_path();
             self.bump();
 
             let id = if *self.token == token::LPAREN {
@@ -2942,7 +2958,7 @@ pub impl Parser {
     }
 
     fn parse_fn_header(&self) -> (ident, ast::Generics) {
-        let id = self.parse_ident();
+        let id = self.parse_value_ident();
         let generics = self.parse_generics();
         (id, generics)
     }
@@ -2965,6 +2981,10 @@ pub impl Parser {
         (ident, item_fn(decl, purity, generics, body), Some(inner_attrs))
     }
 
+    fn parse_method_name(&self) -> ident {
+        self.parse_value_ident()
+    }
+
     fn parse_method(&self) -> @method {
         let attrs = self.parse_outer_attributes();
         let lo = self.span.lo;
@@ -2974,7 +2994,7 @@ pub impl Parser {
 
         let visa = self.parse_visibility();
         let pur = self.parse_fn_purity();
-        let ident = self.parse_ident();
+        let ident = self.parse_method_name();
         let generics = self.parse_generics();
         let (self_ty, decl) = do self.parse_fn_decl_with_self() |p| {
             p.parse_arg()
@@ -3098,7 +3118,7 @@ pub impl Parser {
     }
 
     fn parse_item_struct(&self) -> item_info {
-        let class_name = self.parse_ident();
+        let class_name = self.parse_value_ident();
         self.parse_region_param();
         let generics = self.parse_generics();
         if self.eat(&token::COLON) {
@@ -3326,7 +3346,7 @@ pub impl Parser {
     }
 
     fn parse_item_const(&self) -> item_info {
-        let id = self.parse_ident();
+        let id = self.parse_value_ident();
         self.expect(&token::COLON);
         let ty = self.parse_ty(false);
         self.expect(&token::EQ);
@@ -3724,7 +3744,7 @@ pub impl Parser {
                 kind = enum_variant_kind(nested_enum_def);
                 needs_comma = false;
             } else {
-                ident = self.parse_ident();
+                ident = self.parse_value_ident();
                 if self.eat(&token::LBRACE) {
                     // Parse a struct variant.
                     all_nullary = false;

trunk/src/libsyntax/print/pprust.rs

@@ -567,7 +567,7 @@ pub fn print_item(s: @ps, &&item: @ast::item) {
 
       ast::item_impl(ref generics, opt_trait, ty, ref methods) => {
         head(s, visibility_qualified(item.vis, ~"impl"));
-        if !generics.is_empty() {
+        if generics.is_parameterized() {
             print_generics(s, generics);
             space(s.s);
         }

trunk/src/test/run-pass/issue-5243.rs

@@ -0,0 +1,23 @@
+// Copyright 2012-2013 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.
+
+// Check that merely have lifetime parameters is not
+// enough for trans to consider this as non-monomorphic,
+// which led to various assertions and failures in turn.
+
+struct S<'self> {
+    v: &'self int
+}
+
+fn f<'lt>(_s: &S<'lt>) {}
+
+fn main() {
+    f(& S { v: &42 });
+}