---

yaml
---
r: 209654
b: refs/heads/try
c: 2a24e97
h: refs/heads/master
v: v3

Author: fhahn

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: fe113931729f3c6cce1e81a4af9e908f45386d98
+refs/heads/try: 2a24e97c80d5004cd1b57cb96a0bde6fe43a848d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/Makefile.in

@@ -76,7 +76,7 @@
 #
 #   * `CFG_ENABLE_VALGRIND=1` - Run tests under valgrind
 #   * `VALGRIND_COMPILE=1` - Run the compiler itself under valgrind
-#                            (requires `CFG_ENABLE_VALGRIND`)
+#                            (may require `CFG_ENABLE_VALGRIND`)
 #
 #   * `NO_REBUILD=1` - Don't rebootstrap when testing std
 #                      (and possibly other crates)

branches/try/mk/main.mk

@@ -18,7 +18,7 @@ CFG_RELEASE_NUM=1.0.0
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release
 # versions (section 9)
-CFG_PRERELEASE_VERSION=.3
+CFG_PRERELEASE_VERSION=.2
 
 CFG_FILENAME_EXTRA=4e7c5e5c
 

branches/try/mk/platform.mk

@@ -46,9 +46,8 @@ endif
 # see https://blog.mozilla.org/jseward/2012/06/05/valgrind-now-supports-jemalloc-builds-directly/
 ifdef CFG_VALGRIND
   CFG_VALGRIND += --error-exitcode=100 \
-                  --fair-sched=try \
-                  --quiet \
                   --soname-synonyms=somalloc=NONE \
+                  --quiet \
                   --suppressions=$(CFG_SRC_DIR)src/etc/x86.supp \
                   $(OS_SUPP)
   ifdef CFG_ENABLE_HELGRIND

branches/try/src/doc/complement-design-faq.md

@@ -165,13 +165,12 @@ particularly easy to read.
 
 ## Why is `let` used to introduce variables?
 
-Instead of the term "variable", we use "variable bindings". The
-simplest way for creating a binding is by using the `let` syntax.
-Other ways include `if let`, `while let`, and `match`. Bindings also
-exist in function argument positions.
+We don't use the term "variable", instead, we use "variable bindings". The
+simplest way for binding is the `let` syntax, other ways including `if let`,
+`while let` and `match`. Bindings also exist in function arguments positions.
 
 Bindings always happen in pattern matching positions, and it's also Rust's way
-to declare mutability. One can also re-declare mutability of a binding in
+to declare mutability. One can also redeclare mutability of a binding in
 pattern matching. This is useful to avoid unnecessary `mut` annotations. An
 interesting historical note is that Rust comes, syntactically, most closely
 from ML, which also uses `let` to introduce bindings.

branches/try/src/doc/complement-lang-faq.md

@@ -42,7 +42,10 @@ Let the fact that this is an easily countable number be a warning.
 
 ## Does it run on Windows?
 
-Yes. All development happens in lockstep on all 3 target platforms (using MinGW, not Cygwin).
+Yes. All development happens in lockstep on all 3 target platforms (using MinGW, not Cygwin). Note that the Windows implementation currently has some limitations; in particular, the 64-bit build is [not fully supported yet][win64], and all executables created by rustc [depend on libgcc DLL at runtime][libgcc].
+
+[win64]: https://github.com/rust-lang/rust/issues/1237
+[libgcc]: https://github.com/rust-lang/rust/issues/11782
 
 ## Is it OO? How do I do this thing I normally do in an OO language?
 
@@ -121,7 +124,7 @@ Yes. Calling C code from Rust is simple and exactly as efficient as calling C co
 
 Yes. The Rust code has to be exposed via an `extern` declaration, which makes it C-ABI compatible. Such a function can be passed to C code as a function pointer or, if given the `#[no_mangle]` attribute to disable symbol mangling, can be called directly from C code.
 
-## Why aren't function signatures inferred? Why only local variables?
+## Why aren't function signatures inferred? Why only local slots?
 
 * Mechanically, it simplifies the inference algorithm; inference only requires looking at one function at a time.
 * The same simplification goes double for human readers. A reader does not need an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby.

branches/try/src/doc/grammar.md

@@ -5,7 +5,8 @@
 This document is the primary reference for the Rust programming language grammar. It
 provides only one kind of material:
 
-  - Chapters that formally define the language grammar.
+  - Chapters that formally define the language grammar and, for each
+    construct.
 
 This document does not serve as an introduction to the language. Background
 familiarity with the language is assumed. A separate [guide] is available to
@@ -426,7 +427,7 @@ meta_seq : meta_item [ ',' meta_seq ] ? ;
 **FIXME:** grammar?
 
 A _declaration statement_ is one that introduces one or more *names* into the
-enclosing statement block. The declared names may denote new variables or new
+enclosing statement block. The declared names may denote new slots or new
 items.
 
 #### Item declarations
@@ -440,7 +441,7 @@ function, enumeration, structure, type, static, trait, implementation or module
 scope to a narrow region containing all of its uses; it is otherwise identical
 in meaning to declaring the item outside the statement block.
 
-#### Variable declarations
+#### Slot declarations
 
 ```antlr
 let_decl : "let" pat [':' type ] ? [ init ] ? ';' ;
@@ -762,7 +763,7 @@ bound := path | lifetime
 
 ### Memory ownership
 
-### Variables
+### Memory slots
 
 ### Boxes