Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Commits on Oct 11, 2014
  1. @bors

    auto merge of #17801 : Gankro/rust/collections-stuff, r=sfackler

    bors authored
    I previously avoided `#[inline]`ing anything assuming someone would come in and explain to me where this would be appropriate. Apparently no one *really* knows, so I'll just go the opposite way an inline everything assuming someone will come in and yell at me that such-and-such shouldn't be `#[inline]`.
    
    ==================
    
    For posterity, iteration comparisons:
    
    ```
    test btree::map::bench::iter_20                            ... bench:       971 ns/iter (+/- 30)
    test btree::map::bench::iter_1000                          ... bench:     29445 ns/iter (+/- 480)
    test btree::map::bench::iter_100000                        ... bench:   2929035 ns/iter (+/- 21551)
    
    test treemap::bench::iter_20                               ... bench:       530 ns/iter (+/- 66)
    test treemap::bench::iter_1000                             ... bench:     26287 ns/iter (+/- 825)
    test treemap::bench::iter_100000                           ... bench:   7650084 ns/iter (+/- 356711)
    
    test trie::bench_map::iter_20                              ... bench:       646 ns/iter (+/- 265)
    test trie::bench_map::iter_1000                            ... bench:     43556 ns/iter (+/- 5014)
    test trie::bench_map::iter_100000                          ... bench:  12988002 ns/iter (+/- 139676)
    ```
    
    As you can see `btree` "scales" much better than `treemap`. `triemap` scales quite poorly.
    
    Note that *completely* different results are given if the elements are inserted in order from the range [0, size]. In particular, TrieMap *completely* dominates in the sorted case. This suggests adding benches for both might be worthwhile. However unsorted is *probably* the more "normal" case, so I consider this "good enough" for now.
  2. @bors

    auto merge of #17940 : pnkfelix/rust/fix-check-stage1-on-clean-dir, r…

    bors authored
    …=huonw
    
    compiletest needs to link to native crate, or at least the `rt` library.
    
    (I tried using a dependency on `rustrt` instead, and that did not resolve the problem.  But this does.)
    
    Partially addresses #17883
  3. @pnkfelix

    compiletest needs to link to native crate, or at least the `rt` library.

    pnkfelix authored
    (I tried using a dependency on `rustrt` instead, and that did not
    resolve the problem.  But this does.)
    
    Fix #17883
  4. @bors

    auto merge of #17939 : alexcrichton/rust/snapshots, r=sfackler

    bors authored
    Also convert a number of `static mut` to just a plain old `static` and remove
    some unsafe blocks.
  5. @bors

    auto merge of #17928 : steveklabnik/rust/remove_runtime_guide, r=alex…

    bors authored
    …crichton
    
    Now that libgreen is gone, this is all wrong.
    
    Fixes #17923
  6. @alexcrichton

    Register new snapshots

    alexcrichton authored
    Also convert a number of `static mut` to just a plain old `static` and remove
    some unsafe blocks.
  7. @bors

    auto merge of #17936 : TeXitoi/rust/remove-shootout-warnings, r=alexc…

    bors authored
    …richton
    
    Only one warning remain, and I can't find a way to remove it without doing more bound checks:
    
    ```
    shootout-nbody.rs:105:36: 105:51 warning: use of deprecated item: use iter_mut, #[warn(deprecated)] on by default
    shootout-nbody.rs:105             let bi = match b_slice.mut_shift_ref() {
    ```
    
    using `split_at_mut` may be an option, but it will do more bound checking.
    
    If anyone have an idea, I'll update this PR.
