---

yaml
---
r: 7729
b: refs/heads/snap-stage3
c: 7da3733
h: refs/heads/master
i:
  7727: ff2b7c9
v: v3

Author: graydon

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: dfae48736ffd3504598b15e0f350269a8d1b1063
+refs/heads/snap-stage3: 7da3733c73e7a3ba4c18f3927bbbe185598ad233
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/snap-stage3/doc/rust.md

@@ -761,9 +761,7 @@ fn main() {
 ##### Export declarations
 
 ~~~~~~~~ {.ebnf .gram}
-export_decl : "export" ident [ ',' ident ] * 
-            | "export" ident "::{}"
-            | "export" ident '{' ident [ ',' ident ] * '}' ;
+export_decl : "export" ident [ ',' ident ] * ;
 ~~~~~~~~
 
 An _export declaration_ restricts the set of local names within a module that
@@ -815,40 +813,6 @@ mod foo {
 }
 ~~~~~~~~
 
-When exporting the name of an `enum` type `t`, by default, the module also
-implicitly exports all of `t`'s constructors. For example:
-
-~~~~~~~~
-mod foo {
-    export t;
-    
-    enum t {a, b, c};
-}
-~~~~~~~~
-
-Here, `foo` imports `t`, `a`, `b`, and `c`. 
-
-The second and third forms of export declaration can be used to export
-an `enum` item without exporting all of its constructors. These two
-forms can only be used to export an `enum` item. The second form
-exports the `enum` type name without exporting any of its
-constructors, achieving a simple kind of data abstraction. The third
-form exports an `enum` type name along with a subset of its
-constructors. For example:
-
-~~~~~~~~
-mod foo {
-    export abstract{};
-    export slightly_abstract{a, b};
-
-    enum abstract {x, y, z}
-    enum slightly_abstract {a, b, c, d}
-} 
-~~~~~~~~
-
-Module `foo` exports the types `abstract` and `slightly_abstract`, as well as
-constructors `a` and `b`, but doesn't export constructors `x`, `y`, `z`, `c`,
-or `d`.
 
 ### Functions
 

branches/snap-stage3/src/cargo/cargo.rs

@@ -34,7 +34,6 @@ type package = {
     uuid: str,
     url: str,
     method: str,
-    description: str,
     ref: option::t<str>,
     tags: [str]
 };
@@ -270,15 +269,12 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
         }
         _ { }
     }
-    // TODO: make this *actually* get the description from the .rc file.
-    let description = "This package's description.";
     vec::grow(src.packages, 1u, {
         // source: _source(src),
         name: name,
         uuid: uuid,
         url: url,
         method: method,
-        description: description,
         ref: ref,
         tags: tags
     });
@@ -685,9 +681,6 @@ fn print_pkg(s: source, p: package) {
         m = m + " [" + str::connect(p.tags, ", ") + "]";
     }
     info(m);
