---

yaml
---
r: 83735
b: refs/heads/try
c: d7b2c70
h: refs/heads/master
i:
  83733: 33ebf67
  83731: e3da8f8
  83727: 7669aa7
v: v3

Author: catamorphism

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: dd98f7089fec5ee8bc908089bcb89c6e352d8726
+refs/heads/try: d7b2c70a1335b866a26b63bcf13da67328b0cf3c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rust.md

@@ -1833,58 +1833,6 @@ fn main() {
 > individual functions, structs, methods and enum variants, *not* to
 > entire modules, traits, impls or enums themselves.
 
-### Compiler Features
-
-Certain aspects of Rust may be implemented in the compiler, but they're not
-necessarily ready for every-day use. These features are often of "prototype
-quality" or "almost production ready", but may not be stable enough to be
-considered a full-fleged language feature.
-
-For this reason, rust recognizes a special crate-level attribute of the form:
-
-~~~ {.xfail-test}
-#[feature(feature1, feature2, feature3)]
-~~~
-
-This directive informs the compiler that the feature list: `feature1`,
-`feature2`, and `feature3` should all be enabled. This is only recognized at a
-crate-level, not at a module-level. Without this directive, all features are
-considered off, and using the features will result in a compiler error.
-
-The currently implemented features of the compiler are:
-
-* `macro_rules` - The definition of new macros. This does not encompass
-                  macro-invocation, that is always enabled by default, this only
-                  covers the definition of new macros. There are currently
-                  various problems with invoking macros, how they interact with
-                  their environment, and possibly how they are used outside of
-                  location in which they are defined. Macro definitions are
-                  likely to change slightly in the future, so they are currently
-                  hidden behind this feature.
-
-* `globs` - Importing everything in a module through `*`. This is currently a
-            large source of bugs in name resolution for Rust, and it's not clear
-            whether this will continue as a feature or not. For these reasons,
-            the glob import statement has been hidden behind this feature flag.
-
-* `struct_variant` - Structural enum variants (those with named fields). It is
-                     currently unknown whether this style of enum variant is as
-                     fully supported as the tuple-forms, and it's not certain
-                     that this style of variant should remain in the language.
-                     For now this style of variant is hidden behind a feature
-                     flag.
-
-If a feature is promoted to a language feature, then all existing programs will
-start to receive compilation warnings about #[feature] directives which enabled
-the new feature (because the directive is no longer necessary). However, if
-a feature is decided to be removed from the language, errors will be issued (if
-there isn't a parser error first). The directive in this case is no longer
-necessary, and it's likely that existing code will break if the feature isn't
-removed.
-
-If a unknown feature is found in a directive, it results in a compiler error. An
-unknown feature is one which has never been recognized by the compiler.
-
 # Statements and expressions
 
 Rust is _primarily_ an expression language. This means that most forms of

branches/try/doc/tutorial.md

@@ -746,10 +746,6 @@ fn area(sh: Shape) -> f64 {
 }
 ~~~~
 
-> ***Note:*** This feature of the compiler is currently gated behind the
-> `#[feature(struct_variant)]` directive. More about these directives can be
-> found in the manual.
-
 ## Tuples
 
 Tuples in Rust behave exactly like structs, except that their fields
@@ -2669,10 +2665,6 @@ use farm::*;
 # fn main() { cow(); chicken() }
 ~~~
 
-> ***Note:*** This feature of the compiler is currently gated behind the
-> `#[feature(globs)]` directive. More about these directives can be found in
-> the manual.
-
 However, that's not all. You can also rename an item while you're bringing it into scope:
 
 ~~~

branches/try/src/libextra/extra.rs

@@ -33,8 +33,6 @@ Rust extras are part of the standard Rust distribution.
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-#[feature(macro_rules, globs)];
-
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 

branches/try/src/librustc/driver/driver.rs

@@ -159,8 +159,6 @@ pub fn phase_2_configure_and_expand(sess: Session,
     *sess.building_library = session::building_library(sess.opts.crate_type,
                                                        &crate, sess.opts.test);
 
-    time(time_passes, ~"gated feature checking", (), |_|
-         front::feature_gate::check_crate(sess, &crate));
 
     // strip before expansion to allow macros to depend on
     // configuration variables e.g/ in

branches/try/src/librustc/front/feature_gate.rs

@@ -32,10 +32,6 @@ pub fn replace_bound_regions_in_fn_sig(
 {
     let mut all_tys = ty::tys_in_fn_sig(fn_sig);
 
-    for &self_ty in opt_self_ty.iter() {
-        all_tys.push(self_ty);
-    }
-
     for &t in opt_self_ty.iter() { all_tys.push(t) }
 
     debug2!("replace_bound_regions_in_fn_sig(self_ty={:?}, fn_sig={}, \

branches/try/src/librustc/middle/typeck/check/regionmanip.rs

@@ -17,8 +17,6 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-#[feature(macro_rules, globs, struct_variant)];
-
 // Rustc tasks always run on a fixed_stack_segment, so code in this
 // module can call C functions (in particular, LLVM functions) with
 // impunity.
@@ -85,7 +83,6 @@ pub mod front {
     pub mod test;
     pub mod std_inject;
     pub mod assign_node_ids;
-    pub mod feature_gate;
 }
 
 pub mod back {

branches/try/src/librustc/rustc.rs

@@ -17,8 +17,6 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-#[feature(globs, struct_variant)];
-
 extern mod syntax;
 extern mod rustc;
 extern mod extra;

branches/try/src/librustdoc/rustdoc.rs

@@ -66,8 +66,6 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-#[feature(globs)];
-
 extern mod extra;
 extern mod rustc;
 extern mod syntax;

branches/try/src/librusti/rusti.rs

@@ -18,8 +18,6 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-#[feature(globs)];
-
 extern mod extra;
 extern mod rustc;
 extern mod syntax;

branches/try/src/librustpkg/rustpkg.rs

@@ -27,10 +27,8 @@ use context::{in_target, StopBefore, Link, Assemble, BuildContext};
 use package_id::PkgId;
 use package_source::PkgSrc;
 use workspace::pkg_parent_workspaces;
-use path_util::{installed_library_in_workspace, U_RWX, rust_path, system_library, target_build_dir};
-use messages::error;
-use conditions::nonexistent_package::cond;
-
+use path_util::{installed_library_in_workspace, U_RWX, system_library, target_build_dir};
+use path_util::default_workspace;
 pub use target::{OutputType, Main, Lib, Bench, Test, JustOne, lib_name_of, lib_crate_filename};
 use workcache_support::{digest_file_with_date, digest_only_date};
 
@@ -432,26 +430,26 @@ impl<'self> Visitor<()> for ViewItemVisitor<'self> {
                                lib_name.to_str());
                         // Try to install it
                         let pkg_id = PkgId::new(lib_name);
+                        // Find all the workspaces in the RUST_PATH that contain this package.
                         let workspaces = pkg_parent_workspaces(&self.context.context,
                                                                &pkg_id);
-                        let source_workspace = if workspaces.is_empty() {
-                            error(format!("Couldn't find package {} \
-                                       in any of the workspaces in the RUST_PATH ({})",
-                                       lib_name,
-                                       rust_path().map(|s| s.to_str()).connect(":")));
-                            cond.raise((pkg_id.clone(), ~"Dependency not found"))
-                        }
-                            else {
-                            workspaces[0]
-                        };
+                        // Two cases:
+                        // (a) `workspaces` is empty. That means there's no local source
+                        // for this package. In that case, we pass the default workspace
+                        // into `PkgSrc::new`, so that if it exists as a remote repository,
+                        // its sources will be fetched into it.
+                        // (b) `workspaces` is non-empty -- we found a local source for this
+                        // package.
+                        let dest_workspace = if workspaces.is_empty() {
+                            default_workspace()
+                        } else { workspaces[0] };
+                        let pkg_src = PkgSrc::new(dest_workspace,
+                        // Use the rust_path_hack to search for dependencies iff
+                        // we were already using it
+                                                  self.context.context.use_rust_path_hack,
+                                                  pkg_id);
                         let (outputs_disc, inputs_disc) =
-                            self.context.install(PkgSrc::new(source_workspace.clone(),
-                            // Use the rust_path_hack to search for dependencies iff
-                            // we were already using it
-                            self.context.context.use_rust_path_hack,
-                                                             pkg_id),
-                                                 &JustOne(Path(
-                                    lib_crate_filename)));
+                            self.context.install(pkg_src, &JustOne(Path(lib_crate_filename)));
                         debug2!("Installed {}, returned {:?} dependencies and \
                                {:?} transitive dependencies",
                                lib_name, outputs_disc.len(), inputs_disc.len());