---

yaml
---
r: 147223
b: refs/heads/try2
c: aafed3e
h: refs/heads/master
i:
  147221: b9a8919
  147219: d2a4380
  147215: 5783dda
v: v3

Author: bors

[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: 5de42701a87cb0e517921cce7bc3a512e513301c
+refs/heads/try2: aafed3ece58be56e5e88c51d32d065254f10309a
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -609,10 +609,8 @@ Attributes on the anonymous crate module define important metadata that influenc
 the behavior of the compiler.
 
 ~~~~
-// Linkage attributes
-#[ link(name = "projx",
-        vers = "2.5",
-        uuid = "9cccc5d5-aceb-4af5-8285-811211826b82") ];
+// Package ID
+#[ pkgid = "projx#2.5" ];
 
 // Additional metadata attributes
 #[ desc = "Project X" ];
@@ -775,36 +773,24 @@ An _`extern mod` declaration_ specifies a dependency on an external crate.
 The external crate is then bound into the declaring scope
 as the `ident` provided in the `extern_mod_decl`.
 
-The external crate is resolved to a specific `soname` at compile time,
-and a runtime linkage requirement to that `soname` is passed to the linker for
-loading at runtime.
-The `soname` is resolved at compile time by scanning the compiler's library path
-and matching the `link_attrs` provided in the `use_decl` against any `#link` attributes that
-were declared on the external crate when it was compiled.
-If no `link_attrs` are provided,
-a default `name` attribute is assumed,
-equal to the `ident` given in the `use_decl`.
-
-Optionally, an identifier in an `extern mod` declaration may be followed by an equals sign,
-then a string literal denoting a relative path on the filesystem.
-This path should exist in one of the directories in the Rust path,
-which by default contains the `.rust` subdirectory of the current directory and each of its parents,
-as well as any directories in the colon-separated (or semicolon-separated on Windows)
-list of paths that is the `RUST_PATH` environment variable.
-The meaning of `extern mod a = "b/c/d";`, supposing that `/a` is in the RUST_PATH,
-is that the name `a` should be taken as a reference to the crate whose absolute location is
-`/a/b/c/d`.
+The external crate is resolved to a specific `soname` at compile time, and a
+runtime linkage requirement to that `soname` is passed to the linker for
+loading at runtime.  The `soname` is resolved at compile time by scanning the
+compiler's library path and matching the optional `pkgid` provided as a string literal
+against the `pkgid` attributes that were declared on the external crate when
+it was compiled.  If no `pkgid` is provided, a default `name` attribute is
+assumed, equal to the `ident` given in the `extern_mod_decl`.
 
 Four examples of `extern mod` declarations:
 
 ~~~~ {.xfail-test}
-extern mod pcre (uuid = "54aba0f8-a7b1-4beb-92f1-4cf625264841");
+extern mod pcre;
 
-extern mod extra; // equivalent to: extern mod extra ( name = "extra" );
+extern mod extra; // equivalent to: extern mod extra = "extra";
 
-extern mod rustextra (name = "extra"); // linking to 'extra' under another name
+extern mod rustextra = "extra"; // linking to 'extra' under another name
 
-extern mod complicated_mod = "some-file/in/the-rust/path";
+extern mod foo = "some/where/foo#1.0"; // a full package ID for rustpkg
 ~~~~
 
 ##### Use declarations
