---

yaml
---
r: 95262
b: refs/heads/dist-snap
c: bed669c
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: e293026e9c41a5322d95098c30e193fdb815c1bb
+refs/heads/dist-snap: bed669cba6c20e3bdbe01e87ce4566b60d7bc232
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -239,14 +239,13 @@ literal : string_lit | char_lit | num_lit ;
 
 ~~~~~~~~ {.ebnf .gram}
 char_lit : '\x27' char_body '\x27' ;
-string_lit : '"' string_body * '"' | 'r' raw_string ;
+string_lit : '"' string_body * '"' ;
 
 char_body : non_single_quote
           | '\x5c' [ '\x27' | common_escape ] ;
 
 string_body : non_double_quote
             | '\x5c' [ '\x22' | common_escape ] ;
-raw_string : '"' raw_string_body '"' | '#' raw_string '#' ;
 
 common_escape : '\x5c'
               | 'n' | 'r' | 't' | '0'
@@ -268,10 +267,9 @@ which must be _escaped_ by a preceding U+005C character (`\`).
 
 A _string literal_ is a sequence of any Unicode characters enclosed within
 two `U+0022` (double-quote) characters, with the exception of `U+0022`
-itself, which must be _escaped_ by a preceding `U+005C` character (`\`),
-or a _raw string literal_.
+itself, which must be _escaped_ by a preceding `U+005C` character (`\`).
 
-Some additional _escapes_ are available in either character or non-raw string
+Some additional _escapes_ are available in either character or string
 literals. An escape starts with a `U+005C` (`\`) and continues with one of
 the following forms:
 
@@ -287,35 +285,9 @@ the following forms:
   * A _whitespace escape_ is one of the characters `U+006E` (`n`), `U+0072`
     (`r`), or `U+0074` (`t`), denoting the unicode values `U+000A` (LF),
     `U+000D` (CR) or `U+0009` (HT) respectively.
-  * The _backslash escape_ is the character `U+005C` (`\`) which must be
+  * The _backslash escape_ is the character U+005C (`\`) which must be
     escaped in order to denote *itself*.
 
-Raw string literals do not process any escapes. They start with the character
-`U+0072` (`r`), followed zero or more of the character `U+0023` (`#`) and a
-`U+0022` (double-quote) character. The _raw string body_ is not defined in the
-EBNF grammar above: it can contain any sequence of Unicode characters and is
-terminated only by another `U+0022` (double-quote) character, followed by the
-same number of `U+0023` (`#`) characters that preceeded the opening `U+0022`
-(double-quote) character.
-
-All Unicode characters contained in the raw string body represent themselves,
-the characters `U+0022` (double-quote) (except when followed by at least as
-many `U+0023` (`#`) characters as were used to start the raw string literal) or
-`U+005C` (`\`) do not have any special meaning.
-
-Examples for string literals:
-
-~~~
-"foo"; r"foo";                     // foo
-"\"foo\""; r#""foo""#;             // "foo"
-
-"foo #\"# bar";
-r##"foo #"# bar"##;                // foo #"# bar
-
-"\x52"; "R"; r"R";                 // R
-"\\x52"; r"\x52";                  // \x52
-~~~
-
 #### Number literals
 
 ~~~~~~~~ {.ebnf .gram}
@@ -1529,171 +1501,6 @@ is `extern "abi" fn(A1, ..., An) -> R`,
 where `A1...An` are the declared types of its arguments
 and `R` is the decalred return type.
 
-## Visibility and Privacy
-
-These two terms are often used interchangeably, and what they are attempting to
-convey is the answer to the question "Can this item be used at this location?"
-
-Rust's name resolution operates on a global hierarchy of namespaces. Each level
-in the hierarchy can be thought of as some item. The items are one of those
-mentioned above, but also include external crates. Declaring or defining a new
-module can be thought of as inserting a new tree into the hierarchy at the
-location of the definition.
-
-To control whether interfaces can be used across modules, Rust checks each use
-of an item to see whether it should be allowed or not. This is where privacy
-warnings are generated, or otherwise "you used a private item of another module
-and weren't allowed to."
-
-By default, everything in rust is *private*, with two exceptions. The first
-exception is that struct fields are public by default (but the struct itself is
-still private by default), and the remaining exception is that enum variants in
-a `pub` enum are the default visibility of the enum container itself.. You are
-allowed to alter this default visibility with the `pub` keyword (or `priv`
-keyword for struct fields and enum variants). When an item is declared as `pub`,
-it can be thought of as being accessible to the outside world. For example:
-
-~~~
-// Declare a private struct
-struct Foo;
-
-// Declare a public struct with a private field
-pub struct Bar {
-    priv field: int
-}
-
-// Declare a public enum with public and private variants
-pub enum State {
-    PubliclyAccessibleState,
-    priv PrivatelyAccessibleState
-}
-~~~
-
-With the notion of an item being either public or private, Rust allows item
-accesses in two cases:
-
-1. If an item is public, then it can be used externally through any of its
-   public ancestors.
-2. If an item is private, it may be accessed by the current module and its
-   descendants.
-
-These two cases are surprisingly powerful for creating module hierarchies
-exposing public APIs while hiding internal implementation details. To help
-explain, here's a few use cases and what they would entail.
-
-* A library developer needs to expose functionality to crates which link against
-  their library. As a consequence of the first case, this means that anything
-  which is usable externally must be `pub` from the root down to the destination
-  item. Any private item in the chain will disallow external accesses.
-
-* A crate needs a global available "helper module" to itself, but it doesn't
-  want to expose the helper module as a public API. To accomplish this, the root
-  of the crate's hierarchy would have a private module which then internally has
-  a "public api". Because the entire crate is an ancestor of the root, then the
-  entire local crate can access this private module through the second case.
-
-* When writing unit tests for a module, it's often a common idiom to have an
-  immediate child of the module to-be-tested named `mod test`. This module could
-  access any items of the parent module through the second case, meaning that
-  internal implementation details could also be seamlessly tested from the child
-  module.
-
-In the second case, it mentions that a private item "can be accessed" by the
-current module and its descendants, but the exact meaning of accessing an item
-depends on what the item is. Accessing a module, for example, would mean looking
-inside of it (to import more items). On the other hand, accessing a function
-would mean that it is invoked.
-
-Here's an example of a program which exemplifies the three cases outlined above.
-
-~~~
-// This module is private, meaning that no external crate can access this
-// module. Because it is private at the root of this current crate, however, any
-// module in the crate may access any publicly visible item in this module.
-mod crate_helper_module {
-
-    // This function can be used by anything in the current crate
-    pub fn crate_helper() {}
-
-    // This function *cannot* be used by anything else in the crate. It is not
-    // publicly visible outside of the `crate_helper_module`, so only this
-    // current module and its descendants may access it.
-    fn implementation_detail() {}
-}
-
-// This function is "public to the root" meaning that it's available to external
-// crates linking against this one.
-pub fn public_api() {}
-
-// Similarly to 'public_api', this module is public so external crates may look
-// inside of it.
-pub mod submodule {
-    use crate_helper_module;
-
-    pub fn my_method() {
-        // Any item in the local crate may invoke the helper module's public
-        // interface through a combination of the two rules above.
-        crate_helper_module::crate_helper();
-    }
-
-    // This function is hidden to any module which is not a descendant of
-    // `submodule`
-    fn my_implementation() {}
-
-    #[cfg(test)]
-    mod test {
-
-        #[test]
-        fn test_my_implementation() {
-            // Because this module is a descendant of `submodule`, it's allowed
-            // to access private items inside of `submodule` without a privacy
-            // violation.
-            super::my_implementation();
-        }
-    }
-}
-
-# fn main() {}
-~~~
-
-For a rust program to pass the privacy checking pass, all paths must be valid
-accesses given the two rules above. This includes all use statements,
-expressions, types, etc.
-
-### Re-exporting and Visibility
-
-Rust allows publicly re-exporting items through a `pub use` directive. Because
-this is a public directive, this allows the item to be used in the current
-module through the rules above. It essentially allows public access into the
-re-exported item. For example, this program is valid:
-
-~~~
-pub use api = self::implementation;
-
-mod implementation {
-    pub fn f() {}
-}
-
-# fn main() {}
-~~~
-
-This means that any external crate referencing `implementation::f` would receive
-a privacy violation, while the path `api::f` would be allowed.
-
-When re-exporting a private item, it can be thought of as allowing the "privacy
-chain" being short-circuited through the reexport instead of passing through the
-namespace hierarchy as it normally would.
-
-### Glob imports and Visibility
-
-Currently glob imports are considered an "experimental" language feature. For
-sanity purpose along with helping the implementation, glob imports will only
-import public items from their destination, not private items.
-
-> **Note:** This is subject to change, glob exports may be removed entirely or
-> they could possibly import private items for a privacy error to later be
-> issued if the item is used.
-
 ## Attributes
 
 ~~~~~~~~{.ebnf .gram}

branches/dist-snap/doc/tutorial.md

@@ -353,12 +353,7 @@ whose literals are written between single quotes, as in `'x'`.
 Just like C, Rust understands a number of character escapes, using the backslash
 character, such as `\n`, `\r`, and `\t`. String literals,
 written between double quotes, allow the same escape sequences.
-
-On the other hand, raw string literals do not process any escape sequences.
-They are written as `r##"blah"##`, with a matching number of zero or more `#`
-before the opening and after the closing quote, and can contain any sequence of
-characters except their closing delimiter.  More on strings
-[later](#vectors-and-strings).
+More on strings [later](#vectors-and-strings).
 
 The nil type, written `()`, has a single value, also written `()`.
 
@@ -2327,18 +2322,19 @@ fn main() {
 
 The `::farm::chicken` construct is what we call a 'path'.
 
-Because it's starting with a `::`, it's also a 'global path', which qualifies
-an item by its full path in the module hierarchy relative to the crate root.
+Because it's starting with a `::`, it's also a 'global path',
+which qualifies an item by its full path in the module hierarchy
+relative to the crate root.
 
-If the path were to start with a regular identifier, like `farm::chicken`, it
-would be a 'local path' instead. We'll get to them later.
+If the path were to start with a regular identifier, like `farm::chicken`, it would be
+a 'local path' instead. We'll get to them later.
 
-Now, if you actually tried to compile this code example, you'll notice that you
-get a `function 'chicken' is private` error. That's because by default, items
-(`fn`, `struct`, `static`, `mod`, ...) are private.
+Now, if you actually tried to compile this code example, you'll notice
+that you get a `unresolved name: 'farm::chicken'` error. That's because per default,
+items (`fn`, `struct`, `static`, `mod`, ...) are only visible inside the module
+they are defined in.
 
-To make them visible outside their containing modules, you need to mark them
-_public_ with `pub`:
+To make them visible outside their containing modules, you need to mark them _public_ with `pub`:
 
 ~~~~
 mod farm {
@@ -2360,8 +2356,7 @@ Rust doesn't support encapsulation: both struct fields and methods can
 be private. But this encapsulation is at the module level, not the
 struct level.
 
-For convenience, fields are _public_ by default, and can be made _private_ with
-the `priv` keyword:
+For convenience, fields are _public_ by default, and can be made _private_ with the `priv` keyword:
 
 ~~~
 mod farm {
@@ -2398,8 +2393,7 @@ fn main() {
 # fn make_me_a_chicken() -> farm::Chicken { 0 }
 ~~~
 
-Exact details and specifications about visibility rules can be found in the Rust
-manual.
+> ***Note:*** Visibility rules are currently buggy and not fully defined, you might have to add or remove `pub` along a path until it works.
 
 ## Files and modules
 

branches/dist-snap/src/etc/vim/syntax/rust.vim

@@ -148,7 +148,6 @@ syn match     rustFormat      display "%%" contained
 syn match     rustSpecial     display contained /\\\([nrt\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)/
 syn match     rustStringContinuation display contained /\\\n\s*/
 syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustTodo,rustFormat,rustSpecial,rustStringContinuation
-syn region    rustString      start='r\z(#*\)"' end='"\z1'
 
 syn region    rustAttribute   start="#\[" end="\]" contains=rustString,rustDeriving
 syn region    rustDeriving    start="deriving(" end=")" contained contains=rustTrait

branches/dist-snap/src/libextra/container.rs

@@ -40,7 +40,7 @@ pub trait Deque<T> : Mutable {
 }
 
 #[cfg(test)]
-pub mod bench {
+mod bench {
     use std::container::MutableMap;
     use std::{vec, rand};
     use std::rand::Rng;

branches/dist-snap/src/libextra/crypto/cryptoutil.rs

@@ -346,7 +346,7 @@ impl <T: FixedBuffer> StandardPadding for T {
 
 
 #[cfg(test)]
-pub mod test {
+mod test {
     use std::rand::{IsaacRng, Rng};
     use std::vec;
 

branches/dist-snap/src/libextra/stats.rs

@@ -101,8 +101,7 @@ pub trait Stats {
 
 /// Extracted collection of all the summary statistics of a sample set.
 #[deriving(Clone, Eq)]
-#[allow(missing_doc)]
-pub struct Summary {
+struct Summary {
     sum: f64,
     min: f64,
     max: f64,

branches/dist-snap/src/librustc/driver/driver.rs

@@ -199,6 +199,7 @@ pub fn phase_2_configure_and_expand(sess: Session,
 
 pub struct CrateAnalysis {
     exp_map2: middle::resolve::ExportMap2,
+    exported_items: @middle::privacy::ExportedItems,
     ty_cx: ty::ctxt,
     maps: astencode::Maps,
     reachable: @mut HashSet<ast::NodeId>
@@ -228,9 +229,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
     let middle::resolve::CrateMap {
         def_map: def_map,
         exp_map2: exp_map2,
-        trait_map: trait_map,
-        external_exports: external_exports,
-        last_private_map: last_private_map
+        trait_map: trait_map
     } =
         time(time_passes, "resolution", (), |_|
              middle::resolve::resolve_crate(sess, lang_items, crate));
@@ -262,10 +261,9 @@ pub fn phase_3_run_analysis_passes(sess: Session,
          middle::check_const::check_crate(sess, crate, ast_map, def_map,
                                           method_map, ty_cx));
 
-    let maps = (external_exports, last_private_map);
-    time(time_passes, "privacy checking", maps, |(a, b)|
-         middle::privacy::check_crate(ty_cx, &method_map, &exp_map2,
-                                      a, b, crate));
+    let exported_items =
+        time(time_passes, "privacy checking", (), |_|
+             middle::privacy::check_crate(ty_cx, &method_map, &exp_map2, crate));
 
     time(time_passes, "effect checking", (), |_|
          middle::effect::check_crate(ty_cx, method_map, crate));
@@ -307,6 +305,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
 
     CrateAnalysis {
         exp_map2: exp_map2,
+        exported_items: @exported_items,
         ty_cx: ty_cx,
         maps: astencode::Maps {
             root_map: root_map,

branches/dist-snap/src/librustc/front/test.rs

@@ -407,7 +407,7 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
     debug2!("encoding {}", ast_util::path_name_i(path));
 
     let name_lit: ast::lit =
-        nospan(ast::lit_str(ast_util::path_name_i(path).to_managed(), ast::CookedStr));
+        nospan(ast::lit_str(ast_util::path_name_i(path).to_managed()));
 
     let name_expr = @ast::Expr {
           id: ast::DUMMY_NODE_ID,