More editorial changes to expressions

* Go back to calling the syntactic elements "expressions", but name
  them operands afterwards.
* Use "called XYZ" to name something in syntax.
* Trade out a few uses of expressions using letters for operand names
  for the actual operand names.
* Pick arbitrary names for the operands. I don't like some of them, but
  they're not set in stone.
* Say they're not set in stone in the main expressions chapter.

Author: Havvy

src/expressions.md

@@ -55,6 +55,9 @@ In this way, the structure of expressions dictates the structure of execution.
 Blocks are just another kind of expression, so blocks, statements, expressions,
 and blocks again can recursively nest inside each other to an arbitrary depth.
 
+> **Note**: We give names to the operands of expressions so that we may discuss
+> them, but these names are not stable and may be changed.
+
 ## Expression precedence
 
 The precedence of Rust operators and expressions is ordered as follows, going

src/expressions/array-expr.md

@@ -14,21 +14,24 @@
 Array expressions come in two forms.
 
 The first form lists out every value in the array.
-The syntax for this form is a comma-separated list of operands of uniform type enclosed in square brackets.
+The syntax for this form is a comma-separated list of expressions of uniform type enclosed in square brackets.
 This produces an array containing each of these values in the order they are written.
 
-The syntax for the second form is two operands separated by a semicolon (`;`) enclosed in square brackets.
-The operand after the `;` must have type `usize` and be a [constant expression], such as a [literal] or a [constant item].
-`[a; b]` creates an array containing `b` copies of the value of `a`.
-If the operand after the semicolon has a value greater than 1 then this requires that the type of `a` is [`Copy`], or `a` must be a path to a constant item.
+The syntax for the second form is two expressions separated by a semicolon (`;`) enclosed in square brackets.
+The expression before the `;` is called the *repeat operand*.
+The expression after the `;` is called the *length operand*.
+It must have type `usize` and be a [constant expression], such as a [literal] or a [constant item].
+An array expression of this form creates an array with the length of the value of the legnth operand with each element a copy of the repeat operand.
+That is, `[a; b]` creates an array containing `b` copies of the value of `a`.
+If the length operand has a value greater than 1 then this requires that the type of the repeat operand is [`Copy`] or that it must be a [path] to a constant item.
 
-When the repeat expression, `a`, is a constant item, it is evaluated `b` times.
-If `b` is 0, the constant item is not evaluated at all.
-For expressions that are not a constant item, it is evaluated exactly once, and then the result is copied `b` times.
+When the repeat operand is a constant item, it is evaluated the length operand's value times.
+If that value is `0`, then the constant item is not evaluated at all.
+For expressions that are not a constant item, it is evaluated exactly once, and then the result is copied the length operand's value times.
 
 <div class="warning">
 