-    if p.description != "" {
-        print("   >> " + p.description)
-    }
 }
 fn cmd_list(c: cargo, argv: [str]) {
     for_each_package(c, { |s, p|

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

@@ -1403,8 +1403,6 @@ fn index_mod(md: ast::_mod) -> mod_index {
           }
           //globbed imports have to be resolved lazily.
           ast::view_item_import_glob(_, _) | ast::view_item_export(_, _) {}
-          // exports: ignore
-          _ {}
         }
     }
     for it: @ast::item in md.items {
@@ -1766,32 +1764,6 @@ fn check_exports(e: @env) {
         }
     }
 
-    fn check_enum_ok(e: @env, sp:span, id: ident, val: @indexed_mod)
-        -> node_id {
-        alt val.index.find(id) {
-           none { e.sess.span_fatal(sp, #fmt("error: undefined id %s\
-                         in an export", id)); }
-           some(ms) {
-             let maybe_id = list::find(ms) {|m|
-                  alt m {
-                     mie_item(an_item) {
-                      alt an_item.node {
-                          item_tag(_,_) { /* OK */ some(an_item.id) }
-                          _ { none }
-                      }
-                     }
-                     _ { none }
-               }
-             };
-             alt maybe_id {
-                some(an_id) { ret an_id; }
-                _ { e.sess.span_fatal(sp, #fmt("error: %s does not refer \
-                          to an enumeration", id)); }
-             }
-         }
-      }
-    }
-
     e.mod_map.values {|val|
         alt val.m {
           some(m) {
@@ -1802,44 +1774,14 @@ fn check_exports(e: @env) {
                         check_export(e, ident, val, vi);
                     }
                   }
-                  ast::view_item_export_tag_none(id, _) {
-                      let _ = check_enum_ok(e, vi.span, id, val);
-                  }
-                  ast::view_item_export_tag_some(id, ids, _) {
-                      // Check that it's an enum and all the given variants
-                      // belong to it
-                      let parent_id = check_enum_ok(e, vi.span, id, val);
-                      for variant_id in ids {
-                         alt val.index.find(variant_id.node.name) {
-                            some(ms) {
-                                list::iter(ms) {|m|
-                                   alt m {
-                                     mie_tag_variant(parent_item,_) {
-                                       if parent_item.id != parent_id {
-                                          e.sess.span_err(vi.span,
-                                           #fmt("variant %s \
-                                           doesn't belong to enum %s",
-                                                variant_id.node.name,
-                                                id));
-                                       }
-                                     }
-                                     _ { e.sess.span_err(vi.span,
-                                         #fmt("%s is not a \
-                                         variant", variant_id.node.name));  }
-                                       }}
-                            }
-                            _ { e.sess.span_err(vi.span, #fmt("%s is not a\
-                                         variant", variant_id.node.name));  }
-                      }
-                     }
-                  }
                   _ { }
                 }
             }
           }
           none { }
         }
-    }}
+    };
+}
 
 // Impl resolution
 

branches/snap-stage3/src/comp/rustc.rc

@@ -5,7 +5,7 @@
        uuid = "0ce89b41-2f92-459e-bbc1-8f5fe32f16cf",
        url = "http://rust-lang.org/src/rustc")];
 
-#[comment = "The Rust compiler"];
+#[desc = "The Rust compiler"];
 #[license = "MIT"];
 #[crate_type = "lib"];
 

branches/snap-stage3/src/comp/syntax/ast.rs

@@ -442,7 +442,7 @@ enum view_item_ {
     // export foo::{}
     view_item_export_tag_none(ident, node_id),
     // export foo::{bar, baz, blat}
-    view_item_export_tag_some(ident, [import_ident], node_id)
+    view_item_export_tag_some(ident, [ident], node_id)
 }
 
 // Meta-data associated with an item

branches/snap-stage3/src/comp/syntax/ast_util.rs