@@ -1742,7 +1728,8 @@ names are effectively reserved. Some significant attributes include:
 * The `doc` attribute, for documenting code in-place.
 * The `cfg` attribute, for conditional-compilation by build-configuration.
 * The `lang` attribute, for custom definitions of traits and functions that are known to the Rust compiler (see [Language items](#language-items)).
-* The `link` attribute, for describing linkage metadata for a crate.
+* The `link` attribute, for describing linkage metadata for a extern blocks.
+* The `pkgid` attribute, for describing the package ID of a crate.
 * The `test` attribute, for marking functions as unit tests.
 * The `allow`, `warn`, `forbid`, and `deny` attributes, for
   controlling lint checks (see [Lint check attributes](#lint-check-attributes)).
@@ -3795,7 +3782,7 @@ specified then log level 4 is assumed.  Debug messages can be omitted
 by passing `--cfg ndebug` to `rustc`.
 
 As an example, to see all the logs generated by the compiler, you would set
-`RUST_LOG` to `rustc`, which is the crate name (as specified in its `link`
+`RUST_LOG` to `rustc`, which is the crate name (as specified in its `pkgid`
 [attribute](#attributes)). To narrow down the logs to just crate resolution,
 you would set it to `rustc::metadata::creader`. To see just error logging
 use `rustc=0`.

branches/try2/doc/rustdoc.md

@@ -13,7 +13,7 @@ comments":
 ~~~
 // the "link" crate attribute is currently required for rustdoc, but normally
 // isn't needed.
-#[link(name="universe")];
+#[pkgid = "universe"];
 #[crate_type="lib"];
 
 //! Tools for dealing with universes (this is a doc comment, and is shown on

branches/try2/doc/rustpkg.md

@@ -89,6 +89,10 @@ as well as `foo/src/bar/extras/baz/lib.rs`,
 then both `bar` and `bar/extras/baz` are valid package identifiers
 in the workspace `foo`.
 
+Because rustpkg uses generic source file names as the main inputs, you will
+need to specify the package identifier in them using the `pkgid` attribute
+on the crate.
+
 ## Source files
 
 rustpkg searches for four different fixed filenames in order to determine the crates to build:
@@ -108,9 +112,6 @@ When building a package that is not under version control,
 or that has no tags, `rustpkg` assumes the intended version is 0.1.
 
 > **Note:** A future version of rustpkg will support semantic versions.
-> Also, a future version will add the option to specify a version with a metadata
-> attribute like `#[link(vers = "3.1415")]` inside the crate module,
-> though this attribute will never be mandatory.
 
 # Dependencies
 

branches/try2/doc/tutorial.md

@@ -3070,22 +3070,21 @@ Therefore, if you plan to compile your crate as a library, you should annotate i
 // lib.rs
 
 # #[crate_type = "lib"];
-// Crate linkage metadata
-#[link(name = "farm", vers = "2.5")];
+// Package ID
+#[pkgid = "farm#2.5"];
 
 // ...
 # fn farm() {}
 ~~~~
 
-You can also in turn require in a `extern mod` statement that certain link metadata items match some criteria.
-For that, Rust currently parses a comma-separated list of name/value pairs that appear after
-it, and ensures that they match the attributes provided in the `link` attribute of a crate file.
-This enables you to, e.g., pick a crate based on its version number, or link a library under a
-different name. For example, these two `mod` statements would both accept and select the crate define above:
+You can also specify package ID information in a `extern mod` statement.  For
+example, these `extern mod` statements would both accept and select the
+crate define above:
 
 ~~~~ {.xfail-test}
-extern mod farm(vers = "2.5");
-extern mod my_farm(name = "farm", vers = "2.5");
+extern mod farm;
+extern mod farm = "farm#2.5";
+extern mod my_farm = "farm";
 ~~~~
 
 Other crate settings and metadata include things like enabling/disabling certain errors or warnings,
@@ -3096,21 +3095,18 @@ or setting the crate type (library or executable) explicitly:
 // ...
 
 // This crate is a library ("bin" is the default)
+#[pkgid = "farm#2.5"];
 #[crate_type = "lib"];
 
 // Turn on a warning
 #[warn(non_camel_case_types)]
 # fn farm() {}
 ~~~~
 
-If you're compiling your crate with `rustpkg`,
-link annotations will not be necessary, because they get
-inferred by `rustpkg` based on the Package id and naming conventions.
-
-
-> ***Note:*** The rules regarding link metadata, both as attributes and on `extern mod`,
-              as well as their interaction with `rustpkg`
-              are currently not clearly defined and will likely change in the future.
+> ***Note:*** The rules regarding package IDs, both as attributes and as used
+              in `extern mod`, as well as their interaction with `rustpkg` are
+              currently not clearly defined and will likely change in the
+              future.
 
 ## A minimal example
 
@@ -3120,7 +3116,7 @@ We define two crates, and use one of them as a library in the other.
 
 ~~~~
 // world.rs
-#[link(name = "world", vers = "0.42")];
+#[pkgid = "world#0.42"];
 # extern mod extra;
 pub fn explore() -> &'static str { "world" }
 # fn main() {}
@@ -3144,7 +3140,7 @@ Now compile and run like this (adjust to your platform if necessary):
 Notice that the library produced contains the version in the file name
 as well as an inscrutable string of alphanumerics. As explained in the previous paragraph,
 these are both part of Rust's library versioning scheme. The alphanumerics are
-a hash representing the crates link metadata.
+a hash representing the crates package ID.
 
 ## The standard library and the prelude
 

branches/try2/mk/platform.mk

@@ -287,7 +287,7 @@ CFG_LIB_GLOB_arm-linux-androideabi=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_arm-linux-androideabi=lib$(1)-*.dylib.dSYM
 CFG_GCCISH_CFLAGS_arm-linux-androideabi := -Wall -g -fPIC -D__arm__ -DANDROID -D__ANDROID__
 CFG_GCCISH_CXXFLAGS_arm-linux-androideabi := -fno-rtti
-CFG_GCCISH_LINK_FLAGS_arm-linux-androideabi := -shared -fPIC -ldl -g -lm -lsupc++ -lgnustl_shared
+CFG_GCCISH_LINK_FLAGS_arm-linux-androideabi := -shared -fPIC -ldl -g -lm -lsupc++
 CFG_GCCISH_DEF_FLAG_arm-linux-androideabi := -Wl,--export-dynamic,--dynamic-list=
 CFG_GCCISH_PRE_LIB_FLAGS_arm-linux-androideabi := -Wl,-whole-archive
 CFG_GCCISH_POST_LIB_FLAGS_arm-linux-androideabi := -Wl,-no-whole-archive

branches/try2/mk/tests.mk

@@ -156,8 +156,6 @@ $(info check: android device test dir $(CFG_ADB_TEST_DIR) ready \
  $(shell adb shell mkdir $(CFG_ADB_TEST_DIR)) \
  $(shell adb shell mkdir $(CFG_ADB_TEST_DIR)/tmp) \
  $(shell adb push $(S)src/etc/adb_run_wrapper.sh $(CFG_ADB_TEST_DIR) 1>/dev/null) \
- $(shell adb push $(CFG_ANDROID_CROSS_PATH)/arm-linux-androideabi/lib/armv7-a/libgnustl_shared.so \
-                  $(CFG_ADB_TEST_DIR) 1>/dev/null) \
  $(shell adb push $(TLIB2_T_arm-linux-androideabi_H_$(CFG_BUILD))/$(CFG_RUNTIME_arm-linux-androideabi) \
                   $(CFG_ADB_TEST_DIR)) \
  $(shell adb push $(TLIB2_T_arm-linux-androideabi_H_$(CFG_BUILD))/$(STDLIB_GLOB_arm-linux-androideabi) \

branches/try2/src/etc/combine-tests.py

@@ -41,11 +41,15 @@ def scrub(b):
 
 c = open("tmp/run_pass_stage2.rc", "w")
 i = 0
-c.write("// AUTO-GENERATED FILE: DO NOT EDIT\n")
-c.write("#[pkgid=\"run_pass_stage2#0.1\"];\n")
-c.write("#[link(name=\"run_pass_stage2\", vers=\"0.1\")];\n")
-c.write("#[feature(globs, macro_rules, struct_variant, managed_boxes)];\n")
-c.write("#[allow(attribute_usage)];\n")
+c.write(
+"""
+// AUTO-GENERATED FILE: DO NOT EDIT
+#[pkgid=\"run_pass_stage2#0.1\"];
+#[link(name=\"run_pass_stage2\", vers=\"0.1\")];
+#[feature(globs, macro_rules, struct_variant, managed_boxes)];
+#[allow(warnings)];
+"""
+)
 for t in stage2_tests:
     p = os.path.join(run_pass, t)
     p = p.replace("\\", "\\\\")
@@ -56,15 +60,19 @@ def scrub(b):
 
 
 d = open("tmp/run_pass_stage2_driver.rs", "w")
-d.write("// AUTO-GENERATED FILE: DO NOT EDIT\n")
-d.write("#[feature(globs, managed_boxes)];\n")
-d.write("extern mod extra;\n")
-d.write("extern mod run_pass_stage2;\n")
-d.write("use run_pass_stage2::*;\n")
-d.write("use std::io;\n")
-d.write("use std::io::Writer;\n")
-d.write("fn main() {\n")
-d.write("    let mut out = io::stdout();\n")
+d.write(
+"""
+// AUTO-GENERATED FILE: DO NOT EDIT
+#[feature(globs, managed_boxes)];
+extern mod extra;
+extern mod run_pass_stage2;
+use run_pass_stage2::*;
+use std::io;
+use std::io::Writer;
+fn main() {
+    let mut out = io::stdout();
+"""
+)
 i = 0
 for t in stage2_tests:
     p = os.path.join("test", "run-pass", t)

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

@@ -37,6 +37,7 @@ fn should_explore(tcx: ty::ctxt, def_id: ast::DefId) -> bool {
     match tcx.items.find(&def_id.node) {
         Some(&ast_map::node_item(..))
         | Some(&ast_map::node_method(..))
+        | Some(&ast_map::node_foreign_item(..))
         | Some(&ast_map::node_trait_method(..)) => true,
         _ => false
     }
@@ -61,11 +62,10 @@ impl MarkSymbolVisitor {
         }
     }
 
-    fn lookup_and_handle_definition(&mut self, id: &ast::NodeId,
-                                    span: codemap::Span) {
+    fn lookup_and_handle_definition(&mut self, id: &ast::NodeId) {
         let def = match self.tcx.def_map.find(id) {
             Some(&def) => def,
-            None => self.tcx.sess.span_bug(span, "def ID not in def map?!"),
+            None => return
         };
         let def_id = match def {
             ast::DefVariant(enum_id, _, _) => Some(enum_id),
@@ -107,8 +107,7 @@ impl MarkSymbolVisitor {
                 match item.node {
                     ast::item_fn(..)
                     | ast::item_ty(..)
-                    | ast::item_static(..)
-                    | ast::item_foreign_mod(_) => {
+                    | ast::item_static(..) => {
                         visit::walk_item(self, item, ());
                     }
                     _ => ()
@@ -120,6 +119,9 @@ impl MarkSymbolVisitor {
             ast_map::node_method(method, _, _) => {
                 visit::walk_block(self, method.body, ());
             }
+            ast_map::node_foreign_item(foreign_item, _, _, _) => {
+                visit::walk_foreign_item(self, foreign_item, ());
+            }
             _ => ()
         }
     }
@@ -129,9 +131,6 @@ impl Visitor<()> for MarkSymbolVisitor {
 
     fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
         match expr.node {
-            ast::ExprPath(_) | ast::ExprStruct(..) => {
-                self.lookup_and_handle_definition(&expr.id, expr.span);
-            }
             ast::ExprMethodCall(..) => {
                 match self.method_map.find(&expr.id) {
                     Some(&typeck::method_map_entry {
@@ -160,12 +159,16 @@ impl Visitor<()> for MarkSymbolVisitor {
     fn visit_ty(&mut self, typ: &ast::Ty, _: ()) {
         match typ.node {
             ast::ty_path(_, _, ref id) => {
-                self.lookup_and_handle_definition(id, typ.span);
+                self.lookup_and_handle_definition(id);
             }
             _ => visit::walk_ty(self, typ, ()),
         }
     }
 
+    fn visit_path(&mut self, _: &ast::Path, id: ast::NodeId, _: ()) {
+        self.lookup_and_handle_definition(&id);
+    }
+
     fn visit_item(&mut self, _item: @ast::item, _: ()) {
         // Do not recurse into items. These items will be added to the
         // worklist and recursed into manually if necessary.
@@ -299,19 +302,31 @@ impl DeadVisitor {
         }
         false
     }
+
+    fn warn_dead_code(&mut self, id: ast::NodeId,
+                      span: codemap::Span, ident: &ast::Ident) {
+        self.tcx.sess.add_lint(dead_code, id, span,
+                               format!("code is never used: `{}`",
+                                       token::ident_to_str(ident)));
+    }
 }
 
 impl Visitor<()> for DeadVisitor {
     fn visit_item(&mut self, item: @ast::item, _: ()) {
         let ctor_id = get_struct_ctor_id(item);
         if !self.symbol_is_live(item.id, ctor_id) && should_warn(item) {
-            self.tcx.sess.add_lint(dead_code, item.id, item.span,
-                                   format!("code is never used: `{}`",
-                                           token::ident_to_str(&item.ident)));
+            self.warn_dead_code(item.id, item.span, &item.ident);
         }
         visit::walk_item(self, item, ());
     }
 
+    fn visit_foreign_item(&mut self, fi: @ast::foreign_item, _: ()) {
+        if !self.symbol_is_live(fi.id, None) {
+            self.warn_dead_code(fi.id, fi.span, &fi.ident);
+        }
+        visit::walk_foreign_item(self, fi, ());
+    }
+
     fn visit_fn(&mut self, fk: &visit::fn_kind,
                 _: &ast::fn_decl, block: ast::P<ast::Block>,
                 span: codemap::Span, id: ast::NodeId, _: ()) {
@@ -320,10 +335,7 @@ impl Visitor<()> for DeadVisitor {
             visit::fk_method(..) => {
                 let ident = visit::name_of_fn(fk);
                 if !self.symbol_is_live(id, None) {
-                    self.tcx.sess
-                            .add_lint(dead_code, id, span,
-                                      format!("code is never used: `{}`",
-                                              token::ident_to_str(&ident)));
+                    self.warn_dead_code(id, span, &ident);
                 }
             }
             _ => ()