Apply suggestions from code review

Co-Authored-By: vweijsters <vweijsters@users.noreply.github.com>

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers/Settings/ObjectModel/NamingSettings.cs

@@ -22,8 +22,8 @@ protected internal NamingSettings()
             this.AllowCommonHungarianPrefixes = true;
             this.allowedHungarianPrefixes = ImmutableArray.CreateBuilder<string>();
 
-            this.IncludeInferredTupleFieldNames = false;
-            this.TupleFieldNameCasing = TupleFieldNameCase.CamelCase;
+            this.IncludeInferredTupleElementNames = false;
+            this.TupleElementNameCasing = TupleElementNameCase.CamelCase;
         }
 
         /// <summary>
@@ -57,12 +57,12 @@ protected internal NamingSettings(JsonObject namingSettingsObject)
 
                     break;
 
-                case "includeInferredTupleFieldNames":
-                    this.IncludeInferredTupleFieldNames = kvp.ToBooleanValue();
+                case "includeInferredTupleElementNames":
+                    this.IncludeInferredTupleElementNames = kvp.ToBooleanValue();
                     break;
 
-                case "tupleFieldNameCasing":
-                    this.TupleFieldNameCasing = kvp.ToEnumValue<TupleFieldNameCase>();
+                case "tupleElementNameCasing":
+                    this.TupleElementNameCasing = kvp.ToEnumValue<TupleElementNameCase>();
                     break;
 
                 default:

StyleCop.Analyzers/StyleCop.Analyzers/Settings/ObjectModel/TupleFieldNameCase.cs

@@ -3,15 +3,15 @@
 
 namespace StyleCop.Analyzers.Settings.ObjectModel
 {
-    internal enum TupleFieldNameCase
+    internal enum TupleElementNameCase
     {
         /// <summary>
-        /// Tuple field names must use camel case.
+        /// Tuple element names must use camelCase.
         /// </summary>
         CamelCase = 0,
 
         /// <summary>
-        /// Tuple field names must use pascal case.
+        /// Tuple element names must use PascalCase.
         /// </summary>
         PascalCase,
     }

StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json

@@ -128,17 +128,17 @@
                 "uniqueItems": true
               }
             },