@@ -113,16 +113,12 @@ fn float_ty_to_str(t: float_ty) -> str {
 
 fn is_exported(i: ident, m: _mod) -> bool {
     let nonlocal = true;
-    let parent_tag : option<ident> = none;
     for it: @item in m.items {
         if it.ident == i { nonlocal = false; }
         alt it.node {
           item_tag(variants, _) {
             for v: variant in variants {
-                if v.node.name == i {
-                   nonlocal = false;
-                   parent_tag = some(it.ident);
-                }
+                if v.node.name == i { nonlocal = false; }
             }
           }
           _ { }
@@ -133,28 +129,9 @@ fn is_exported(i: ident, m: _mod) -> bool {
     for vi: @view_item in m.view_items {
         alt vi.node {
           view_item_export(ids, _) {
-              // If any of ids is a tag, we want to consider
-              // all the variants to be exported
-            for id in ids {
-                if str::eq(i, id) { ret true; }
-                alt parent_tag {
-                    some(parent_tag_id) {
-                        if str::eq(id, parent_tag_id) { ret true; }
-                    }
-                    _ { }
-                 }
-            }
+            for id in ids { if str::eq(i, id) { ret true; } }
             count += 1u;
           }
-          view_item_export_tag_none(id, _) {
-              if str::eq(i, id) { ret true; }
-              count += 1u;
-          }
-          view_item_export_tag_some(id, ids, _) {
-              if str::eq(i, id) { ret true; }
-              for id in ids { if str::eq(i, id.node.name) { ret true; } }
-              count += 1u;
-          }
           _ {/* fall through */ }
         }
     }

branches/snap-stage3/src/comp/syntax/parse/parser.rs

@@ -194,18 +194,10 @@ fn spanned<T: copy>(lo: uint, hi: uint, node: T) -> spanned<T> {
 fn parse_ident(p: parser) -> ast::ident {
     alt p.token {
       token::IDENT(i, _) { p.bump(); ret p.get_str(i); }
-      _ { p.fatal("expecting ident, found "
-                  + token::to_str(p.reader, p.token)); }
+      _ { p.fatal("expecting ident"); }
     }
 }
 
-fn parse_import_ident(p: parser) -> ast::import_ident {
-    let lo = p.span.lo;
-    let ident = parse_ident(p);
-    let hi = p.span.hi;
-    ret spanned(lo, hi, {name: ident, id: p.get_id()});
-}
-
 fn parse_value_ident(p: parser) -> ast::ident {
     check_bad_word(p);
     ret parse_ident(p);
@@ -2324,6 +2316,12 @@ fn parse_rest_import_name(p: parser, first: ast::ident,
 
 
           token::LBRACE {
+            fn parse_import_ident(p: parser) -> ast::import_ident {
+                let lo = p.span.lo;
+                let ident = parse_ident(p);
+                let hi = p.span.hi;
+                ret spanned(lo, hi, {name: ident, id: p.get_id()});
+            }
             let from_idents_ =
                 parse_seq(token::LBRACE, token::RBRACE, seq_sep(token::COMMA),
                           parse_import_ident, p).node;
@@ -2394,9 +2392,9 @@ fn parse_import(p: parser) -> ast::view_item_ {
 }
 
 fn parse_tag_export(p:parser, tyname:ast::ident) -> ast::view_item_ {
-    let tagnames:[ast::import_ident] =
+    let tagnames:[ast::ident] =
         parse_seq(token::LBRACE, token::RBRACE,
-             seq_sep(token::COMMA), {|p| parse_import_ident(p) }, p).node;
+                    seq_sep(token::COMMA), {|p| parse_ident(p) }, p).node;
     let id = p.get_id();
     if vec::is_empty(tagnames) {
        ret ast::view_item_export_tag_none(tyname, id);
@@ -2409,8 +2407,9 @@ fn parse_tag_export(p:parser, tyname:ast::ident) -> ast::view_item_ {
 fn parse_export(p: parser) -> ast::view_item_ {
     let first = parse_ident(p);
     alt p.token {
-       token::MOD_SEP {
+       token::COLON {
            p.bump();
+           expect(p, token::COLON);
            ret parse_tag_export(p, first);
        }
        t {

branches/snap-stage3/src/comp/syntax/print/pprust.rs

@@ -1303,19 +1303,6 @@ fn print_view_item(s: ps, item: @ast::view_item) {
         commasep(s, inconsistent, ids,
                  fn@(s: ps, &&w: ast::ident) { word(s.s, w) });
       }
-      ast::view_item_export_tag_none(id, _) {
-          head(s, "export");
-          word(s.s, id);
-          word(s.s, "::{}");
-      }
-      ast::view_item_export_tag_some(id, ids, _) {
-          head(s, "export");
-          word(s.s, id);
-          word(s.s, "::{");
-          commasep(s, inconsistent, ids, fn@(s:ps, &&w: ast::import_ident) {
-                  word(s.s, w.node.name) });
-          word(s.s, "}");
-      }
     }
     word(s.s, ";");
     end(s); // end inner head-block

branches/snap-stage3/src/etc/rustdoc.py

@@ -7,24 +7,6 @@
 #[license = "MIT"];
 #[crate_type = "lib"];
 
-#[doc(
-    brief = "The Rust core library",
-    desc = "
-The core library provides functionality that is closely tied to
-the Rust built-in types and runtime services, or that is used in nearly
-every non-trivial program.
-
-The core library is linked by default to all crates and the contents
-imported. The effect is as though the user had written the following:
-
-~~~
-use core;
-import core::*;
-~~~
-
-This behavior can be disabled with the `--no-core` compiler flag."
-)];
-
 export box, char, float, bessel, f32, f64, int, str, ptr;
 export uint, u8, u32, u64, vec, bool;
 export either, option, result;