From 8e420e07d914a50ef279de60e6b3d303e82bfd72 Mon Sep 17 00:00:00 2001 From: Craig Hills Date: Mon, 5 Oct 2015 22:25:19 -0400 Subject: [PATCH 01/16] trpl: Clarify closure terminology This is to address issue #28803 --- src/doc/trpl/closures.md | 42 +++++++++++++++++++++------------------- src/llvm | 2 +- 2 files changed, 23 insertions(+), 21 deletions(-) diff --git a/src/doc/trpl/closures.md b/src/doc/trpl/closures.md index 983af4a0efe..85e74b083b4 100644 --- a/src/doc/trpl/closures.md +++ b/src/doc/trpl/closures.md @@ -1,9 +1,10 @@ % Closures -Rust not only has named functions, but anonymous functions as well. Anonymous -functions that have an associated environment are called ‘closures’, because they -close over an environment. Rust has a really great implementation of them, as -we’ll see. +Sometimes it is useful to wrap up a function and free variables for better +clarity and reuse. The _free variables_ that can be used come from the +enclosing scope and are "closed over" when used in the function. From this, we +get the name "closures" and Rust provides a really great implementation of +them, as we’ll see. # Syntax @@ -34,7 +35,7 @@ assert_eq!(4, plus_two(2)); ``` You’ll notice a few things about closures that are a bit different from regular -functions defined with `fn`. The first is that we did not need to +named functions defined with `fn`. The first is that we did not need to annotate the types of arguments the closure takes or the values it returns. We can: @@ -44,14 +45,14 @@ let plus_one = |x: i32| -> i32 { x + 1 }; assert_eq!(2, plus_one(1)); ``` -But we don’t have to. Why is this? Basically, it was chosen for ergonomic reasons. -While specifying the full type for named functions is helpful with things like -documentation and type inference, the types of closures are rarely documented -since they’re anonymous, and they don’t cause the kinds of error-at-a-distance -problems that inferring named function types can. +But we don’t have to. Why is this? Basically, it was chosen for ergonomic +reasons. While specifying the full type for named functions is helpful with +things like documentation and type inference, types within closures are rarely +documented since they’re anonymous, and they don’t cause the kinds of +error-at-a-distance problems that inferring named function types can. -The second is that the syntax is similar, but a bit different. I’ve added spaces -here for easier comparison: +The second is that the syntax is similar, but a bit different. I’ve added +spaces here for easier comparison: ```rust fn plus_one_v1 (x: i32) -> i32 { x + 1 } @@ -63,8 +64,8 @@ Small differences, but they’re similar. # Closures and their environment -Closures are called such because they ‘close over their environment’. It -looks like this: +The environment for a closure can include bindings from it's enclosing scope in +addition to parameters and local bindings. It looks like this: ```rust let num = 5; @@ -197,9 +198,10 @@ frame. Without `move`, a closure may be tied to the stack frame that created it, while a `move` closure is self-contained. This means that you cannot generally return a non-`move` closure from a function, for example. -But before we talk about taking and returning closures, we should talk some more -about the way that closures are implemented. As a systems language, Rust gives -you tons of control over what your code does, and closures are no different. +But before we talk about taking and returning closures, we should talk some +more about the way that closures are implemented. As a systems language, Rust +gives you tons of control over what your code does, and closures are no +different. # Closure implementation @@ -288,9 +290,9 @@ isn’t interesting. The next part is: # some_closure(1) } ``` -Because `Fn` is a trait, we can bound our generic with it. In this case, our closure -takes a `i32` as an argument and returns an `i32`, and so the generic bound we use -is `Fn(i32) -> i32`. +Because `Fn` is a trait, we can bound our generic with it. In this case, our +closure takes a `i32` as an argument and returns an `i32`, and so the generic +bound we use is `Fn(i32) -> i32`. There’s one other key point here: because we’re bounding a generic with a trait, this will get monomorphized, and therefore, we’ll be doing static diff --git a/src/llvm b/src/llvm index 62ad301a240..2e9f0d21fe3 160000 --- a/src/llvm +++ b/src/llvm @@ -1 +1 @@ -Subproject commit 62ad301a2407a7aca50c1d5120c63597d676d29f +Subproject commit 2e9f0d21fe321849a4759a01fc28eae82ef196d6 From a78a874ebb8c3348f2e1cb7a687636ab26a85a1c Mon Sep 17 00:00:00 2001 From: Craig Hills Date: Mon, 5 Oct 2015 22:32:53 -0400 Subject: [PATCH 02/16] possessive its --- src/doc/trpl/closures.md | 2 +- src/llvm | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/doc/trpl/closures.md b/src/doc/trpl/closures.md index 85e74b083b4..fee18cb0167 100644 --- a/src/doc/trpl/closures.md +++ b/src/doc/trpl/closures.md @@ -64,7 +64,7 @@ Small differences, but they’re similar. # Closures and their environment -The environment for a closure can include bindings from it's enclosing scope in +The environment for a closure can include bindings from its enclosing scope in addition to parameters and local bindings. It looks like this: ```rust diff --git a/src/llvm b/src/llvm index 2e9f0d21fe3..62ad301a240 160000 --- a/src/llvm +++ b/src/llvm @@ -1 +1 @@ -Subproject commit 2e9f0d21fe321849a4759a01fc28eae82ef196d6 +Subproject commit 62ad301a2407a7aca50c1d5120c63597d676d29f From 7895ec2d5752c5a5dacd17d463e401d9e85fac13 Mon Sep 17 00:00:00 2001 From: Craig Hills Date: Tue, 6 Oct 2015 10:30:33 -0400 Subject: [PATCH 03/16] address review concerns --- src/doc/trpl/closures.md | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/doc/trpl/closures.md b/src/doc/trpl/closures.md index fee18cb0167..7d4452a4c84 100644 --- a/src/doc/trpl/closures.md +++ b/src/doc/trpl/closures.md @@ -1,9 +1,9 @@ % Closures -Sometimes it is useful to wrap up a function and free variables for better -clarity and reuse. The _free variables_ that can be used come from the -enclosing scope and are "closed over" when used in the function. From this, we -get the name "closures" and Rust provides a really great implementation of +Sometimes it is useful to wrap up a function and _free variables_ for better +clarity and reuse. The free variables that can be used come from the +enclosing scope and are ‘closed over’ when used in the function. From this, we +get the name ‘closures’ and Rust provides a really great implementation of them, as we’ll see. # Syntax @@ -46,10 +46,11 @@ assert_eq!(2, plus_one(1)); ``` But we don’t have to. Why is this? Basically, it was chosen for ergonomic -reasons. While specifying the full type for named functions is helpful with -things like documentation and type inference, types within closures are rarely -documented since they’re anonymous, and they don’t cause the kinds of -error-at-a-distance problems that inferring named function types can. +reasons. While specifying the full type for named functions is helpful with +things like documentation and type inference, the full type signatures of +closures are rarely documented since they’re anonymous, and they don’t cause +the kinds of error-at-a-distance problems that inferring named function types +can. The second is that the syntax is similar, but a bit different. I’ve added spaces here for easier comparison: @@ -65,7 +66,7 @@ Small differences, but they’re similar. # Closures and their environment The environment for a closure can include bindings from its enclosing scope in -addition to parameters and local bindings. It looks like this: +addition to parameters and local bindings. It looks like this: ```rust let num = 5; @@ -454,7 +455,7 @@ autogenerated name. The error also points out that the return type is expected to be a reference, but what we are trying to return is not. Further, we cannot directly assign a `'static` lifetime to an object. So we'll take a different approach and return -a "trait object" by `Box`ing up the `Fn`. This _almost_ works: +a ‘trait object’ by `Box`ing up the `Fn`. This _almost_ works: ```rust,ignore fn factory() -> Box i32> { From 4d40dd3c03f1f379211fe6d0e07e0dc5aa7a2abb Mon Sep 17 00:00:00 2001 From: Steve Klabnik Date: Tue, 6 Oct 2015 21:59:49 -0400 Subject: [PATCH 04/16] Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279 --- ...-line-endings-string-literal-doc-comment.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/test/run-pass/lexer-crlf-line-endings-string-literal-doc-comment.rs b/src/test/run-pass/lexer-crlf-line-endings-string-literal-doc-comment.rs index 10bf096dae7..5c8db524cc2 100644 --- a/src/test/run-pass/lexer-crlf-line-endings-string-literal-doc-comment.rs +++ b/src/test/run-pass/lexer-crlf-line-endings-string-literal-doc-comment.rs @@ -1,7 +1,7 @@ // ignore-tidy-cr ignore-license // ignore-tidy-cr (repeated again because of tidy bug) // license is ignored because tidy can't handle the CRLF here properly. - + // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. @@ -11,33 +11,33 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. - + // NB: this file needs CRLF line endings. The .gitattributes file in // this directory should enforce it. - + // ignore-pretty - + /// Doc comment that ends in CRLF pub fn foo() {} - + /** Block doc comment that * contains CRLF characters */ pub fn bar() {} - + fn main() { let s = "string literal"; assert_eq!(s, "string\nliteral"); - + let s = "literal with \ escaped newline"; assert_eq!(s, "literal with escaped newline"); - + let s = r"string literal"; assert_eq!(s, "string\nliteral"); - + // validate that our source file has CRLF endings let source = include_str!("lexer-crlf-line-endings-string-literal-doc-comment.rs"); assert!(source.contains("string\r\nliteral")); From d21b4f545173b5c74d4c9446137cf1886953a0dc Mon Sep 17 00:00:00 2001 From: Jack Wilson Date: Sun, 4 Oct 2015 13:17:35 -0700 Subject: [PATCH 05/16] Use the correct mod name from the example --- src/doc/trpl/crates-and-modules.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/doc/trpl/crates-and-modules.md b/src/doc/trpl/crates-and-modules.md index 1c5115117cb..c4775cd9868 100644 --- a/src/doc/trpl/crates-and-modules.md +++ b/src/doc/trpl/crates-and-modules.md @@ -563,8 +563,8 @@ What's going on here? First, both `extern crate` and `use` allow renaming the thing that is being imported. So the crate is still called "phrases", but here we will refer to it as "sayings". Similarly, the first `use` statement pulls in the -`japanese::farewells` module from the crate, but makes it available as -`jp_farewells` as opposed to simply `farewells`. This can help to avoid +`japanese::greetings` module from the crate, but makes it available as +`ja_greetings` as opposed to simply `greetings`. This can help to avoid ambiguity when importing similarly-named items from different places. The second `use` statement uses a star glob to bring in _all_ symbols from the From cbf97c3e65e288702ccaea7f4a7153a37f7e4ee3 Mon Sep 17 00:00:00 2001 From: Martin Pool Date: Tue, 6 Oct 2015 19:42:58 -0700 Subject: [PATCH 06/16] style guide: suggest manual links to constructors --- src/doc/style/style/comments.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/doc/style/style/comments.md b/src/doc/style/style/comments.md index b2d2d9ab6b4..3851187b520 100644 --- a/src/doc/style/style/comments.md +++ b/src/doc/style/style/comments.md @@ -85,3 +85,20 @@ Use inner doc comments _only_ to document crates and file-level modules: //! //! The core library is a something something... ``` + +### Explain context. + +Rust doesn't have special constructors, only functions that return new +instances. These aren't visible in the automatically generated documentation +for a type, so you should specifically link to them: + +``` rust +/// An iterator that yields `None` forever after the underlying iterator +/// yields `None` once. +/// +/// These can be created through +/// [`iter.fuse()`](trait.Iterator.html#method.fuse). +pub struct Fuse { + // ... +} +``` From 4119fc27498dba51d0233f0496ff8d03036ee350 Mon Sep 17 00:00:00 2001 From: Colin Wallace Date: Sat, 19 Sep 2015 19:50:42 -0700 Subject: [PATCH 07/16] Fix "the the" typo and split a run-on sentence --- src/doc/trpl/patterns.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/doc/trpl/patterns.md b/src/doc/trpl/patterns.md index a365732fe9b..3d22066c725 100644 --- a/src/doc/trpl/patterns.md +++ b/src/doc/trpl/patterns.md @@ -299,7 +299,7 @@ match x { ``` This prints `no`, because the `if` applies to the whole of `4 | 5`, and not to -just the `5`, In other words, the the precedence of `if` behaves like this: +just the `5`. In other words, the precedence of `if` behaves like this: ```text (4 | 5) if y => ... From 03dfe89786d5bbb8ec5f467c48e73152f843136a Mon Sep 17 00:00:00 2001 From: Yoshito Komatsu Date: Wed, 7 Oct 2015 16:07:42 +0900 Subject: [PATCH 08/16] Fix a typo Add musl link --- src/doc/trpl/advanced-linking.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/doc/trpl/advanced-linking.md b/src/doc/trpl/advanced-linking.md index 921f27336f2..9ef6d5c2bff 100644 --- a/src/doc/trpl/advanced-linking.md +++ b/src/doc/trpl/advanced-linking.md @@ -26,7 +26,7 @@ shells out to the system linker (`gcc` on most systems, `link.exe` on MSVC), so it makes sense to provide extra command line arguments, but this will not always be the case. In the future `rustc` may use LLVM directly to link native libraries, in which case `link_args` will have no -meaning. You can achieve the same effect as the `link-args` attribute with the +meaning. You can achieve the same effect as the `link_args` attribute with the `-C link-args` argument to `rustc`. It is highly recommended to *not* use this attribute, and rather use the more @@ -71,7 +71,7 @@ Dynamic linking on Linux can be undesirable if you wish to use new library features on old systems or target systems which do not have the required dependencies for your program to run. -Static linking is supported via an alternative `libc`, `musl`. You can compile +Static linking is supported via an alternative `libc`, [`musl`](http://www.musl-libc.org). You can compile your own version of Rust with `musl` enabled and install it into a custom directory with the instructions below: From 8fee5480c34f97a1b970a44758c6617d293724e8 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Tue, 6 Oct 2015 23:06:15 +0200 Subject: [PATCH 09/16] Add new error code --- src/librustc_trans/trans/consts.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 8e63f2788ed..0cae0ae59ba 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -628,8 +628,8 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, if iv >= len { // FIXME #3170: report this earlier on in the const-eval // pass. Reporting here is a bit late. - cx.sess().span_err(e.span, - "const index-expr is out of bounds"); + span_err!(cx.sess(), e.span, E0515, + "const index-expr is out of bounds"); C_undef(val_ty(arr).element_type()) } else { const_get_elt(cx, arr, &[iv as c_uint]) From a94f684129dbf8cb4c87abe69ff45765cf24e501 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Tue, 6 Oct 2015 23:08:33 +0200 Subject: [PATCH 10/16] Add error explanation for E0515 --- src/librustc_trans/diagnostics.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/librustc_trans/diagnostics.rs b/src/librustc_trans/diagnostics.rs index dd7c3834e56..05236a7a6fb 100644 --- a/src/librustc_trans/diagnostics.rs +++ b/src/librustc_trans/diagnostics.rs @@ -12,6 +12,21 @@ register_long_diagnostics! { +E0515: r##" +A constant index expression was out of bounds. Erroneous code example: + +``` +let x = &[0, 1, 2][7]; // error: const index-expr is out of bounds +``` + +Please specify a valid index (not inferior to 0 or superior to array length). +Example: + +``` +let x = &[0, 1, 2][2]; // ok! +``` +"##, + } register_diagnostics! { From e84461a5c509240dfcc01a866a8c19bb9670d219 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Wed, 7 Oct 2015 09:30:51 -0400 Subject: [PATCH 11/16] Alter formatting for words in Option::cloned doc comment --- src/libcore/option.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libcore/option.rs b/src/libcore/option.rs index d1bb65d2290..0e4c6d1676e 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -706,7 +706,8 @@ impl Option { } impl<'a, T: Clone> Option<&'a T> { - /// Maps an Option<&T> to an Option by cloning the contents of the Option. + /// Maps an `Option<&T>` to an `Option` by cloning the contents of the + /// option. #[stable(feature = "rust1", since = "1.0.0")] pub fn cloned(self) -> Option { self.map(|t| t.clone()) From 2ba0c48b7975501bb220afe8dea4163de5d2187e Mon Sep 17 00:00:00 2001 From: Boris Egorov Date: Wed, 7 Oct 2015 22:44:17 +0600 Subject: [PATCH 12/16] trpl: Use ordered list to release user from counting Later in text we mention 'step four' and 'step three'. This fix releases user from counting. --- src/doc/trpl/lifetimes.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/doc/trpl/lifetimes.md b/src/doc/trpl/lifetimes.md index 4896be714bb..23569dd1b91 100644 --- a/src/doc/trpl/lifetimes.md +++ b/src/doc/trpl/lifetimes.md @@ -43,11 +43,11 @@ With that in mind, let’s learn about lifetimes. Lending out a reference to a resource that someone else owns can be complicated. For example, imagine this set of operations: -- I acquire a handle to some kind of resource. -- I lend you a reference to the resource. -- I decide I’m done with the resource, and deallocate it, while you still have +1. I acquire a handle to some kind of resource. +2. I lend you a reference to the resource. +3. I decide I’m done with the resource, and deallocate it, while you still have your reference. -- You decide to use the resource. +4. You decide to use the resource. Uh oh! Your reference is pointing to an invalid resource. This is called a dangling pointer or ‘use after free’, when the resource is memory. From 1e0fbbd721e797e49fa0f7dfa9aa1591b324daca Mon Sep 17 00:00:00 2001 From: Boris Egorov Date: Wed, 7 Oct 2015 23:37:24 +0600 Subject: [PATCH 13/16] trpl: Fix some bad wording in iterators subsection --- src/doc/trpl/iterators.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/doc/trpl/iterators.md b/src/doc/trpl/iterators.md index 6d1e66b6733..3350df4ff7f 100644 --- a/src/doc/trpl/iterators.md +++ b/src/doc/trpl/iterators.md @@ -42,12 +42,12 @@ loop is just a handy way to write this `loop`/`match`/`break` construct. `for` loops aren't the only thing that uses iterators, however. Writing your own iterator involves implementing the `Iterator` trait. While doing that is outside of the scope of this guide, Rust provides a number of useful iterators -to accomplish various tasks. Before we talk about those, we should talk about a -Rust anti-pattern. And that's using ranges like this. +to accomplish various tasks. But first, a few notes about limitations of ranges. -Yes, we just talked about how ranges are cool. But ranges are also very -primitive. For example, if you needed to iterate over the contents of a vector, -you may be tempted to write this: +Ranges are very primitive, and we often can use better alternatives. Consider +following Rust anti-pattern: using ranges to emulate a C-style `for` loop. Let’s +suppose you needed to iterate over the contents of a vector. You may be tempted +to write this: ```rust let nums = vec![1, 2, 3]; @@ -281,8 +281,8 @@ If you are trying to execute a closure on an iterator for its side effects, just use `for` instead. There are tons of interesting iterator adapters. `take(n)` will return an -iterator over the next `n` elements of the original iterator. Let's try it out with our infinite -iterator from before: +iterator over the next `n` elements of the original iterator. Let's try it out +with an infinite iterator: ```rust for i in (1..).take(5) { From 17033a62b420fcf353150998bbdb62629efdf956 Mon Sep 17 00:00:00 2001 From: Michael Pankov Date: Thu, 8 Oct 2015 01:01:02 +0300 Subject: [PATCH 14/16] rustfmt part of libcore/fmt Rest is blocked by https://github.com/nrc/rustfmt/issues/413 --- src/libcore/fmt/builders.rs | 62 ++++++++++++++++++++++++++++--------- src/libcore/fmt/num.rs | 21 ++++++++++--- src/libcore/fmt/rt/v1.rs | 2 +- 3 files changed, 65 insertions(+), 20 deletions(-) diff --git a/src/libcore/fmt/builders.rs b/src/libcore/fmt/builders.rs index 764d12dd903..0d4c0bb6480 100644 --- a/src/libcore/fmt/builders.rs +++ b/src/libcore/fmt/builders.rs @@ -61,7 +61,8 @@ pub struct DebugStruct<'a, 'b: 'a> { has_fields: bool, } -pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) +pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, + name: &str) -> DebugStruct<'a, 'b> { let result = fmt.write_str(name); DebugStruct { @@ -84,7 +85,8 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> { if self.is_pretty() { let mut writer = PadAdapter::new(self.fmt); - fmt::write(&mut writer, format_args!("{}\n{}: {:#?}", prefix, name, value)) + fmt::write(&mut writer, + format_args!("{}\n{}: {:#?}", prefix, name, value)) } else { write!(self.fmt, "{} {}: {:?}", prefix, name, value) } @@ -195,10 +197,18 @@ impl<'a, 'b: 'a> DebugInner<'a, 'b> { self.result = self.result.and_then(|_| { if self.is_pretty() { let mut writer = PadAdapter::new(self.fmt); - let prefix = if self.has_fields { "," } else { "" }; + let prefix = if self.has_fields { + "," + } else { + "" + }; fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry)) } else { - let prefix = if self.has_fields { ", " } else { "" }; + let prefix = if self.has_fields { + ", " + } else { + "" + }; write!(self.fmt, "{}{:?}", prefix, entry) } }); @@ -207,7 +217,11 @@ impl<'a, 'b: 'a> DebugInner<'a, 'b> { } pub fn finish(&mut self) { - let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" }; + let prefix = if self.is_pretty() && self.has_fields { + "\n" + } else { + "" + }; self.result = self.result.and_then(|_| self.fmt.write_str(prefix)); } @@ -232,7 +246,7 @@ pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b fmt: fmt, result: result, has_fields: false, - } + }, } } @@ -247,7 +261,9 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> { /// Adds the contents of an iterator of entries to the set output. #[stable(feature = "debug_builders", since = "1.2.0")] pub fn entries(&mut self, entries: I) -> &mut DebugSet<'a, 'b> - where D: fmt::Debug, I: IntoIterator { + where D: fmt::Debug, + I: IntoIterator + { for entry in entries { self.entry(&entry); } @@ -278,7 +294,7 @@ pub fn debug_list_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugList<'a, fmt: fmt, result: result, has_fields: false, - } + }, } } @@ -293,7 +309,9 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> { /// Adds the contents of an iterator of entries to the list output. #[stable(feature = "debug_builders", since = "1.2.0")] pub fn entries(&mut self, entries: I) -> &mut DebugList<'a, 'b> - where D: fmt::Debug, I: IntoIterator { + where D: fmt::Debug, + I: IntoIterator + { for entry in entries { self.entry(&entry); } @@ -335,10 +353,19 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> { self.result = self.result.and_then(|_| { if self.is_pretty() { let mut writer = PadAdapter::new(self.fmt); - let prefix = if self.has_fields { "," } else { "" }; - fmt::write(&mut writer, format_args!("{}\n{:#?}: {:#?}", prefix, key, value)) + let prefix = if self.has_fields { + "," + } else { + "" + }; + fmt::write(&mut writer, + format_args!("{}\n{:#?}: {:#?}", prefix, key, value)) } else { - let prefix = if self.has_fields { ", " } else { "" }; + let prefix = if self.has_fields { + ", " + } else { + "" + }; write!(self.fmt, "{}{:?}: {:?}", prefix, key, value) } }); @@ -350,7 +377,10 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> { /// Adds the contents of an iterator of entries to the map output. #[stable(feature = "debug_builders", since = "1.2.0")] pub fn entries(&mut self, entries: I) -> &mut DebugMap<'a, 'b> - where K: fmt::Debug, V: fmt::Debug, I: IntoIterator { + where K: fmt::Debug, + V: fmt::Debug, + I: IntoIterator + { for (k, v) in entries { self.entry(&k, &v); } @@ -360,7 +390,11 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> { /// Finishes output and returns any error encountered. #[stable(feature = "debug_builders", since = "1.2.0")] pub fn finish(&mut self) -> fmt::Result { - let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" }; + let prefix = if self.is_pretty() && self.has_fields { + "\n" + } else { + "" + }; self.result.and_then(|_| write!(self.fmt, "{}}}", prefix)) } diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 022fe6711bd..5d8f5858078 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -48,7 +48,9 @@ trait GenericRadix { fn base(&self) -> u8; /// A radix-specific prefix string. - fn prefix(&self) -> &'static str { "" } + fn prefix(&self) -> &'static str { + "" + } /// Converts an integer to corresponding radix digit. fn digit(&self, x: u8) -> u8; @@ -70,7 +72,10 @@ trait GenericRadix { x = x / base; // Deaccumulate the number. *byte = self.digit(n.to_u8()); // Store the digit in the buffer. curr -= 1; - if x == zero { break }; // No more digits left to accumulate. + if x == zero { + // No more digits left to accumulate. + break + }; } } else { // Do the same as above, but accounting for two's complement. @@ -79,7 +84,9 @@ trait GenericRadix { x = x / base; // Deaccumulate the number. *byte = self.digit(n.to_u8()); // Store the digit in the buffer. curr -= 1; - if x == zero { break }; // No more digits left to accumulate. + if x == zero { + break + }; // No more digits left to accumulate. } } let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) }; @@ -141,13 +148,17 @@ pub struct Radix { impl Radix { fn new(base: u8) -> Radix { - assert!(2 <= base && base <= 36, "the base must be in the range of 2..36: {}", base); + assert!(2 <= base && base <= 36, + "the base must be in the range of 2..36: {}", + base); Radix { base: base } } } impl GenericRadix for Radix { - fn base(&self) -> u8 { self.base } + fn base(&self) -> u8 { + self.base + } fn digit(&self, x: u8) -> u8 { match x { x @ 0 ... 9 => b'0' + x, diff --git a/src/libcore/fmt/rt/v1.rs b/src/libcore/fmt/rt/v1.rs index 033834dd5aa..f889045a3f5 100644 --- a/src/libcore/fmt/rt/v1.rs +++ b/src/libcore/fmt/rt/v1.rs @@ -53,5 +53,5 @@ pub enum Count { #[derive(Copy, Clone)] pub enum Position { Next, - At(usize) + At(usize), } From 3fbbee6ad5a8ce225702910deb712dc88f4412c3 Mon Sep 17 00:00:00 2001 From: Michael Pankov Date: Thu, 8 Oct 2015 01:03:52 +0300 Subject: [PATCH 15/16] rustfmt hash submodule --- src/libcore/hash/mod.rs | 31 ++++++++++++++++++++++--------- src/libcore/hash/sip.rs | 11 +++++------ 2 files changed, 27 insertions(+), 15 deletions(-) diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index 2a4c909d638..4e038f455e1 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -100,7 +100,9 @@ pub trait Hash { /// Feeds a slice of this type into the state provided. #[stable(feature = "hash_slice", since = "1.3.0")] - fn hash_slice(data: &[Self], state: &mut H) where Self: Sized { + fn hash_slice(data: &[Self], state: &mut H) + where Self: Sized + { for piece in data { piece.hash(state); } @@ -121,7 +123,9 @@ pub trait Hasher { /// Write a single `u8` into this hasher #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_u8(&mut self, i: u8) { self.write(&[i]) } + fn write_u8(&mut self, i: u8) { + self.write(&[i]) + } /// Write a single `u16` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] @@ -145,8 +149,7 @@ pub trait Hasher { #[stable(feature = "hasher_write", since = "1.3.0")] fn write_usize(&mut self, i: usize) { let bytes = unsafe { - ::slice::from_raw_parts(&i as *const usize as *const u8, - mem::size_of::()) + ::slice::from_raw_parts(&i as *const usize as *const u8, mem::size_of::()) }; self.write(bytes); } @@ -154,23 +157,33 @@ pub trait Hasher { /// Write a single `i8` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_i8(&mut self, i: i8) { self.write_u8(i as u8) } + fn write_i8(&mut self, i: i8) { + self.write_u8(i as u8) + } /// Write a single `i16` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_i16(&mut self, i: i16) { self.write_u16(i as u16) } + fn write_i16(&mut self, i: i16) { + self.write_u16(i as u16) + } /// Write a single `i32` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_i32(&mut self, i: i32) { self.write_u32(i as u32) } + fn write_i32(&mut self, i: i32) { + self.write_u32(i as u32) + } /// Write a single `i64` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_i64(&mut self, i: i64) { self.write_u64(i as u64) } + fn write_i64(&mut self, i: i64) { + self.write_u64(i as u64) + } /// Write a single `isize` into this hasher. #[inline] #[stable(feature = "hasher_write", since = "1.3.0")] - fn write_isize(&mut self, i: isize) { self.write_usize(i as usize) } + fn write_isize(&mut self, i: isize) { + self.write_usize(i as usize) + } } ////////////////////////////////////////////////////////////////////////////// diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index 32a4f1e5bd7..722d77a8a11 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -37,12 +37,12 @@ pub struct SipHasher { // and simd implementations of SipHash will use vectors // of v02 and v13. By placing them in this order in the struct, // the compiler can pick up on just a few simd optimizations by itself. - v0: u64, // hash state + v0: u64, // hash state v2: u64, v1: u64, v3: u64, tail: u64, // unprocessed bytes le - ntail: usize, // how many bytes in tail are valid + ntail: usize, // how many bytes in tail are valid } // sadly, these macro definitions can't appear later, @@ -80,8 +80,7 @@ macro_rules! u8to64_le { unsafe fn load_u64_le(buf: &[u8], i: usize) -> u64 { debug_assert!(i + 8 <= buf.len()); let mut data = 0u64; - ptr::copy_nonoverlapping(buf.get_unchecked(i), - &mut data as *mut _ as *mut u8, 8); + ptr::copy_nonoverlapping(buf.get_unchecked(i), &mut data as *mut _ as *mut u8, 8); data.to_le() } @@ -152,12 +151,12 @@ impl Hasher for SipHasher { if self.ntail != 0 { needed = 8 - self.ntail; if length < needed { - self.tail |= u8to64_le!(msg, 0, length) << 8*self.ntail; + self.tail |= u8to64_le!(msg, 0, length) << 8 * self.ntail; self.ntail += length; return } - let m = self.tail | u8to64_le!(msg, 0, needed) << 8*self.ntail; + let m = self.tail | u8to64_le!(msg, 0, needed) << 8 * self.ntail; self.v3 ^= m; compress!(self.v0, self.v1, self.v2, self.v3); From 11a7773a3acfb3c48d56cecb6a5ab076f9d71dfe Mon Sep 17 00:00:00 2001 From: Michael Pankov Date: Thu, 8 Oct 2015 01:08:33 +0300 Subject: [PATCH 16/16] Fix comment gone astray --- src/libcore/fmt/num.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 5d8f5858078..23642790a88 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -85,8 +85,9 @@ trait GenericRadix { *byte = self.digit(n.to_u8()); // Store the digit in the buffer. curr -= 1; if x == zero { + // No more digits left to accumulate. break - }; // No more digits left to accumulate. + }; } } let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) };