-            "includeInferredTupleFieldNames": {
+            "includeInferredTupleElementNames": {
               "type": "boolean",
-              "description": "Specifies whether inferred tuple field names will be analyzed as well.",
+              "description": "Specifies whether inferred tuple element names will be analyzed as well.",
               "default": false
             },
-            "tupleFieldNameCasing": {
+            "tupleElementNameCasing": {
               "type": "string",
-              "description": "Specifies the casing convention used for tuple field names.",
+              "description": "Specifies the casing convention used for tuple element names.",
               "enum": [
                 "camelCase",
-                "pascalCase"
+                "PascalCase"
               ],
               "default": "camelCase"
             }

documentation/Configuration.md

@@ -314,39 +314,39 @@ The following example shows a settings file which allows the common prefixes as
 }
 ```
 
-### Tuple field names
+### Tuple element names
 
-The following properties are used to configure the behavior of the tuple field name analyzers.
+The following properties are used to configure the behavior of the tuple element name analyzers.
 
 | Property | Default Value | Minimum Version | Summary |
 | --- | --- | --- | --- |
-| `includeInferredTupleFieldNames` | false | 1.2.0 | Specifies whether inferred tuple field names will be analyzed as well. |
-| `tupleFieldNameCasing` | "camelCase" | 1.2.0 | Specifies the casing convention used for tuple field names. |
+| `includeInferredTupleElementNames` | false | 1.2.0 | Specifies whether inferred tuple element names will be analyzed as well. |
+| `tupleElementNameCasing` | "camelCase" | 1.2.0 | Specifies the casing convention used for tuple element names. |
 
-The following example shows a settings file which requires tuple field names to use pascalCase for all tuple field names (including implicitly named tuple fields).
+The following example shows a settings file which requires tuple element names to use PascalCase for all tuple elements (including inferred element names).
 
 ```json
 {
   "settings": {
     "namingRules": {
-      "includeInferredTupleFieldNames": true,
-      "tupleFieldNameCasing" : "pascalCase"
+      "includeInferredTupleElementNames": true,
+      "tupleElementNameCasing" : "PascalCase"
     }
   }
 }
 ```
 
 
-#### Tuple Field Name Casing
-The `tupleFieldNameCasing` property affects the behavior of the [SA1316 Tuple field names must use correct casing](SA1316.md) analyzer.
+#### Tuple Element Name Casing
+The `tupleElementNameCasing` property affects the behavior of the [SA1316 Tuple element names should use correct casing](SA1316.md) analyzer.
 
 This property has two allowed values, which are described as follows.
 
 ##### `"camelCase"`
-In this mode, tuple field names must start with a lowercase letter.
+In this mode, tuple element names must start with a lowercase letter.
 
-##### `"pascalCase"`
-In this mode, tuple field names must start with an uppercase letter.
+##### `"PascalCase"`
+In this mode, tuple element names must start with an uppercase letter.
 
 
 ## Maintainability Rules

documentation/NamingRules.md

@@ -18,4 +18,4 @@ Identifier | Name | Description
 [SA1312](SA1312.md) | VariableNamesMustBeginWithLowerCaseLetter | The name of a variable in C# does not begin with a lower-case letter. 
 [SA1313](SA1313.md) | ParameterNamesMustBeginWithLowerCaseLetter | The name of a parameter in C# does not begin with a lower-case letter. 
 [SA1314](SA1314.md) | TypeParameterNamesMustBeginWithT | The name of a C# type parameter does not begin with the capital letter T.
-[SA1316](SA1316.md) | TupleFieldNamesMustUseCorrectCasing | Field names within a tuple declaration should have the correct casing.
+[SA1316](SA1316.md) | TupleElementNamesShouldUseCorrectCasing | Element names within a tuple type should have the correct casing.

documentation/ReadabilityRules.md

@@ -42,4 +42,4 @@ Identifier | Name | Description
 [SA1137](SA1137.md) | ElementsShouldHaveTheSameIndentation | Two sibling elements which each start on their own line have different levels of indentation.
 [SA1139](SA1139.md) | UseLiteralsSuffixNotationInsteadOfCasting | Use literal suffix notation instead of casting. 
 [SA1141](SA1141.md) | UseTupleSyntax | Use tuple syntax instead of the underlying ValueTuple implementation type.
-[SA1142](SA1142.md) | ReferToTupleFieldsByName | A field of a tuple was referenced by its metadata name when a field name is available.
+[SA1142](SA1142.md) | ReferToTupleElementsByName | An element of a tuple was referenced by its metadata name when an element name is available.

documentation/SA1141.md

@@ -29,7 +29,7 @@ A ValueTuple type declaration was used instead of the preferred tuple language c
 For example, the following code would produce a violation of this rule:
 
 ```csharp
-ValueTuple<int, int> x;
+ValueTuple<int, int> x; // SA1141
 ```
 
 The following code would not produce any violations:

documentation/SA1142.md

@@ -3,7 +3,7 @@
 <table>
 <tr>
   <td>TypeName</td>
-  <td>SA1142ReferToTupleFieldsByName</td>
+  <td>SA1142ReferToTupleElementsByName</td>
 </tr>
 <tr>
   <td>CheckId</td>
@@ -20,18 +20,18 @@
 
 ## Cause
 
-A field of a tuple was referenced by its metadata name when a field name is available.
+An element of a tuple was referenced by its metadata name when an element name is available.
 
 ## Rule description
 
-A field of a tuple was referenced by its metadata name when a field name is available.  See the documentation on [tuple types](https://docs.microsoft.com/en-us/dotnet/csharp/tuples) for information on how to work with tuples in C# 7.
+An element of a tuple was referenced by its metadata name when an element name is available.  See the documentation on [tuple types](https://docs.microsoft.com/en-us/dotnet/csharp/tuples) for information on how to work with tuples in C# 7.
 
 For example, the following code would produce a violation of this rule:
 
 ```csharp
 (int valueA, int valueB) x;
 
-var y = x.Item1;
+var y = x.Item1; // SA1142
 ```
 
 The following code would not produce any violations:
@@ -44,15 +44,15 @@ var y = x.valueA;
 
 ## How to fix violations
 
-To fix a violation of this rule, use the appropriate tuple field name in code instead of the metadata name.
+To fix a violation of this rule, use the appropriate tuple element name in code instead of the metadata name.
 
 ## How to suppress violations
 
 ```csharp
-[SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1142:ReferToTupleFieldsByName", Justification = "Reviewed.")]
+[SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1142:ReferToTupleElementsByName", Justification = "Reviewed.")]
 ```
 
 ```csharp
-#pragma warning disable SA1142 // Refer to tuple fields by name
-#pragma warning restore SA1142 // Refer to tuple fields by name
+#pragma warning disable SA1142 // Refer to tuple elements by name
+#pragma warning restore SA1142 // Refer to tuple elements by name
 ```

documentation/SA1316.md

@@ -3,7 +3,7 @@
 <table>
 <tr>
   <td>TypeName</td>
-  <td>SA1316TupleFieldNamesMustUseCorrectCasing</td>
+  <td>SA1316TupleElementNamesShouldUseCorrectCasing</td>
 </tr>
 <tr>
   <td>CheckId</td>
@@ -20,18 +20,18 @@
 
 ## Cause
 
-Field names within a tuple declaration should have the correct casing.
+Element names within a tuple type should have the correct casing.
 
 ## Rule description
 
-Tuple declarations with field names should use the configured casing for the field names (see [Configuration.md](Configuration.md) for details).  See the documentation on [tuple types](https://docs.microsoft.com/en-us/dotnet/csharp/tuples) for information on how to work with tuples in C# 7.
+Tuple types with element names should use the configured casing for the element names (see [Configuration.md](Configuration.md) for details).  See the documentation on [tuple types](https://docs.microsoft.com/en-us/dotnet/csharp/tuples) for information on how to work with tuples in C# 7.
 
 For example, the following code would produce a violation of this rule (with default settings):
 
 ```csharp
 public class ExampleClass
 {
-  public (int ValueA, int ValueB) ExampleMethod()
+  public (int ValueA, int ValueB) ExampleMethod() // SA1316
   {
   }
 }
@@ -50,15 +50,15 @@ public class ExampleClass
 
 ## How to fix violations
 
-To fix a violation of this rule, correct the casing of the tuple field name.
+To fix a violation of this rule, correct the casing of the tuple element name.
 
 ## How to suppress violations
 
 ```csharp
-[SuppressMessage("StyleCop.CSharp.NamingRules", "SA1316:TupleFieldNamesMustUseCorrectCasing", Justification = "Reviewed.")]
+[SuppressMessage("StyleCop.CSharp.NamingRules", "SA1316:TupleElementNamesShouldUseCorrectCasing", Justification = "Reviewed.")]
 ```
 
 ```csharp
-#pragma warning disable SA1316 // Tuple field names must use correct casing
-#pragma warning restore SA1316 // Tuple field names must use correct casing
+#pragma warning disable SA1316 // Tuple element names should use correct casing
+#pragma warning restore SA1316 // Tuple element names should use correct casing
 ```

documentation/SA1414.md

@@ -20,18 +20,18 @@
 
 ## Cause
 
-A tuple declaration without element names is present in a member declaration.
+A tuple type without element names is present in a member declaration.
 
 ## Rule description
 
-Tuple types appearing in member declarations should have explicitly named tuple elements.  See the documentation on [tuple types](https://docs.microsoft.com/en-us/dotnet/csharp/tuples) for information on how to work with tuples in C# 7.
+Tuple types appearing in member declarations should have explicitly named elements.  See the documentation on [tuple types](https://docs.microsoft.com/en-us/dotnet/csharp/tuples) for information on how to work with tuples in C# 7.
 
 For example, the following code would produce a violation of this rule:
 
 ```csharp
 public class ExampleClass
 {
-  public (int, int) ExampleMethod()
+  public (int, int) ExampleMethod() // SA1414
   {
   }
 }
@@ -50,7 +50,7 @@ public class ExampleClass
 
 ## How to fix violations
 
-To fix a violation of this rule, provide an element name foreach tuple element.
+To fix a violation of this rule, provide an element name for each tuple element.
 
 ## How to suppress violations