auto merge of #14601 : skade/rust/remove-notrust-tags, r=alexcrichton
Now that rustdoc understands proper language tags as the code not being Rust, we can tag everything properly. `norust` as a negative statement is a bad tag. This change tags examples in other languages by their language. Plain notations are marked as `text`. Console examples are marked as `console`. Also fix markdown.rs to not highlight non-rust code. Amends the documentation to reflect the new behaviour.
This commit is contained in:
bors
commit
63e9b8f105
19 changed files with 165 additions and 156 deletions
|
|
@ -255,7 +255,7 @@ Note: The Rust signatures should be wrapped in an `extern "ABI" { ... }` block.
|
|||
|
||||
You might see things like this in C APIs:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~c
|
||||
typedef struct Window Window;
|
||||
Window* createWindow(int width, int height);
|
||||
~~~
|
||||
|
|
|
|||
|
|
@ -135,7 +135,7 @@ For simplicity, we do not plan to do so. Implementing automatic semicolon insert
|
|||
|
||||
**Short answer** set the RUST_LOG environment variable to the name of your source file, sans extension.
|
||||
|
||||
```notrust,sh
|
||||
```sh
|
||||
rustc hello.rs
|
||||
export RUST_LOG=hello
|
||||
./hello
|
||||
|
|
|
|||
|
|
@ -229,7 +229,7 @@ fn main() {
|
|||
|
||||
C code:
|
||||
|
||||
~~~~ {.notrust}
|
||||
~~~~c
|
||||
typedef void (*rust_callback)(int32_t);
|
||||
rust_callback cb;
|
||||
|
||||
|
|
@ -296,7 +296,7 @@ fn main() {
|
|||
|
||||
C code:
|
||||
|
||||
~~~~ {.notrust}
|
||||
~~~~c
|
||||
typedef void (*rust_callback)(int32_t);
|
||||
void* cb_target;
|
||||
rust_callback cb;
|
||||
|
|
|
|||
|
|
@ -218,7 +218,7 @@ fn example3() -> int {
|
|||
To make this clearer, consider this diagram showing the state of
|
||||
memory immediately before the re-assignment of `x`:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.text}
|
||||
Stack Exchange Heap
|
||||
|
||||
x +-------------+
|
||||
|
|
@ -232,7 +232,7 @@ memory immediately before the re-assignment of `x`:
|
|||
|
||||
Once the reassignment occurs, the memory will look like this:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.text}
|
||||
Stack Exchange Heap
|
||||
|
||||
x +-------------+ +---------+
|
||||
|
|
@ -329,7 +329,7 @@ to a pointer of type `&size` into the _interior of the enum_.
|
|||
To make this more clear, let's look at a diagram of memory layout in
|
||||
the case where `shape` points at a rectangle:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.text}
|
||||
Stack Memory
|
||||
|
||||
+-------+ +---------------+
|
||||
|
|
@ -354,7 +354,7 @@ to store that shape value would still be valid, _it would have a
|
|||
different type_! The following diagram shows what memory would look
|
||||
like if code overwrote `shape` with a circle:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.text}
|
||||
Stack Memory
|
||||
|
||||
+-------+ +---------------+
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ fn main() {
|
|||
|
||||
And now I get an error:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
error: mismatched types: expected `&int` but found `<generic integer #0>` (expected &-ptr but found integral variable)
|
||||
~~~
|
||||
|
||||
|
|
@ -201,7 +201,7 @@ fn main() {
|
|||
|
||||
This prints:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
Cons(1, box Cons(2, box Cons(3, box Nil)))
|
||||
~~~
|
||||
|
||||
|
|
@ -347,7 +347,7 @@ fn main() {
|
|||
|
||||
It gives this error:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
test.rs:5:8: 5:10 error: cannot assign to `*x` because it is borrowed
|
||||
test.rs:5 *x -= 1;
|
||||
^~
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ fn return_two_test() {
|
|||
To run these tests, compile with `rustc --test` and run the resulting
|
||||
binary:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ rustc --test foo.rs
|
||||
$ ./foo
|
||||
running 1 test
|
||||
|
|
@ -111,7 +111,7 @@ sequentially.
|
|||
|
||||
### Typical test run
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests
|
||||
|
||||
running 30 tests
|
||||
|
|
@ -125,7 +125,7 @@ result: ok. 28 passed; 0 failed; 2 ignored
|
|||
|
||||
### Test run with failures
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests
|
||||
|
||||
running 30 tests
|
||||
|
|
@ -139,7 +139,7 @@ result: FAILED. 27 passed; 1 failed; 2 ignored
|
|||
|
||||
### Running ignored tests
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests --ignored
|
||||
|
||||
running 2 tests
|
||||
|
|
@ -153,7 +153,7 @@ result: FAILED. 1 passed; 1 failed; 0 ignored
|
|||
|
||||
Using a plain string:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests mytest23
|
||||
|
||||
running 1 tests
|
||||
|
|
@ -164,7 +164,7 @@ result: ok. 1 passed; 0 failed; 0 ignored
|
|||
|
||||
Using some regular expression features:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests 'mytest[145]'
|
||||
|
||||
running 13 tests
|
||||
|
|
@ -247,7 +247,7 @@ Advice on writing benchmarks:
|
|||
To run benchmarks, pass the `--bench` flag to the compiled
|
||||
test-runner. Benchmarks are compiled-in but not executed by default.
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ rustc mytests.rs -O --test
|
||||
$ mytests --bench
|
||||
|
||||
|
|
@ -283,7 +283,7 @@ fn bench_xor_1000_ints(b: &mut Bencher) {
|
|||
|
||||
gives the following results
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
running 1 test
|
||||
test bench_xor_1000_ints ... bench: 0 ns/iter (+/- 0)
|
||||
|
||||
|
|
@ -323,7 +323,7 @@ overhead (e.g. `black_box(&huge_struct)`).
|
|||
Performing either of the above changes gives the following
|
||||
benchmarking results
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
running 1 test
|
||||
test bench_xor_1000_ints ... bench: 375 ns/iter (+/- 148)
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ and is the feature from which many of Rust's powerful capabilities are derived.
|
|||
write, and ultimately release, memory.
|
||||
Let's start by looking at some C++ code:
|
||||
|
||||
```notrust
|
||||
```cpp
|
||||
int* dangling(void)
|
||||
{
|
||||
int i = 1234;
|
||||
|
|
@ -74,7 +74,7 @@ fn main() {
|
|||
|
||||
Save this program as `dangling.rs`. When you try to compile this program with `rustc dangling.rs`, you'll get an interesting (and long) error message:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
dangling.rs:3:12: 3:14 error: `i` does not live long enough
|
||||
dangling.rs:3 return &i;
|
||||
^~
|
||||
|
|
@ -155,7 +155,7 @@ You can roughly compare these two lines:
|
|||
let i = box 1234;
|
||||
```
|
||||
|
||||
```notrust
|
||||
```cpp
|
||||
// C++
|
||||
int *i = new int;
|
||||
*i = 1234;
|
||||
|
|
@ -254,7 +254,7 @@ fn main() {
|
|||
|
||||
This will result an error indicating that the value is no longer in scope:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
concurrency.rs:12:20: 12:27 error: use of moved value: 'numbers'
|
||||
concurrency.rs:12 println!("{}", numbers.get(0));
|
||||
^~~~~~~
|
||||
|
|
|
|||
|
|
@ -356,15 +356,15 @@ msgstr "上記条件を満たしていれば、以下のような手順でビル
|
|||
#: src/doc/tutorial.md:112
|
||||
#, fuzzy
|
||||
#| msgid ""
|
||||
#| "~~~~ {.notrust} $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar."
|
||||
#| "~~~~console $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar."
|
||||
#| "gz $ tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure $ make && make "
|
||||
#| "install ~~~~"
|
||||
msgid ""
|
||||
"~~~~ {.notrust} $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz $ "
|
||||
"~~~~console $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz $ "
|
||||
"tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure $ make && make install "
|
||||
"~~~~"
|
||||
msgstr ""
|
||||
"~~~~ {.notrust}\n"
|
||||
"~~~~console\n"
|
||||
"$ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz\n"
|
||||
"$ tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure\n"
|
||||
"$ make && make install\n"
|
||||
|
|
@ -4610,7 +4610,7 @@ msgstr ""
|
|||
#: src/doc/tutorial.md:2761 src/doc/tutorial.md:2793
|
||||
#, fuzzy
|
||||
#| msgid "~~~~ {.ignore} let foo = 10;"
|
||||
msgid "~~~ {.notrust} src/plants.rs src/plants/mod.rs"
|
||||
msgid "~~~text src/plants.rs src/plants/mod.rs"
|
||||
msgstr ""
|
||||
"~~~~ {.ignore}\n"
|
||||
"let foo = 10;"
|
||||
|
|
@ -4927,24 +4927,24 @@ msgstr ""
|
|||
#: src/doc/tutorial.md:3168
|
||||
#, fuzzy, no-wrap
|
||||
#| msgid ""
|
||||
#| "~~~~ {.notrust}\n"
|
||||
#| "> rustc --lib world.rs # compiles libworld-94839cbfe144198-1.0.so\n"
|
||||
#| "> rustc main.rs -L . # compiles main\n"
|
||||
#| "> ./main\n"
|
||||
#| "~~~~console\n"
|
||||
#| "$ rustc --lib world.rs # compiles libworld-94839cbfe144198-1.0.so\n"
|
||||
#| "$ rustc main.rs -L . # compiles main\n"
|
||||
#| "$ ./main\n"
|
||||
#| "\"hello world\"\n"
|
||||
#| "~~~~\n"
|
||||
msgid ""
|
||||
"~~~~ {.notrust}\n"
|
||||
"> rustc --lib world.rs # compiles libworld-<HASH>-0.42.so\n"
|
||||
"> rustc main.rs -L . # compiles main\n"
|
||||
"> ./main\n"
|
||||
"~~~~console\n"
|
||||
"$ rustc --crate-type=lib world.rs # compiles libworld-<HASH>-0.42.so\n"
|
||||
"$ rustc main.rs -L . # compiles main\n"
|
||||
"$ ./main\n"
|
||||
"\"hello world\"\n"
|
||||
"~~~~\n"
|
||||
msgstr ""
|
||||
"~~~~ {.notrust}\n"
|
||||
"> rustc --lib world.rs # libworld-94839cbfe144198-1.0.so が生成される\n"
|
||||
"> rustc main.rs -L . # main が生成される\n"
|
||||
"> ./main\n"
|
||||
"~~~~console\n"
|
||||
"$ rustc --lib world.rs # libworld-94839cbfe144198-1.0.so が生成される\n"
|
||||
"$ rustc main.rs -L . # main が生成される\n"
|
||||
"$ ./main\n"
|
||||
"\"hello world\"\n"
|
||||
"~~~~\n"
|
||||
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ dialect of EBNF supported by common automated LL(k) parsing tools such as
|
|||
`llgen`, rather than the dialect given in ISO 14977. The dialect can be
|
||||
defined self-referentially as follows:
|
||||
|
||||
~~~~ {.notrust .ebnf .notation}
|
||||
~~~~ {.ebnf .notation}
|
||||
grammar : rule + ;
|
||||
rule : nonterminal ':' productionrule ';' ;
|
||||
productionrule : production [ '|' production ] * ;
|
||||
|
|
@ -153,7 +153,7 @@ Some productions are defined by exclusion of particular Unicode characters:
|
|||
|
||||
## Comments
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
comment : block_comment | line_comment ;
|
||||
block_comment : "/*" block_comment_body * '*' + '/' ;
|
||||
block_comment_body : [block_comment | character] * ;
|
||||
|
|
@ -174,7 +174,7 @@ Non-doc comments are interpreted as a form of whitespace.
|
|||
|
||||
## Whitespace
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
whitespace_char : '\x20' | '\x09' | '\x0a' | '\x0d' ;
|
||||
whitespace : [ whitespace_char | comment ] + ;
|
||||
~~~~
|
||||
|
|
@ -191,7 +191,7 @@ with any other legal whitespace element, such as a single space character.
|
|||
|
||||
## Tokens
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
simple_token : keyword | unop | binop ;
|
||||
token : simple_token | ident | literal | symbol | whitespace token ;
|
||||
~~~~
|
||||
|
|
@ -205,7 +205,7 @@ grammar as double-quoted strings. Other tokens have exact rules given.
|
|||
|
||||
The keywords are the following strings:
|
||||
|
||||
~~~~ {.notrust .keyword}
|
||||
~~~~ {.text .keyword}
|
||||
as
|
||||
box break
|
||||
continue crate
|
||||
|
|
@ -233,13 +233,13 @@ evaluates to, rather than referring to it by name or some other evaluation
|
|||
rule. A literal is a form of constant expression, so is evaluated (primarily)
|
||||
at compile time.
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
literal : string_lit | char_lit | num_lit ;
|
||||
~~~~
|
||||
|
||||
#### Character and string literals
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
char_lit : '\x27' char_body '\x27' ;
|
||||
string_lit : '"' string_body * '"' | 'r' raw_string ;
|
||||
|
||||
|
|
@ -321,7 +321,7 @@ r##"foo #"# bar"##; // foo #"# bar
|
|||
|
||||
#### Number literals
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?
|
||||
| '0' [ [ dec_digit | '_' ] * num_suffix ?
|
||||
| 'b' [ '1' | '0' | '_' ] + int_suffix ?
|
||||
|
|
@ -419,7 +419,7 @@ The two values of the boolean type are written `true` and `false`.
|
|||
|
||||
### Symbols
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
symbol : "::" "->"
|
||||
| '#' | '[' | ']' | '(' | ')' | '{' | '}'
|
||||
| ',' | ';' ;
|
||||
|
|
@ -434,7 +434,7 @@ operators](#binary-operator-expressions), or [keywords](#keywords).
|
|||
|
||||
## Paths
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
expr_path : [ "::" ] ident [ "::" expr_path_tail ] + ;
|
||||
expr_path_tail : '<' type_expr [ ',' type_expr ] + '>'
|
||||
| expr_path ;
|
||||
|
|
@ -543,7 +543,7 @@ All of the above extensions are expressions with values.
|
|||
|
||||
## Macros
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ;
|
||||
macro_rule : '(' matcher * ')' "=>" '(' transcriber * ')' ';' ;
|
||||
matcher : '(' matcher * ')' | '[' matcher * ']'
|
||||
|
|
@ -687,7 +687,7 @@ each of which may have some number of [attributes](#attributes) attached to it.
|
|||
|
||||
## Items
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
item : mod_item | fn_item | type_item | struct_item | enum_item
|
||||
| static_item | trait_item | impl_item | extern_block ;
|
||||
~~~~
|
||||
|
|
@ -735,7 +735,7 @@ That is, Rust has no notion of type abstraction: there are no first-class "foral
|
|||
|
||||
### Modules
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
mod_item : "mod" ident ( ';' | '{' mod '}' );
|
||||
mod : [ view_item | item ] * ;
|
||||
~~~~
|
||||
|
|
@ -803,7 +803,7 @@ mod task {
|
|||
|
||||
#### View items
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
view_item : extern_crate_decl | use_decl ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -816,7 +816,7 @@ There are several kinds of view item:
|
|||
|
||||
##### Extern crate declarations
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
extern_crate_decl : "extern" "crate" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
|
||||
link_attrs : link_attr [ ',' link_attrs ] + ;
|
||||
link_attr : ident '=' literal ;
|
||||
|
|
@ -848,7 +848,7 @@ extern crate foo = "some/where/rust-foo#foo:1.0"; // a full crate ID for externa
|
|||
|
||||
##### Use declarations
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
use_decl : "pub" ? "use" [ ident '=' path
|
||||
| path_glob ] ;
|
||||
|
||||
|
|
@ -1274,7 +1274,7 @@ whereas `Dog` is simply called an enum variant.
|
|||
|
||||
### Static items
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
static_item : "static" ident ':' type '=' expr ';' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -1519,7 +1519,7 @@ impl Seq<bool> for u32 {
|
|||
|
||||
### External blocks
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
extern_block_item : "extern" '{' extern_block '}' ;
|
||||
extern_block : [ foreign_fn ] * ;
|
||||
~~~~
|
||||
|
|
@ -1741,7 +1741,7 @@ import public items from their destination, not private items.
|
|||
|
||||
## Attributes
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
attribute : '#' '!' ? '[' meta_item ']' ;
|
||||
meta_item : ident [ '=' literal
|
||||
| '(' meta_seq ')' ] ? ;
|
||||
|
|
@ -2383,7 +2383,7 @@ declaring a function-local item.
|
|||
|
||||
#### Slot declarations
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
let_decl : "let" pat [':' type ] ? [ init ] ? ';' ;
|
||||
init : [ '=' ] expr ;
|
||||
~~~~
|
||||
|
|
@ -2483,7 +2483,7 @@ values.
|
|||
|
||||
### Structure expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
struct_expr : expr_path '{' ident ':' expr
|
||||
[ ',' ident ':' expr ] *
|
||||
[ ".." expr ] '}' |
|
||||
|
|
@ -2537,7 +2537,7 @@ Point3d {y: 0, z: 10, .. base};
|
|||
|
||||
### Block expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
block_expr : '{' [ view_item ] *
|
||||
[ stmt ';' | item ] *
|
||||
[ expr ] '}' ;
|
||||
|
|
@ -2555,7 +2555,7 @@ of the block are that of the expression itself.
|
|||
|
||||
### Method-call expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
method_call_expr : expr '.' ident paren_expr_list ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2566,7 +2566,7 @@ or dynamically dispatching if the left-hand-side expression is an indirect [obje
|
|||
|
||||
### Field expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
field_expr : expr '.' ident ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2588,7 +2588,7 @@ it is automatically dereferenced to make the field access possible.
|
|||
|
||||
### Vector expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
vec_expr : '[' "mut" ? vec_elems? ']' ;
|
||||
|
||||
vec_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
|
||||
|
|
@ -2610,7 +2610,7 @@ as a [literal](#literals) or a [static item](#static-items).
|
|||
|
||||
### Index expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
idx_expr : expr '[' expr ']' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2662,7 +2662,7 @@ before the expression they apply to.
|
|||
|
||||
### Binary operator expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
binop_expr : expr binop expr ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2803,7 +2803,7 @@ Any such expression always has the [`unit`](#primitive-types) type.
|
|||
The precedence of Rust binary operators is ordered as follows, going
|
||||
from strong to weak:
|
||||
|
||||
~~~~ {.notrust .precedence}
|
||||
~~~~ {.text .precedence}
|
||||
* / %
|
||||
as
|
||||
+ -
|
||||
|
|
@ -2827,7 +2827,7 @@ An expression enclosed in parentheses evaluates to the result of the enclosed
|
|||
expression. Parentheses can be used to explicitly specify evaluation order
|
||||
within an expression.
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
paren_expr : '(' expr ')' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2840,7 +2840,7 @@ let x = (2 + 3) * 4;
|
|||
|
||||
### Call expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
expr_list : [ expr [ ',' expr ]* ] ? ;
|
||||
paren_expr_list : '(' expr_list ')' ;
|
||||
call_expr : expr paren_expr_list ;
|
||||
|
|
@ -2863,7 +2863,7 @@ let pi: Option<f32> = FromStr::from_str("3.14");
|
|||
|
||||
### Lambda expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
ident_list : [ ident [ ',' ident ]* ] ? ;
|
||||
lambda_expr : '|' ident_list '|' expr ;
|
||||
~~~~
|
||||
|
|
@ -2906,7 +2906,7 @@ ten_times(|j| println!("hello, {}", j));
|
|||
|
||||
### While loops
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
while_expr : "while" expr '{' block '}' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2930,7 +2930,7 @@ while i < 10 {
|
|||
|
||||
A `loop` expression denotes an infinite loop.
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
loop_expr : [ lifetime ':' ] "loop" '{' block '}';
|
||||
~~~~
|
||||
|
||||
|
|
@ -2941,7 +2941,7 @@ See [Break expressions](#break-expressions) and [Continue expressions](#continue
|
|||
|
||||
### Break expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
break_expr : "break" [ lifetime ];
|
||||
~~~~
|
||||
|
||||
|
|
@ -2954,7 +2954,7 @@ but must enclose it.
|
|||
|
||||
### Continue expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
continue_expr : "continue" [ lifetime ];
|
||||
~~~~
|
||||
|
||||
|
|
@ -2973,7 +2973,7 @@ A `continue` expression is only permitted in the body of a loop.
|
|||
|
||||
### For expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
for_expr : "for" pat "in" expr '{' block '}' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -3007,7 +3007,7 @@ for i in range(0u, 256) {
|
|||
|
||||
### If expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
if_expr : "if" expr '{' block '}'
|
||||
else_tail ? ;
|
||||
|
||||
|
|
@ -3028,7 +3028,7 @@ then any `else` block is executed.
|
|||
|
||||
### Match expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
match_expr : "match" expr '{' match_arm * '}' ;
|
||||
|
||||
match_arm : attribute * match_pat "=>" [ expr "," | '{' block '}' ] ;
|
||||
|
|
@ -3219,7 +3219,7 @@ let message = match maybe_digit {
|
|||
|
||||
### Return expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
return_expr : "return" expr ? ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -3496,7 +3496,7 @@ x = bo(5,7);
|
|||
|
||||
### Closure types
|
||||
|
||||
~~~~ {.notrust .ebnf .notation}
|
||||
~~~~ {.ebnf .notation}
|
||||
closure_type := [ 'unsafe' ] [ '<' lifetime-list '>' ] '|' arg-list '|'
|
||||
[ ':' bound-list ] [ '->' type ]
|
||||
procedure_type := 'proc' [ '<' lifetime-list '>' ] '(' arg-list ')'
|
||||
|
|
@ -4107,7 +4107,7 @@ fn main() {
|
|||
|
||||
These four log levels correspond to levels 1-4, as controlled by `RUST_LOG`:
|
||||
|
||||
```notrust,bash
|
||||
```sh
|
||||
$ RUST_LOG=rust=3 ./rust
|
||||
This is an error log
|
||||
This is a warn log
|
||||
|
|
|
|||
|
|
@ -122,33 +122,41 @@ source code.
|
|||
|
||||
To test documentation, the `--test` argument is passed to rustdoc:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.sh}
|
||||
rustdoc --test crate.rs
|
||||
~~~
|
||||
|
||||
## Defining tests
|
||||
|
||||
Rust documentation currently uses the markdown format, and rustdoc treats all
|
||||
code blocks as testable-by-default. In order to not run a test over a block of
|
||||
code, the `ignore` string can be added to the three-backtick form of markdown
|
||||
code block.
|
||||
code blocks as testable-by-default unless they carry a language tag of another
|
||||
language. In order to not run a test over a block of code, the `ignore` string
|
||||
can be added to the three-backtick form of markdown code block.
|
||||
|
||||
~~~notrust
|
||||
~~~md
|
||||
```
|
||||
// This is a testable code block
|
||||
```
|
||||
|
||||
```rust{.example}
|
||||
// This is rust and also testable
|
||||
```
|
||||
|
||||
```ignore
|
||||
// This is not a testable code block
|
||||
```
|
||||
|
||||
// This is a testable code block (4-space indent)
|
||||
|
||||
```sh
|
||||
# this is shell code and not tested
|
||||
```
|
||||
~~~
|
||||
|
||||
You can specify that the test's execution should fail with the `should_fail`
|
||||
directive.
|
||||
|
||||
~~~notrust
|
||||
~~~md
|
||||
```should_fail
|
||||
// This code block is expected to generate a failure when run
|
||||
```
|
||||
|
|
@ -157,7 +165,7 @@ directive.
|
|||
You can specify that the code block should be compiled but not run with the
|
||||
`no_run` directive.
|
||||
|
||||
~~~notrust
|
||||
~~~md
|
||||
```no_run
|
||||
// This code will be compiled but not executed
|
||||
```
|
||||
|
|
@ -169,7 +177,7 @@ will not show up in the HTML documentation, but it will be used when
|
|||
testing the code block (NB. the space after the `#` is required, so
|
||||
that one can still write things like `#[deriving(Eq)]`).
|
||||
|
||||
~~~notrust
|
||||
~~~md
|
||||
```
|
||||
# /!\ The three following lines are comments, which are usually stripped off by
|
||||
# the doc-generating tool. In order to display them anyway in this particular
|
||||
|
|
@ -194,7 +202,7 @@ uses is build on crate `test`, which is also used when you compile crates with
|
|||
rustc's `--test` flag. Extra arguments can be passed to rustdoc's test harness
|
||||
with the `--test-args` flag.
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
# Only run tests containing 'foo' in their name
|
||||
$ rustdoc --test lib.rs --test-args 'foo'
|
||||
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ packages:
|
|||
If you've fulfilled those prerequisites, something along these lines
|
||||
should work.
|
||||
|
||||
~~~~ {.notrust}
|
||||
~~~~console
|
||||
$ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz
|
||||
$ tar -xzf rust-nightly.tar.gz
|
||||
$ cd rust-nightly
|
||||
|
|
@ -151,7 +151,7 @@ error. If you introduce an error into the program (for example, by changing
|
|||
`println!` to some nonexistent macro), and then compile it, you'll see
|
||||
an error message like this:
|
||||
|
||||
~~~~ {.notrust}
|
||||
~~~~text
|
||||
hello.rs:2:5: 2:24 error: macro undefined: 'print_with_unicorns'
|
||||
hello.rs:2 print_with_unicorns!("hello?");
|
||||
^~~~~~~~~~~~~~~~~~~
|
||||
|
|
@ -1066,7 +1066,7 @@ being destroyed along with the owner. Since the `list` variable above is
|
|||
immutable, the whole list is immutable. The memory allocation itself is the
|
||||
box, while the owner holds onto a pointer to it:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
List box List box List box List box
|
||||
+--------------+ +--------------+ +--------------+ +----------+
|
||||
list -> | Cons | 1 | | -> | Cons | 2 | | -> | Cons | 3 | | -> | Nil |
|
||||
|
|
@ -2841,7 +2841,7 @@ mod animals {
|
|||
|
||||
The compiler will look for these files, in this order:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
src/plants.rs
|
||||
src/plants/mod.rs
|
||||
|
||||
|
|
@ -2872,7 +2872,7 @@ mod mammals {
|
|||
|
||||
...then the source files of `mod animals`'s submodules can either be in the same directory as the animals source file or in a subdirectory of its directory. If the animals file is `src/animals.rs`, `rustc` will look for:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
src/animals.rs
|
||||
src/fish.rs
|
||||
src/fish/mod.rs
|
||||
|
|
@ -2883,7 +2883,7 @@ src/animals.rs
|
|||
|
||||
If the animals file is `src/animals/mod.rs`, `rustc` will look for:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
src/animals/mod.rs
|
||||
src/animals/fish.rs
|
||||
src/animals/fish/mod.rs
|
||||
|
|
@ -3244,10 +3244,10 @@ fn main() { println!("hello {}", world::explore()); }
|
|||
|
||||
Now compile and run like this (adjust to your platform if necessary):
|
||||
|
||||
~~~~ {.notrust}
|
||||
> rustc --crate-type=lib world.rs # compiles libworld-<HASH>-0.42.so
|
||||
> rustc main.rs -L . # compiles main
|
||||
> ./main
|
||||
~~~~console
|
||||
$ rustc --crate-type=lib world.rs # compiles libworld-<HASH>-0.42.so
|
||||
$ rustc main.rs -L . # compiles main
|
||||
$ ./main
|
||||
"hello world"
|
||||
~~~~
|
||||
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ pub trait Zero: Add<Self, Self> {
|
|||
///
|
||||
/// # Laws
|
||||
///
|
||||
/// ~~~notrust
|
||||
/// ~~~text
|
||||
/// a + 0 = a ∀ a ∈ Self
|
||||
/// 0 + a = a ∀ a ∈ Self
|
||||
/// ~~~
|
||||
|
|
@ -123,7 +123,7 @@ pub trait One: Mul<Self, Self> {
|
|||
///
|
||||
/// # Laws
|
||||
///
|
||||
/// ~~~notrust
|
||||
/// ~~~text
|
||||
/// a * 1 = a ∀ a ∈ Self
|
||||
/// 1 * a = a ∀ a ∈ Self
|
||||
/// ~~~
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ disabled except for `error!` (a log level of 1). Logging is controlled via the
|
|||
`RUST_LOG` environment variable. The value of this environment variable is a
|
||||
comma-separated list of logging directives. A logging directive is of the form:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
path::to::module=log_level
|
||||
```
|
||||
|
||||
|
|
@ -80,7 +80,7 @@ all modules is set to this value.
|
|||
|
||||
Some examples of valid values of `RUST_LOG` are:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
hello // turns on all logging for the 'hello' module
|
||||
info // turns on all info logging
|
||||
hello=debug // turns on debug logging for 'hello'
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ use super::{IndependentSample, Sample, Exp};
|
|||
///
|
||||
/// The density function of this distribution is
|
||||
///
|
||||
/// ```notrust
|
||||
/// ```text
|
||||
/// f(x) = x^(k - 1) * exp(-x / θ) / (Γ(k) * θ^k)
|
||||
/// ```
|
||||
///
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ it is safe with respect to the in-scope loans.
|
|||
Throughout the docs we'll consider a simple subset of Rust in which
|
||||
you can only borrow from lvalues, defined like so:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LV = x | LV.f | *LV
|
||||
```
|
||||
|
||||
|
|
@ -64,7 +64,7 @@ Here `x` represents some variable, `LV.f` is a field reference,
|
|||
and `*LV` is a pointer dereference. There is no auto-deref or other
|
||||
niceties. This means that if you have a type like:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
struct S { f: uint }
|
||||
```
|
||||
|
||||
|
|
@ -73,7 +73,7 @@ to an `LV` of `(*a).f`.
|
|||
|
||||
Here is the formal grammar for the types we'll consider:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
TY = () | S<'LT...> | Box<TY> | & 'LT MQ TY | @ MQ TY
|
||||
MQ = mut | imm | const
|
||||
```
|
||||
|
|
@ -81,7 +81,7 @@ MQ = mut | imm | const
|
|||
Most of these types should be pretty self explanatory. Here `S` is a
|
||||
struct name and we assume structs are declared like so:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SD = struct S<'LT...> { (f: TY)... }
|
||||
```
|
||||
|
||||
|
|
@ -93,7 +93,7 @@ SD = struct S<'LT...> { (f: TY)... }
|
|||
|
||||
Now, imagine we had a program like this:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
struct Foo { f: uint, g: uint }
|
||||
...
|
||||
'a: {
|
||||
|
|
@ -118,7 +118,7 @@ the borrow, and (3) a set of restrictions. In the code, `Loan` is a
|
|||
struct defined in `middle::borrowck`. Formally, we define `LOAN` as
|
||||
follows:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LOAN = (LV, LT, MQ, RESTRICTION*)
|
||||
RESTRICTION = (LV, ACTION*)
|
||||
ACTION = MUTATE | CLAIM | FREEZE
|
||||
|
|
@ -151,7 +151,7 @@ To give you a better feeling for what kind of restrictions derived
|
|||
from a loan, let's look at the loan `L` that would be issued as a
|
||||
result of the borrow `&mut (*x).f` in the example above:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
L = ((*x).f, 'a, mut, RS) where
|
||||
RS = [((*x).f, [MUTATE, CLAIM, FREEZE]),
|
||||
(*x, [MUTATE, CLAIM, FREEZE]),
|
||||
|
|
@ -214,7 +214,7 @@ conditions that it uses. For simplicity I will ignore const loans.
|
|||
I will present the rules in a modified form of standard inference
|
||||
rules, which looks as follows:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
PREDICATE(X, Y, Z) // Rule-Name
|
||||
Condition 1
|
||||
Condition 2
|
||||
|
|
@ -290,7 +290,7 @@ Let's begin with the rules for variables, which state that if a
|
|||
variable is declared as mutable, it may be borrowed any which way, but
|
||||
otherwise the variable must be borrowed as immutable or const:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
MUTABILITY(X, MQ) // M-Var-Mut
|
||||
DECL(X) = mut
|
||||
|
||||
|
|
@ -305,7 +305,7 @@ Fields and owned pointers inherit their mutability from
|
|||
their base expressions, so both of their rules basically
|
||||
delegate the check to the base expression `LV`:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
MUTABILITY(LV.f, MQ) // M-Field
|
||||
MUTABILITY(LV, MQ)
|
||||
|
||||
|
|
@ -319,7 +319,7 @@ MUTABILITY(*LV, MQ) // M-Deref-Unique
|
|||
Immutable pointer types like `&T` and `@T` can only
|
||||
be borrowed if MQ is immutable or const:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
MUTABILITY(*LV, MQ) // M-Deref-Borrowed-Imm
|
||||
TYPE(LV) = &Ty
|
||||
MQ == imm | const
|
||||
|
|
@ -333,7 +333,7 @@ MUTABILITY(*LV, MQ) // M-Deref-Managed-Imm
|
|||
|
||||
`&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
MUTABILITY(*LV, MQ) // M-Deref-Borrowed-Mut
|
||||
TYPE(LV) = &mut Ty
|
||||
```
|
||||
|
|
@ -352,7 +352,7 @@ Rust code corresponding to this predicate is the function
|
|||
Local variables are never aliasable as they are accessible only within
|
||||
the stack frame.
|
||||
|
||||
```notrust
|
||||
```text
|
||||
ALIASABLE(X, MQ) // M-Var-Mut
|
||||
```
|
||||
|
||||
|
|
@ -360,7 +360,7 @@ the stack frame.
|
|||
|
||||
Owned content is aliasable if it is found in an aliasable location:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
ALIASABLE(LV.f, MQ) // M-Field
|
||||
ALIASABLE(LV, MQ)
|
||||
|
||||
|
|
@ -373,7 +373,7 @@ ALIASABLE(*LV, MQ) // M-Deref-Unique
|
|||
Immutable pointer types like `&T` are aliasable, and hence can only be
|
||||
borrowed immutably:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
ALIASABLE(*LV, imm) // M-Deref-Borrowed-Imm
|
||||
TYPE(LV) = &Ty
|
||||
```
|
||||
|
|
@ -382,7 +382,7 @@ ALIASABLE(*LV, imm) // M-Deref-Borrowed-Imm
|
|||
|
||||
`&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
ALIASABLE(*LV, MQ) // M-Deref-Borrowed-Mut
|
||||
TYPE(LV) = &mut Ty
|
||||
```
|
||||
|
|
@ -405,13 +405,13 @@ guaranteed to exist, presuming that no mutations occur.
|
|||
|
||||
The scope of a local variable is the block where it is declared:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(X) = block where X is declared
|
||||
```
|
||||
|
||||
The scope of a field is the scope of the struct:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(LV.f) = SCOPE(LV)
|
||||
```
|
||||
|
||||
|
|
@ -419,7 +419,7 @@ The scope of a unique referent is the scope of the pointer, since
|
|||
(barring mutation or moves) the pointer will not be freed until
|
||||
the pointer itself `LV` goes out of scope:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(*LV) = SCOPE(LV) if LV has type Box<T>
|
||||
```
|
||||
|
||||
|
|
@ -427,7 +427,7 @@ The scope of a managed referent is also the scope of the pointer. This
|
|||
is a conservative approximation, since there may be other aliases for
|
||||
that same managed box that would cause it to live longer:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(*LV) = SCOPE(LV) if LV has type @T
|
||||
```
|
||||
|
||||
|
|
@ -435,7 +435,7 @@ The scope of a borrowed referent is the scope associated with the
|
|||
pointer. This is a conservative approximation, since the data that
|
||||
the pointer points at may actually live longer:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(*LV) = LT if LV has type &'LT T or &'LT mut T
|
||||
```
|
||||
|
||||
|
|
@ -444,7 +444,7 @@ the pointer points at may actually live longer:
|
|||
The rule for variables states that a variable can only be borrowed a
|
||||
lifetime `LT` that is a subregion of the variable's scope:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(X, LT, MQ) // L-Local
|
||||
LT <= SCOPE(X)
|
||||
```
|
||||
|
|
@ -454,7 +454,7 @@ LIFETIME(X, LT, MQ) // L-Local
|
|||
The lifetime of a field or owned pointer is the same as the lifetime
|
||||
of its owner:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(LV.f, LT, MQ) // L-Field
|
||||
LIFETIME(LV, LT, MQ)
|
||||
|
||||
|
|
@ -471,7 +471,7 @@ lifetime. Therefore, the borrow is valid so long as the lifetime `LT`
|
|||
of the borrow is shorter than the lifetime `LT'` of the pointer
|
||||
itself:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(*LV, LT, MQ) // L-Deref-Borrowed
|
||||
TYPE(LV) = <' Ty OR <' mut Ty
|
||||
LT <= LT'
|
||||
|
|
@ -484,7 +484,7 @@ Managed pointers are valid so long as the data within them is
|
|||
when the user guarantees such a root will exist. For this to be true,
|
||||
three conditions must be met:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(*LV, LT, MQ) // L-Deref-Managed-Imm-User-Root
|
||||
TYPE(LV) = @Ty
|
||||
LT <= SCOPE(LV) // (1)
|
||||
|
|
@ -518,7 +518,7 @@ borrow without crossing the exit from the scope `LT`.
|
|||
|
||||
The rule for compiler rooting is as follows:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(*LV, LT, MQ) // L-Deref-Managed-Imm-Compiler-Root
|
||||
TYPE(LV) = @Ty
|
||||
LT <= innermost enclosing loop/func
|
||||
|
|
@ -542,7 +542,7 @@ for the lifetime of the loan".
|
|||
Note that there is an initial set of restrictions: these restrictions
|
||||
are computed based on the kind of borrow:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
&mut LV => RESTRICTIONS(LV, LT, MUTATE|CLAIM|FREEZE)
|
||||
&LV => RESTRICTIONS(LV, LT, MUTATE|CLAIM)
|
||||
&const LV => RESTRICTIONS(LV, LT, [])
|
||||
|
|
@ -559,7 +559,7 @@ moved out from under it, so no actions are forbidden.
|
|||
|
||||
The simplest case is a borrow of a local variable `X`:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(X, LT, ACTIONS) = (X, ACTIONS) // R-Variable
|
||||
```
|
||||
|
||||
|
|
@ -570,7 +570,7 @@ In such cases we just record the actions that are not permitted.
|
|||
Restricting a field is the same as restricting the owner of that
|
||||
field:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(LV.f, LT, ACTIONS) = RS, (LV.f, ACTIONS) // R-Field
|
||||
RESTRICTIONS(LV, LT, ACTIONS) = RS
|
||||
```
|
||||
|
|
@ -593,7 +593,7 @@ must prevent the owned pointer `LV` from being mutated, which means
|
|||
that we always add `MUTATE` and `CLAIM` to the restriction set imposed
|
||||
on `LV`:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS) // R-Deref-Send-Pointer
|
||||
TYPE(LV) = Box<Ty>
|
||||
RESTRICTIONS(LV, LT, ACTIONS|MUTATE|CLAIM) = RS
|
||||
|
|
@ -610,7 +610,7 @@ restricting that path. Therefore, the rule for `&Ty` and `@Ty`
|
|||
pointers always returns an empty set of restrictions, and it only
|
||||
permits restricting `MUTATE` and `CLAIM` actions:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(*LV, LT, ACTIONS) = [] // R-Deref-Imm-Managed
|
||||
TYPE(LV) = @Ty
|
||||
ACTIONS subset of [MUTATE, CLAIM]
|
||||
|
|
@ -733,7 +733,7 @@ Because moves from a `&const` or `@const` lvalue are never legal, it
|
|||
is not necessary to add any restrictions at all to the final
|
||||
result.
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(*LV, LT, []) = [] // R-Deref-Freeze-Borrowed
|
||||
TYPE(LV) = &const Ty or @const Ty
|
||||
```
|
||||
|
|
@ -749,7 +749,7 @@ while the new claimant is live.
|
|||
|
||||
The rule for mutable borrowed pointers is as follows:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS) // R-Deref-Mut-Borrowed
|
||||
TYPE(LV) = <' mut Ty
|
||||
LT <= LT' // (1)
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ There are several critical invariants which we maintain:
|
|||
> types lie in between. The bottom type is then the Null type.
|
||||
> So the tree looks like:
|
||||
>
|
||||
> ```notrust
|
||||
> ```text
|
||||
> Object
|
||||
> / \
|
||||
> String Other
|
||||
|
|
@ -106,7 +106,7 @@ Pictorally, what this does is to take two distinct variables with
|
|||
(hopefully not completely) distinct type ranges and produce one with
|
||||
the intersection.
|
||||
|
||||
```notrust
|
||||
```text
|
||||
B.ub B.ub
|
||||
/\ /
|
||||
A.ub / \ A.ub /
|
||||
|
|
@ -129,7 +129,7 @@ bounds in such a way that, whatever happens, we know that A <: B will hold.
|
|||
This can be achieved by ensuring that A.ub <: B.lb. In practice there
|
||||
are two ways to do that, depicted pictorally here:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
Before Option #1 Option #2
|
||||
|
||||
B.ub B.ub B.ub
|
||||
|
|
@ -164,7 +164,7 @@ course, it depends on the program.
|
|||
|
||||
The main case which fails today that I would like to support is:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
fn foo<T>(x: T, y: T) { ... }
|
||||
|
||||
fn bar() {
|
||||
|
|
|
|||
|
|
@ -168,7 +168,8 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
|
|||
slice::raw::buf_as_slice((*lang).data,
|
||||
(*lang).size as uint, |rlang| {
|
||||
let rlang = str::from_utf8(rlang).unwrap();
|
||||
if rlang.contains("notrust") {
|
||||
let (_,_,_,notrust) = parse_lang_string(rlang);
|
||||
if notrust {
|
||||
(my_opaque.dfltblk)(ob, &buf, lang,
|
||||
opaque as *mut libc::c_void);
|
||||
true
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ function, but the `format!` macro is a syntax extension which allows it to
|
|||
leverage named parameters. Named parameters are listed at the end of the
|
||||
argument list and have the syntax:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
identifier '=' expression
|
||||
```
|
||||
|
||||
|
|
@ -110,7 +110,7 @@ Each argument's type is dictated by the format string. It is a requirement that
|
|||
every argument is only ever referred to by one type. For example, this is an
|
||||
invalid format string:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
{0:d} {0:s}
|
||||
```
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ must have the type `uint`. Although a `uint` can be printed with `{:u}`, it is
|
|||
illegal to reference an argument as such. For example, this is another invalid
|
||||
format string:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
{:.*s} {0:u}
|
||||
```
|
||||
|
||||
|
|
@ -347,7 +347,7 @@ This example is the equivalent of `{0:s}` essentially.
|
|||
The select method is a switch over a `&str` parameter, and the parameter *must*
|
||||
be of the type `&str`. An example of the syntax is:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
{0, select, male{...} female{...} other{...}}
|
||||
```
|
||||
|
||||
|
|
@ -366,7 +366,7 @@ The plural method is a switch statement over a `uint` parameter, and the
|
|||
parameter *must* be a `uint`. A plural method in its full glory can be specified
|
||||
as:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
{0, plural, offset=1 =1{...} two{...} many{...} other{...}}
|
||||
```
|
||||
|
||||
|
|
@ -394,7 +394,7 @@ should not be too alien. Arguments are formatted with python-like syntax,
|
|||
meaning that arguments are surrounded by `{}` instead of the C-like `%`. The
|
||||
actual grammar for the formatting syntax is:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
format_string := <text> [ format <text> ] *
|
||||
format := '{' [ argument ] [ ':' format_spec ] [ ',' function_spec ] '}'
|
||||
argument := integer | identifier
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ above `PartialEq`, `A`, `B` and `C`.
|
|||
|
||||
When generating the `expr` for the `A` impl, the `SubstructureFields` is
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
Struct(~[FieldInfo {
|
||||
span: <span of x>
|
||||
name: Some(<ident of x>),
|
||||
|
|
@ -113,7 +113,7 @@ Struct(~[FieldInfo {
|
|||
|
||||
For the `B` impl, called with `B(a)` and `B(b)`,
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
Struct(~[FieldInfo {
|
||||
span: <span of `int`>,
|
||||
name: None,
|
||||
|
|
@ -127,7 +127,7 @@ Struct(~[FieldInfo {
|
|||
When generating the `expr` for a call with `self == C0(a)` and `other
|
||||
== C0(b)`, the SubstructureFields is
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
EnumMatching(0, <ast::Variant for C0>,
|
||||
~[FieldInfo {
|
||||
span: <span of int>
|
||||
|
|
@ -139,7 +139,7 @@ EnumMatching(0, <ast::Variant for C0>,
|
|||
|
||||
For `C1 {x}` and `C1 {x}`,
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
EnumMatching(1, <ast::Variant for C1>,
|
||||
~[FieldInfo {
|
||||
span: <span of x>
|
||||
|
|
@ -151,7 +151,7 @@ EnumMatching(1, <ast::Variant for C1>,
|
|||
|
||||
For `C0(a)` and `C1 {x}` ,
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
EnumNonMatching(~[(0, <ast::Variant for B0>,
|
||||
~[(<span of int>, None, <expr for &a>)]),
|
||||
(1, <ast::Variant for B1>,
|
||||
|
|
@ -165,7 +165,7 @@ EnumNonMatching(~[(0, <ast::Variant for B0>,
|
|||
|
||||
A static method on the above would result in,
|
||||
|
||||
~~~~notrust
|
||||
~~~text
|
||||
StaticStruct(<ast::StructDef of A>, Named(~[(<ident of x>, <span of x>)]))
|
||||
|
||||
StaticStruct(<ast::StructDef of B>, Unnamed(~[<span of x>]))
|
||||
|
|
@ -793,7 +793,7 @@ impl<'a> MethodDef<'a> {
|
|||
/**
|
||||
Creates the nested matches for an enum definition recursively, i.e.
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
match self {
|
||||
Variant1 => match other { Variant1 => matching, Variant2 => nonmatching, ... },
|
||||
Variant2 => match other { Variant1 => nonmatching, Variant2 => matching, ... },
|
||||
|
|
|
|||
Loading…
Reference in a new issue