Commits on Oct 10, 2014
  1. @TeXitoi

    remove shootout warnings

    TeXitoi authored
  2. @bors

    auto merge of #17920 : thestinger/rust/vec, r=aturon

    bors authored
    Introduce conversions between `Box<[T]>` and `Vec<T>` and use it to reimplement the `vec![]` macro for efficiency.
  3. @thestinger
  4. @steveklabnik

    Remove the runtime guide.

    steveklabnik authored
    Now that libgreen is gone, this is all wrong.
    
    Fixes #17923
  5. @thestinger
  6. @bors

    auto merge of #17793 : simias/rust/master, r=huonw

    bors authored
    The man page stated that the list of features was space-separated when
    it's actually comma-separated.
  7. @thestinger

    vec: minor cleanup

    thestinger authored
  8. @bors
  9. @kmcallister
  10. @bors

    auto merge of #17669 : nikomatsakis/rust/multidispatch, r=pcwalton

    bors authored
    Implement multidispatch and conditional dispatch. Because we do not attempt to preserve crate concatenation, this is a backwards compatible change. This is not yet fully integrated into method dispatch, so "UFCS"-style wrappers must be used to take advantage of the new features (see the run-pass tests).
    
    cc #17307 (multidispatch)
    cc #5527 (trait reform -- conditional dispatch)
    
    Because we no longer preserve crate concatenability, this deviates slightly from what was specified in the RFC. The motivation for this change is described in [this blog post](http://smallcultfollowing.com/babysteps/blog/2014/09/30/multi-and-conditional-dispatch-in-traits/). I will post an amendment to the RFC in due course but do not anticipate great controversy on this point -- particularly as the RFCs more important features (e.g., conditional dispatch) just don't work without the change.
  11. @bors

    auto merge of #17853 : alexcrichton/rust/issue-17718, r=pcwalton

    bors authored
    This change is an implementation of [RFC 69][rfc] which adds a third kind of
    global to the language, `const`. This global is most similar to what the old
    `static` was, and if you're unsure about what to use then you should use a
    `const`.
    
    The semantics of these three kinds of globals are:
    
    * A `const` does not represent a memory location, but only a value. Constants
      are translated as rvalues, which means that their values are directly inlined
      at usage location (similar to a #define in C/C++). Constant values are, well,
      constant, and can not be modified. Any "modification" is actually a
      modification to a local value on the stack rather than the actual constant
      itself.
    
      Almost all values are allowed inside constants, whether they have interior
      mutability or not. There are a few minor restrictions listed in the RFC, but
      they should in general not come up too often.
    
    * A `static` now always represents a memory location (unconditionally). Any
      references to the same `static` are actually a reference to the same memory
      location. Only values whose types ascribe to `Sync` are allowed in a `static`.
      This restriction is in place because many threads may access a `static`
      concurrently. Lifting this restriction (and allowing unsafe access) is a
      future extension not implemented at this time.
    
    * A `static mut` continues to always represent a memory location. All references
      to a `static mut` continue to be `unsafe`.
    
    This is a large breaking change, and many programs will need to be updated
    accordingly. A summary of the breaking changes is:
    
    * Statics may no longer be used in patterns. Statics now always represent a
      memory location, which can sometimes be modified. To fix code, repurpose the
      matched-on-`static` to a `const`.
    
          static FOO: uint = 4;
          match n {
              FOO => { /* ... */ }
              _ => { /* ... */ }
          }
    
      change this code to:
    
          const FOO: uint = 4;
          match n {
              FOO => { /* ... */ }
              _ => { /* ... */ }
          }
    
    * Statics may no longer refer to other statics by value. Due to statics being
      able to change at runtime, allowing them to reference one another could
      possibly lead to confusing semantics. If you are in this situation, use a
      constant initializer instead. Note, however, that statics may reference other
      statics by address, however.
    
    * Statics may no longer be used in constant expressions, such as array lengths.
      This is due to the same restrictions as listed above. Use a `const` instead.
    
    [breaking-change]
    Closes #17718 
    
    [rfc]: rust-lang/rfcs#246
Commits on Oct 9, 2014
  1. @alexcrichton
  2. @kmcallister
  3. @kmcallister

    Add -C no-stack-check

    kmcallister authored
    Fixes #16980.
  4. @kmcallister

    Rename the no_split_stack attribute to no_stack_check

    kmcallister authored
    The old name is misleading as we haven't had segmented stacks in quite some
    time. But we still recognize it, with a deprecation warning.
  5. @nikomatsakis
  6. @nikomatsakis
  7. @nikomatsakis
  8. @nikomatsakis

    Implement multidispatch and conditional dispatch. Because we do not

    nikomatsakis authored
    attempt to preserve crate concatenation, this is a backwards compatible
    change.
    
    Conflicts:
    	src/librustc/middle/traits/select.rs
  9. @bors
  10. @bors

    auto merge of #17558 : kaseyc/rust/fix_bitvset_union, r=aturon

    bors authored
    Updates the other_op function shared by the union/intersect/difference/symmetric_difference -with functions to fix an issue where certain elements would not be present in the result. To fix this, when other op is called, we resize self's nbits to account for any new elements that may be added to the set.
    
    Example:
    ```rust
    	let mut a = BitvSet::new();
    	let mut b = BitvSet::new();
    	a.insert(0);
    	b.insert(5);
    	a.union_with(&b);
    	println!("{}", a); //Prints "{0}" instead of "{0, 5}"
    ```
  11. @brson
  12. @brson

    Bump version to 0.13.0

    brson authored
  13. @brson

    Revert "Update html_root_url for 0.12.0 release"

    brson authored
    This reverts commit 2288f33.
  14. @bors

    auto merge of #17880 : pcwalton/rust/duplicate-bindings-in-parameter-…

    bors authored
    …list, r=alexcrichton
    
    parameter list.
    
    This breaks code like:
    
        fn f(a: int, a: int) { ... }
        fn g<T,T>(a: T) { ... }
    
    Change this code to not use the same name for a parameter. For example:
    
        fn f(a: int, b: int) { ... }
        fn g<T,U>(a: T) { ... }
    
    Code like this is *not* affected, since `_` is not an identifier:
    
        fn f(_: int, _: int) { ... } // OK
    
    Closes #17568.
    
    r? @alexcrichton 
    [breaking-change]
  15. @alexcrichton
  16. @alexcrichton

    test: Convert statics to constants

    alexcrichton authored
    Additionally, add lots of tests for new functionality around statics and
    `static mut`.
  17. @alexcrichton

    syntax: Tweak the return value of bytes!()

    alexcrichton authored
    Instead of returning &'static [u8], an invocation of `bytes!()` now returns
    `&'static [u8, ..N]` where `N` is the length of the byte vector. This should
    functionally be the same, but there are some cases where an explicit cast may be
    needed, so this is a:
    
    [breaking-change]
Something went wrong with that request. Please try again.