-Warning: In the case where `b` is 0, and `a` is a non-constant item, there is currently a bug in `rustc` where the value `a` is evaluated but not dropped, thus causing a leak.
+Warning: In the case where the length operand is 0, and the repeat operand is a non-constant item, there is currently a bug in `rustc` where the value `a` is evaluated but not dropped, thus causing a leak.
 See [issue #74836](https://github.com/rust-lang/rust/issues/74836).
 
 </div>
@@ -95,4 +98,5 @@ The array index expression can be implemented for types other than arrays and sl
 [constant item]: ../items/constant-items.md
 [literal]: ../tokens.md#literals
 [memory location]: ../expressions.md#place-expressions-and-value-expressions
+[path]: path-expr.md
 [slice]: ../types/slice.md

src/expressions/await-expr.md

@@ -5,12 +5,12 @@
 >    [_Expression_] `.` `await`
 
 *Await expressions* suspend the current computation until the given future is ready to produce a value.
-The syntax for an await expression is an operand with a type that implements the Future trait, `.`, and then the `await` keyword.
+The syntax for an await expression is an expression with a type that implements the Future trait, called the *future operand*, then the token `.`, and then the `await` keyword.
 Await expressions are legal only within an [async context], like an [`async fn`] or an [`async` block].
 
-More specifically, an `<expr>.await` expression has the following effect.
+More specifically, an await expression has the following effect.
 
-1. Evaluate `<expr>` to a [future] `tmp`;
+1. Evaluate the future operand to a [future] `tmp`;
 2. Pin `tmp` using [`Pin::new_unchecked`];
 3. This pinned future is then polled by calling the [`Future::poll`] method and passing it the current [task context](#task-context);
 3. If the call to `poll` returns [`Poll::Pending`], then the future returns `Poll::Pending`, suspending its state so that, when the surrounding async context is re-polled,execution returns to step 2;
@@ -25,11 +25,11 @@ Because `await` expressions are only legal in an async context, there must be so
 
 ## Approximate desugaring
 
-Effectively, an `<expr>.await` expression is roughly equivalent to the following non-normative desugaring:
+Effectively, an await expression is roughly equivalent to the following non-normative desugaring:
 
 <!-- ignore: example expansion -->
 ```rust,ignore
-match /* <expr> */ {
+match future_operand {
     mut pinned => loop {
         let mut pin = unsafe { Pin::new_unchecked(&mut pinned) };
         match Pin::future::poll(Pin::borrow(&mut pin), &mut current_context) {

src/expressions/block-expr.md

@@ -16,7 +16,7 @@ A *block expression*, or *block*, is a control flow expression and anonymous nam
 As a control flow expression, a block sequentially executes its component non-item declaration statements and then its final optional expression.
 As an anonymous namespace scope, item declarations are only in scope inside the block itself and variables declared by `let` statements are in scope from the next statement until the end of the block.
 
-The syntax for a block is `{`, then any [inner attributes], then [statements], then an optional operand, and finally a `}`.
+The syntax for a block is `{`, then any [inner attributes], then any number of [statements], then an optional expression, called the final operand, and finally a `}`.
 
 Statements are usually required to be followed by a semicolon, with two exceptions:
 
@@ -25,9 +25,9 @@ Statements are usually required to be followed by a semicolon, with two exceptio
 Furthermore, extra semicolons between statements are allowed, but these semicolons do not affect semantics.
 
 When evaluating a block expression, each statement, except for item declaration statements, is executed sequentially.
-Then the final expression is executed, if given.
+Then the final operand is executed, if given.
 
-The type of a block is the type of the final expression, or `()` if the final expression is omitted.
+The type of a block is the type of the final operand, or `()` if the final operand is omitted.
 
 ```rust
 # fn fn_call() {}
@@ -47,7 +47,6 @@ assert_eq!(5, five);
 
 Blocks are always [value expressions] and evaluate the last operand in value expression context.
 
-
 > **Note**: This can be used to force moving a value if really needed.
 > For example, the following example fails on the call to `consume_self` because the struct was moved out of `s` in the block expression.
 >

src/expressions/call-expr.md

@@ -8,11 +8,11 @@
 > &nbsp;&nbsp; [_Expression_]&nbsp;( `,` [_Expression_] )<sup>\*</sup> `,`<sup>?</sup>
 
 A *call expression* calls a function.
-The syntax of a call expression is an operand, the *function operand*, followed by a parenthesized comma-separated list of operands, the *argument operands*.
+The syntax of a call expression is an expression, called the *function operand*, followed by a parenthesized comma-separated list of expression, called the *argument operands*.
 If the function eventually returns, then the expression completes.
-For [non-function types](../types/function-item.md), the expression f(...) uses the method on one of the [`std::ops::Fn`], [`std::ops::FnMut`] or [`std::ops::FnOnce`] traits, which differ in whether they take the type by reference, mutable reference, or take ownership respectively.
+For [non-function types], the expression `f(...)` uses the method on one of the [`std::ops::Fn`], [`std::ops::FnMut`] or [`std::ops::FnOnce`] traits, which differ in whether they take the type by reference, mutable reference, or take ownership respectively.
 An automatic borrow will be taken if needed.
-`f` will also be automatically dereferences as required.
+The function operand will also be [automatically dereferenced] as required.
 
 Some examples of call expressions:
 
@@ -92,4 +92,6 @@ Refer to [RFC 132] for further details and motivations.
 [`std::ops::FnMut`]: ../../std/ops/trait.FnMut.html
 [`std::ops::FnOnce`]: ../../std/ops/trait.FnOnce.html
 [`std::ops::Fn`]: ../../std/ops/trait.Fn.html
+[automatically dereferenced]: field-expr.md#automatic-dereferencing
 [fully-qualified syntax]: ../paths.md#qualified-paths
+[non-function types]: ../types/function-item.md

src/expressions/closure-expr.md

@@ -13,7 +13,7 @@
 > &nbsp;&nbsp; [_OuterAttribute_]<sup>\*</sup> [_Pattern_]&nbsp;( `:` [_Type_] )<sup>?</sup>
 
 A *closure expression*, also know as a lambda expression or a lambda, defines a [closure type] and evaluates to a value of that type.
-The syntax for a closure expression is an optional `move` keyword, then a pipe-symbol-delimited (`|`) comma-separated list of [patterns], the *closure parameters* each optionally followed by a `:` and a type, then an optional `->` and type, the *return type*, and then an operand, the *closure body*.
+The syntax for a closure expression is an optional `move` keyword, then a pipe-symbol-delimited (`|`) comma-separated list of [patterns], called the *closure parameters* each optionally followed by a `:` and a type, then an optional `->` and type, called the *return type*, and then an expression, called the *closure body operand*.
 The optional type after each pattern is a type annotation for the pattern.
 If there is a return type, the closure body must be a [block].
 

src/expressions/field-expr.md

@@ -7,8 +7,8 @@
 A *field expression* is a [place expression] that evaluates to the location of a field of a [struct] or [union].
 When the operand is [mutable], the field expression is also mutable.
 
-The syntax for a field expression is an operand, then a `.`, and finally an [identifier].
-Field expressions cannot be followed by a parenthetical comma-separated list of expressions, as that is parsed as a [method call expression].
+The syntax for a field expression is an expression, called the container operand*, then a `.`, and finally an [identifier].
+Field expressions cannot be followed by a parenthetical comma-separated list of expressions, as that is instead parsed as a [method call expression].
 That is, they cannot be the function operand of a [call expression].
 
 > **Note**: Wrap the field expression in a [parenthesized expression] to use it in a call expression.
@@ -24,9 +24,7 @@ That is, they cannot be the function operand of a [call expression].
 > (holds_callable.callable)();
 > ```
 
-A field expression denotes a field of a [struct] or [union].
-
-To call a function stored in a struct, parentheses are needed around the field expression.
+Examples:
 
 <!-- ignore: needs lots of support code -->
 ```rust,ignore
@@ -38,7 +36,7 @@ foo().x;
 
 ## Automatic dereferencing
 
-If the type of the operand implements [`Deref`] or [`DerefMut`][`Deref`] depending on whether the operand is [mutable], it is *automatically dereferenced* as many times as necessary to make the field access possible.
+If the type of the container operand implements [`Deref`] or [`DerefMut`][`Deref`] depending on whether the operand is [mutable], it is *automatically dereferenced* as many times as necessary to make the field access possible.
 This processes is also called *autoderef* for short.
 
 ## Borrowing

src/expressions/grouped-expr.md

@@ -5,9 +5,11 @@
 > &nbsp;&nbsp; `(` [_InnerAttribute_]<sup>\*</sup> [_Expression_] `)`
 
 A *parenthesized expression* wraps a single expression, evaluating to that expression.
-The syntax for a parenthesized expression is a `(`, then an operand, the *enclosed operand*, and then a `)`.
+The syntax for a parenthesized expression is a `(`, then an expression, called the *enclosed operand*, and then a `)`.
 
-An expression enclosed in parentheses evaluates to the value of the enclosed operand.
+Parenthesized expressions evaluate to the value of the enclosed operand.
+Unlike other expressions, parenthesized expressions are both [place expressions and value expressions][place].
+When the enclosed operand is a place expression, it is a place expression and when the enclosed operand is a value expression, it is a value expression.
 
 Parentheses can be used to explicitly modify the precedence order of subexpressions within an expression.
 
@@ -45,3 +47,4 @@ assert_eq!((a.f)(), "The field f");
 [_Expression_]: ../expressions.md
 [_InnerAttribute_]: ../attributes.md
 [attributes on block expressions]: block-expr.md#attributes-on-block-expressions
+[place]: ../expressions.md#place-expressions-and-value-expressions