Merge pull request #886 from ehuss/style-check

Add style checks.

Author: Havvy

.github/workflows/main.yml

@@ -26,8 +26,8 @@ jobs:
         mdbook --version
     - name: Run tests
       run: mdbook test
-    - name: Check for unstable features
-      run: (cd stable-check && cargo run -- ../src)
+    - name: Style checks
+      run: (cd style-check && cargo run -- ../src)
     - name: Check for broken links
       run: |
         curl -sSLo linkcheck.sh \

STYLE.md

@@ -3,6 +3,10 @@
 Some conventions and content guidelines are specified in the [introduction].
 This document serves as a guide for editors and reviewers.
 
+There is a [`style-check`](style-check/) tool which is run in CI to check some
+of these. To use it locally, run
+`cargo run --manifest-path=style-check/Cargo.toml src`.
+
 ## Markdown formatting
 
 * Use ATX-style heading with sentence case.

src/attributes/codegen.md

@@ -157,9 +157,9 @@ otherwise undefined behavior results.
 
 ### Behavior
 
-Applying the attribute to a function `f` allows code within `f` to get a hint of the [`Location`] of 
-the "topmost" tracked call that led to `f`'s invocation. At the point of observation, an 
-implementation behaves as if it walks up the stack from `f`'s frame to find the nearest frame of an 
+Applying the attribute to a function `f` allows code within `f` to get a hint of the [`Location`] of
+the "topmost" tracked call that led to `f`'s invocation. At the point of observation, an
+implementation behaves as if it walks up the stack from `f`'s frame to find the nearest frame of an
 *unattributed* function `outer`, and it returns the [`Location`] of the tracked call in `outer`.
 
 ```rust
@@ -190,7 +190,7 @@ fn calls_f() {
 ```
 
 When `f` is called by another attributed function `g` which is in turn called by `calls_g`, code in
-both `f` and `g` observes `g`'s callsite within `calls_g`: 
+both `f` and `g` observes `g`'s callsite within `calls_g`:
 
 ```rust
 # #[track_caller]

src/comments.md

@@ -2,27 +2,27 @@
 
 > **<sup>Lexer</sup>**\
 > LINE_COMMENT :\
-> &nbsp;&nbsp; &nbsp;&nbsp; `//` (~[`/` `!`] | `//`) ~`\n`<sup>\*</sup>\
+> &nbsp;&nbsp; &nbsp;&nbsp; `//` (~\[`/` `!`] | `//`) ~`\n`<sup>\*</sup>\
 > &nbsp;&nbsp; | `//`
 >
 > BLOCK_COMMENT :\
-> &nbsp;&nbsp; &nbsp;&nbsp; `/*` (~[`*` `!`] | `**` | _BlockCommentOrDoc_)
+> &nbsp;&nbsp; &nbsp;&nbsp; `/*` (~\[`*` `!`] | `**` | _BlockCommentOrDoc_)
 >      (_BlockCommentOrDoc_ | ~`*/`)<sup>\*</sup> `*/`\
 > &nbsp;&nbsp; | `/**/`\
 > &nbsp;&nbsp; | `/***/`
 >
 > INNER_LINE_DOC :\
-> &nbsp;&nbsp; `//!` ~[`\n` _IsolatedCR_]<sup>\*</sup>
+> &nbsp;&nbsp; `//!` ~\[`\n` _IsolatedCR_]<sup>\*</sup>
 >
 > INNER_BLOCK_DOC :\
-> &nbsp;&nbsp; `/*!` ( _BlockCommentOrDoc_ | ~[`*/` _IsolatedCR_] )<sup>\*</sup> `*/`
+> &nbsp;&nbsp; `/*!` ( _BlockCommentOrDoc_ | ~\[`*/` _IsolatedCR_] )<sup>\*</sup> `*/`
 >
 > OUTER_LINE_DOC :\
-> &nbsp;&nbsp; `///` (~`/` ~[`\n` _IsolatedCR_]<sup>\*</sup>)<sup>?</sup>
+> &nbsp;&nbsp; `///` (~`/` ~\[`\n` _IsolatedCR_]<sup>\*</sup>)<sup>?</sup>
 >
 > OUTER_BLOCK_DOC :\
 > &nbsp;&nbsp; `/**` (~`*` | _BlockCommentOrDoc_ )
->              (_BlockCommentOrDoc_ | ~[`*/` _IsolatedCR_])<sup>\*</sup> `*/`
+>              (_BlockCommentOrDoc_ | ~\[`*/` _IsolatedCR_])<sup>\*</sup> `*/`
 >
 > _BlockCommentOrDoc_ :\
 > &nbsp;&nbsp; &nbsp;&nbsp; BLOCK_COMMENT\

src/destructors.md

