Remove enum variant expression page

It is quite redundant with the (IMO badly named) struct expression.
Perhaps we should rename it to something else? "Named value expression"?

Author: Havvy

src/SUMMARY.md

@@ -56,7 +56,6 @@
         - [Array and index expressions](expressions/array-expr.md)
         - [Tuple and index expressions](expressions/tuple-expr.md)
         - [Struct expressions](expressions/struct-expr.md)
-        - [Enum variant expressions](expressions/enum-variant-expr.md)
         - [Call expressions](expressions/call-expr.md)
         - [Method call expressions](expressions/method-call-expr.md)
         - [Field access expressions](expressions/field-expr.md)

src/attributes/type_system.md

@@ -64,7 +64,7 @@ Non-exhaustive types cannot be constructed outside of the defining crate:
 
 - Non-exhaustive variants ([`struct`][struct] or [`enum` variant][enum]) cannot be constructed
   with a [_StructExpression_] \(including with [functional update syntax]).
-- [`enum`][enum] instances can be constructed in an [_EnumerationVariantExpression_].
+- [`enum`][enum] instances can be constructed.
 
 <!-- ignore: requires external crates -->
 ```rust,ignore
@@ -129,7 +129,6 @@ match message {
 
 Non-exhaustive types are always considered inhabited in downstream crates.
 
-[_EnumerationVariantExpression_]: ../expressions/enum-variant-expr.md
 [_MetaWord_]: ../attributes.md#meta-item-attribute-syntax
 [_StructExpression_]: ../expressions/struct-expr.md
 [_StructPattern_]: ../patterns.md#struct-patterns

src/const_eval.md

@@ -27,7 +27,6 @@ to be run.
 * [Tuple expressions].
 * [Array expressions].
 * [Struct] expressions.
-* [Enum variant] expressions.
 * [Block expressions], including `unsafe` blocks.
     * [let statements] and thus irrefutable [patterns], including mutable bindings
     * [assignment expressions]
@@ -117,7 +116,6 @@ Conversely, the following are possible in a const function, but not in a const c
 [dereference operator]: expressions/operator-expr.md#the-dereference-operator
 [destructors]:          destructors.md
 [enum discriminants]:   items/enumerations.md#custom-discriminant-values-for-fieldless-enumerations
-[enum variant]:         expressions/enum-variant-expr.md
 [expression statements]: statements.md#expression-statements
 [expressions]:          expressions.md
 [field]:                expressions/field-expr.md

src/expressions.md

@@ -18,7 +18,6 @@
 >       | [_TupleExpression_]\
 >       | [_TupleIndexingExpression_]\
 >       | [_StructExpression_]\
->       | [_EnumerationVariantExpression_]\
 >       | [_CallExpression_]\
 >       | [_MethodCallExpression_]\
 >       | [_FieldExpression_]\
@@ -103,7 +102,6 @@ evaluate them conditionally as described on their respective pages.
 * Tuple expression
 * Tuple index expression
 * Struct expression
-* Enumeration variant expression
 * Call expression
 * Method call expression
 * Field expression
@@ -259,7 +257,7 @@ a few specific cases:
 
 * Before an expression used as a [statement].
 * Elements of [array expressions], [tuple expressions], [call expressions],
-  and tuple-style [struct] and [enum variant] expressions.
+  and tuple-style [struct] expressions.
   <!--
     These were likely stabilized inadvertently.
     See https://github.com/rust-lang/rust/issues/32796 and
@@ -277,7 +275,6 @@ They are never allowed before:
 
 [block expressions]:    expressions/block-expr.md
 [call expressions]:     expressions/call-expr.md
-[enum variant]:         expressions/enum-variant-expr.md
 [field]:                expressions/field-expr.md
 [functional update]:    expressions/struct-expr.md#functional-update-syntax
 [`if let`]:             expressions/if-expr.md#if-let-expressions
@@ -329,7 +326,6 @@ They are never allowed before:
 [_ComparisonExpression_]:         expressions/operator-expr.md#comparison-operators
 [_CompoundAssignmentExpression_]: expressions/operator-expr.md#compound-assignment-expressions
 [_ContinueExpression_]:           expressions/loop-expr.md#continue-expressions
-[_EnumerationVariantExpression_]: expressions/enum-variant-expr.md
 [_FieldExpression_]:              expressions/field-expr.md
 [_GroupedExpression_]:            expressions/grouped-expr.md
 [_IfExpression_]:                 expressions/if-expr.md#if-expressions

src/expressions/block-expr.md

@@ -153,7 +153,7 @@ let a = unsafe { an_unsafe_fn() };
 * Loop bodies ([`loop`], [`while`], [`while let`], and [`for`]).
 * Block expressions used as a [statement].
 * Block expressions as elements of [array expressions], [tuple expressions],
-  [call expressions], and tuple-style [struct] and [enum variant] expressions.
+  [call expressions], and tuple-style [struct] expressions.
 * A block expression as the tail expression of another block expression.
 <!-- Keep list in sync with expressions.md -->
 
@@ -178,7 +178,6 @@ fn is_unix_platform() -> bool {
 [`while`]: loop-expr.md#predicate-loops
 [array expressions]: array-expr.md
 [call expressions]: call-expr.md
-[enum variant]: enum-variant-expr.md
 [function]: ../items/functions.md
 [inner attributes]: ../attributes.md
 [method]: ../items/associated-items.md#methods

src/expressions/enum-variant-expr.md

@@ -27,8 +27,8 @@
 >
 > _StructExprUnit_ : [_PathInExpression_]
 
-A _struct expression_ creates a struct or union value.
-It consists of a path to a [struct] or [union] item followed by the values for the fields of the item.
+A *struct expression* creates a struct, enum, or union value.
+It consists of a path to a [struct], [enum], or [union] item followed by the values for the fields of the item.
 There are three forms of struct expressions: struct, tuple, and unit.
 
 The following are examples of struct expressions:
@@ -52,7 +52,7 @@ some_fn::<Cookie>(Cookie);
 A struct expression with fields enclosed in curly braces allows you to specify the value for each individual field in any order.
 The field name is separated from its value with a colon.
 
-A value of a [union] type can also be created using this syntax, except that it must specify exactly one field.
+A value of a [union] type can only be created using this syntax, and it must specify exactly one field.
 
 ## Functional update syntax
 
@@ -101,7 +101,8 @@ Point3d { x, y: y_value, z };
 ## Tuple struct expression
 
 A struct expression with fields enclosed in parentheses constructs a tuple struct.
-Though it is listed here as a specific expression for completeness, it is equivalent to a [call expression] to the tuple struct's constructor. For example:
+Though it is listed here as a specific expression for completeness, it is equivalent to a [call expression] to the tuple struct's constructor. For example: <!--
+This is false. Example: Position(0, ..other_position) -->
 
 ```rust
 struct Position(i32, i32, i32);
