Notes about negated literals

Author: mattheww

src/expressions/literal-expr.md

@@ -77,6 +77,8 @@ If the value does not fit in `u128`, the expression is rejected by the parser.
 > **Note**: The final cast will truncate the value of the literal if it does not fit in the expression's type.
 > There is a [lint check] named `overflowing_literals`, defaulting to `deny`, which rejects expressions where this occurs.
 
+> **Note**: `-1i8`, for example, is an application of the [negation operator] to the literal expression `1i8`, not a single integer literal expression.
+
 ## Floating-point literal expressions
 
 A floating-point literal expression consists of a single [FLOAT_LITERAL] token.
@@ -108,6 +110,8 @@ The value of the expression is determined from the string representation of the
 
 * The string is converted to the expression's type as if by [`f32::from_str`] or [`f64::from_str`].
 
+> **Note**: `-1.0`, for example, is an application of the [negation operator] to the literal expression `1.0`, not a single floating-point literal expression.
+
 > **Note**: `inf` and `NaN` are not literal tokens.
 > The [`f32::INFINITY`], [`f64::INFINITY`], [`f32::NAN`], and [`f64::NAN`] constants can be used instead of literal expressions.
 > A literal large enough to be evaluated as infinite will trigger the `overflowing_literals` lint check.
@@ -119,6 +123,7 @@ The value of the expression is determined from the string representation of the
 [numeric cast]: operator-expr.md#numeric-cast
 [numeric types]: ../types/numeric.md
 [suffix]: ../tokens.md#suffixes
+[negation operator]: operator-expr.md#negation-operators
 [`f32::from_str`]: ../../core/primitive.f32.md#method.from_str
 [`f32::INFINITY`]: ../../core/primitive.f32.md#associatedconstant.INFINITY
 [`f32::NAN`]: ../../core/primitive.f32.md#associatedconstant.NAN

src/tokens.md

@@ -384,6 +384,8 @@ Examples of integer literals of various forms:
 0usize;
 ```
 
+Note that `-1i8`, for example, is analyzed as two tokens: `-` followed by `1i8`.
+
 Examples of invalid integer literals:
 
 ```rust,compile_fail
@@ -408,10 +410,6 @@ Examples of invalid integer literals:
 0b____;
 ```
 
-Note that the Rust syntax considers `-1i8` as an application of the [unary minus
-operator] to an integer literal `1i8`, rather than
-a single integer literal.
-
 #### Tuple index
 
 > **<sup>Lexer</sup>**\
@@ -483,6 +481,8 @@ This last example is different because it is not possible to use the suffix
 syntax with a floating point literal ending in a period. `2.f64` would attempt
 to call a method named `f64` on `2`.
 
+Note that `-1.0`, for example, is analyzed as two tokens: `-` followed by `1.0`.
+
 ### Boolean literals
 
 > **<sup>Lexer</sup>**\