@@ -166,7 +166,7 @@ smallest scope that contains the expression and is for one of the following:
 * The second operand of a [lazy boolean expression].
 
 > **Notes**:
-> 
+>
 > Temporaries that are created in the final expression of a function
 > body are dropped *after* any named variables bound in the function body, as
 > there is no smaller enclosing temporary scope.

src/expressions/closure-expr.md

@@ -12,10 +12,10 @@
 > _ClosureParam_ :\
 > &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 and denotes it as a value, in a single expression. A closure expression 
-is a pipe-symbol-delimited (`|`) list of irrefutable [patterns] followed by an 
-expression. Type annotations may optionally be added for the type of the 
+A _closure expression_, also know as a lambda expression or a lambda, defines a
+closure and denotes it as a value, in a single expression. A closure expression
+is a pipe-symbol-delimited (`|`) list of irrefutable [patterns] followed by an
+expression. Type annotations may optionally be added for the type of the
 parameters or for the return type. If there is a return type, the expression
 used for the body of the closure must be a normal [block]. A closure expression
 also may begin with the `move` keyword before the initial `|`.

src/glossary.md

@@ -75,17 +75,17 @@ function* or a *free const*. Contrast to an [associated item].
 
 ### Fundamental traits
 
-A fundamental trait is one where adding an impl of it for an existing type is a breaking change. 
+A fundamental trait is one where adding an impl of it for an existing type is a breaking change.
 The `Fn` traits and `Sized` are fundamental.
 
 ### Fundamental type constructors
 
-A fundamental type constructor is a type where implementing a [blanket implementation](#blanket-implementation) over it 
-is a breaking change. `&`, `&mut`, `Box`, and `Pin`  are fundamental. 
+A fundamental type constructor is a type where implementing a [blanket implementation](#blanket-implementation) over it
+is a breaking change. `&`, `&mut`, `Box`, and `Pin`  are fundamental.
 
-Any time a type `T` is considered [local](#local-type), `&T`, `&mut T`, `Box<T>`, and `Pin<T>` 
-are also considered local. Fundamental type constructors cannot [cover](#uncovered-type) other types. 
-Any time the term "covered type" is used, 
+Any time a type `T` is considered [local](#local-type), `&T`, `&mut T`, `Box<T>`, and `Pin<T>`
+are also considered local. Fundamental type constructors cannot [cover](#uncovered-type) other types.
+Any time the term "covered type" is used,
 the `T` in `&T`, `&mut T`, `Box<T>`, and `Pin<T>` is not considered covered.
 
 ### Inhabited
@@ -120,7 +120,7 @@ or not independent of applied type arguments. Given `trait Foo<T, U>`,
 
 A `struct`, `enum`, or `union` which was defined in the current crate.
 This is not affected by applied type arguments. `struct Foo` is considered local, but
-`Vec<Foo>` is not. `LocalType<ForeignType>` is local. Type aliases do not 
+`Vec<Foo>` is not. `LocalType<ForeignType>` is local. Type aliases do not
 affect locality.
 
 ### Nominal types

src/identifiers.md

@@ -2,8 +2,8 @@
 
 > **<sup>Lexer:<sup>**\
 > IDENTIFIER_OR_KEYWORD :\
-> &nbsp;&nbsp; &nbsp;&nbsp; [`a`-`z` `A`-`Z`]&nbsp;[`a`-`z` `A`-`Z` `0`-`9` `_`]<sup>\*</sup>\
-> &nbsp;&nbsp; | `_` [`a`-`z` `A`-`Z` `0`-`9` `_`]<sup>+</sup>
+> &nbsp;&nbsp; &nbsp;&nbsp; \[`a`-`z` `A`-`Z`]&nbsp;\[`a`-`z` `A`-`Z` `0`-`9` `_`]<sup>\*</sup>\
+> &nbsp;&nbsp; | `_` \[`a`-`z` `A`-`Z` `0`-`9` `_`]<sup>+</sup>
 >
 > RAW_IDENTIFIER : `r#` IDENTIFIER_OR_KEYWORD <sub>*Except `crate`, `self`, `super`, `Self`*</sub>
 >

src/items/functions.md

@@ -293,7 +293,7 @@ attributes][attributes] are allowed directly after the `{` inside its [block].
 This example shows an inner attribute on a function. The function will only be
 available while running tests.
 
-```
+```rust
 fn test_only() {
     #![test]
 }

src/items/implementations.md

@@ -174,7 +174,7 @@ least one of the following is true:
 
 Only the appearance of *uncovered* type parameters is restricted.
 Note that for the purposes of coherence, [fundamental types] are
-special. The `T` in `Box<T>` is not considered covered, and `Box<LocalType>` 
+special. The `T` in `Box<T>` is not considered covered, and `Box<LocalType>`
 is considered local.