@@ -134,6 +135,7 @@ let b = Gamma{};  // Exact same value as `a`.
 [_PathInExpression_]: ../paths.md#paths-in-expressions
 [attributes on block expressions]: block-expr.md#attributes-on-block-expressions
 [call expression]: call-expr.md
+[enum]: ../items/enumerations.md
 [if let]: if-expr.md#if-let-expressions
 [if]: if-expr.md#if-expressions
 [loop]: loop-expr.md

src/expressions/struct-expr.md

@@ -25,7 +25,7 @@
 > _EnumItemDiscriminant_ :\
 >    `=` [_Expression_]
 
-An *enumeration*, also referred to as *enum* is a simultaneous definition of a
+An *enumeration*, also referred to as an *enum*, is a simultaneous definition of a
 nominal [enumerated type] as well as a set of *constructors*, that can be used
 to create or pattern-match values of the corresponding enumerated type.
 

src/items/enumerations.md

@@ -7,8 +7,7 @@ An [`enum` item] declares both the type and a number of *variants*, each of
 which is independently named and has the syntax of a struct, tuple struct or
 unit-like struct.
 
-New instances of an `enum` can be constructed in an [enumeration variant
-expression].
+New instances of an `enum` can be constructed with a [struct expression].
 
 Any `enum` value consumes as much memory as the largest variant for its
 corresponding `enum` type, as well as the size needed to store a discriminant.
@@ -20,4 +19,4 @@ named reference to an [`enum` item].
              ML, or a *pick ADT* in Limbo.
 
 [`enum` item]: ../items/enumerations.md
-[enumeration variant expression]: ../expressions/enum-variant-expr.md
+[struct expression]: ../expressions/struct-expr.md