Address language in review comments

This commit address the comments in this review: #672 (review)

except for any grammar changes.

Notes on where the edit differs (slightly) from the recommendation:

- The rule that a `using` statement can't declare an `out` variable applies to all forms. I added that in 13.14.1.
- I added a note that ref structs can't use the form of `await using`. It's a note because it follows from the normative restriction that `ref struct` types can't implement interfaces, but `await using` requires the resource type to implement `IAsyncDisposable`.
- The rules for `goto`, `break`, etc. are a note at the end of 13.14.1. They can be derived from the expanded forms of the `using` statement.
- The rule for a using declaration in a switch block remains. It's specific to a using declaration.

Author: BillWagner

standard/statements.md

@@ -351,71 +351,6 @@ It is an error to refer to a local variable by name in a textual position that p
 
 The ref-safe-context ([§9.7.2](variables.md#972-ref-safe-contexts)) of a ref local variable is the ref-safe-context of its initializing *variable_reference*. The ref-safe-context of non-ref local variables is *declaration-block*.
 
-When *local_variable_declaration* includes `using`, the semantics described above are modified, as follows.
-
-Each *local_variable_type* shall be `dynamic` or a resource type. If `await` is also present, the resource type shall not be a ref struct.
-
-Each *local_variable_declarator* shall have a *local_variable_initializer*.
-
-The variables declared are read-only. A compile-time error occurs if any subsequent statement attempts to modify these variables, take the address of them, or pass them as reference or output parameters.
-
-An occurrence of *local_variable_declaration* containing `using` has the same semantics as, and can be rewritten as, the corresponding resource-acquisition form of the using statement ([§13.14](statements.md#1314-the-using-statement)), as follows:
-
-```csharp
-using «local_variable_type» «local_variable_declarators»
-    // statements
-```
-
-is equivalent to
-
-```csharp
-using («local_variable_type» «local_variable_declarators»)
-{
-    // statements
-}
-```
-
-and
-
-```csharp
-await using «local_variable_type» «local_variable_declarators»
-    // statements
-```
-
-is equivalent to
-
-```csharp
-await using («local_variable_type» «local_variable_declarators»)
-{
-    // statements
-}
-```
-
-The lifetime of the variables declared in a *local_variable_declaration* extends to the end of the scope in which they are declared. Those variables are then disposed in the reverse order in which they are declared.
-
-<!-- Example: {template:"code-in-partial-class", name:"LocalVariableDecls6", additionalFiles:["SupportLocalVarDecl.cs"], replaceEllipsis:true, customEllipsisReplacements: ["\"File1.txt\", FileMode.Create", "\"File2.txt\", FileMode.Create", "\"File3.txt\", FileMode.Create"]} -->
-```csharp
-static void M()
-{
-    using FileStream f1 = new FileStream(...);
-    using FileStream f2 = new FileStream(...), f3 = new FileStream(...);
-    ...
-    // Dispose f3
-    // Dispose f2 
-    // Dispose f1
-}
-```
-
-When jumping to a label in a statement list which contains *local_variable_declaration*s involving `using`, there must not be any such declaration between the `goto` statement and the label.```
-
-Apart from wordsmithing this needs x-ref to goto, and goto probably needs this restriction listed in its description as well.
-
-Also surely this is an echo of a similar statement for `using (…) {…}`, so is it needed here at all given the equivalency defined above – this is just a shorthand.
-
-A *local_variable_declaration* with `using` shall not appear directly inside a `case` label, but, instead, may be within a block inside a `case` label.
-
-A *local_variable_declaration* with `using` shall not appear in an `out` variable declaration.
-
 #### 13.6.2.2 Implicitly typed local variable declarations
 
 ```ANTLR
@@ -1941,6 +1876,8 @@ While a mutual-exclusion lock is held, code executing in the same execution thre
 
 ## 13.14 The using statement
 
+### §using_general General
+
 The `using` statement obtains one or more resources, executes a statement, and then disposes of the resource.
 
 ```ANTLR
@@ -1956,7 +1893,9 @@ resource_acquisition
 
 A ***resource*** is either a class or non-ref struct that implements either or both of the `System.IDisposable` or `System.`IAsync`Disposable` interfaces, which includes a single parameterless method named `Dispose` and/or `DisposeAsync`; or a ref struct that includes a method named `Dispose` having the same signature as that declared by `System.IDisposable`. Code that is using a resource can call `Dispose` or `DisposeAsync` to indicate that the resource is no longer needed.
 
-If the form of *resource_acquisition* is *local_variable_declaration* then the type of the *local_variable_declaration* shall be either `dynamic` or a resource type. If the form of *resource_acquisition* is *expression* then this expression shall have a resource type. If `await` is present, the resource type shall implement `System.IAsyncDisposable`.
+If the form of *resource_acquisition* is *local_variable_declaration* then the type of the *local_variable_declaration* shall be either `dynamic` or a resource type. The *local_variable_declaration* cannot include the `out` modifier. If the form of *resource_acquisition* is *expression* then this expression shall have a resource type. If `await` is present, the resource type shall implement `System.IAsyncDisposable`.
+
+> *Note:* A `ref struct` type cannot be the resource type for a `using` statement with the `await` modifier because `ref struct` types cannot implement interfaces. *end note*
 
 Local variables declared in a *resource_acquisition* are read-only, and shall include an initializer. A compile-time error occurs if the embedded statement attempts to modify these local variables (via assignment or the `++` and `--` operators), take the address of them, or pass them as reference or output parameters.
 
@@ -2133,6 +2072,59 @@ corresponds to
 
 When `ResourceType` is a reference type that implements `IAsyncDisposable`. Other expansions for `await using` perform similar substitutions from the synchronous `Dispose` method to the asynchronous `DisposeAsync` method.
 
+> *Note*: Any jump statements (§13.10) in the *embedded_statement* must conform to expanded form of the `using` statement. *end note*
+
+### §using_declarations Using declarations
+
+A syntactic variant of the using statement is a *using declaration*.  A *using declaration* has the same semantics as, and can be rewritten as, the corresponding resource-acquisition form of the using statement (§using_general), as follows:
+
+```csharp
+using «local_variable_type» «local_variable_declarators»
+// statements
+```
+
+is equivalent to
+
+```csharp
+using («local_variable_type» «local_variable_declarators»)
+{
+    // statements
+}
+```
+
+and
+
+```csharp
+await using «local_variable_type» «local_variable_declarators»
+// statements
+```
+
+is equivalent to
+
+```csharp
+await using («local_variable_type» «local_variable_declarators»)
+{
+    // statements
+}
+```
+
+The lifetime of the variables declared in a *local_variable_declaration* extends to the end of the scope in which they are declared. Those variables are then disposed in the reverse order in which they are declared. It is a compile time error for a  `goto` statement (§13.10.4) 
+
+<!-- Example: {template:"code-in-partial-class", name:"LocalVariableDecls6", additionalFiles:["SupportLocalVarDecl.cs"], replaceEllipsis:true, customEllipsisReplacements: ["\"File1.txt\", FileMode.Create", "\"File2.txt\", FileMode.Create", "\"File3.txt\", FileMode.Create"]} -->
+```csharp
+static void M()
+{
+    using FileStream f1 = new FileStream(...);
+    using FileStream f2 = new FileStream(...), f3 = new FileStream(...);
+    ...
+    // Dispose f3
+    // Dispose f2 
+    // Dispose f1
+}
+```
+
+A using declaration shall not appear directly inside a `case` label, but, instead, may be within a block inside a `case` label.
+
 ## 13.15 The yield statement
 
 The `yield` statement is used in an iterator block ([§13.3](statements.md#133-blocks)) to yield a value to the enumerator object ([§15.15.5](classes.md#15155-enumerator-objects)) or enumerable object ([§15.15.6](classes.md#15156-enumerable-objects)) of an iterator or to signal the end of the iteration.