"compiler synthesized"

Use the term "compiler synthesized" rather than "compiler generated" for the backing field in automatically implemented or field backed properties.

Author: BillWagner

docfx.json

@@ -792,7 +792,7 @@
                 "_csharplang/proposals/csharp-13.0/ref-struct-interfaces.md": "This proposal provides features that enable interface authors to allow `ref struct` types to implement a particular interface",
                 "_csharplang/proposals/csharp-13.0/partial-properties.md": "This proposal provides for partial properties and indexers, allowing the definition of a property or indexer to be split across multiple parts.",
                 "_csharplang/proposals/csharp-13.0/overload-resolution-priority.md": "This proposal introduces a new attribute, `OverloadResolutionPriorityAttribute`, that can be applied to methods to influence overload resolution.",
-                "_csharplang/proposals/field-keyword.md": "This proposal introduces a new keyword, `field`, that accesses the compiler generated backing field in a property accessor.",
+                "_csharplang/proposals/field-keyword.md": "This proposal introduces a new keyword, `field`, that accesses the compiler synthesized backing field in a property accessor.",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md": "Learn about any breaking changes since the initial release of C# 10",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 8.md": "Learn about any breaking changes since the initial release of C# 11",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 9.md": "Learn about any breaking changes since the initial release of C# 12",

docs/csharp/language-reference/keywords/field.md

@@ -1,5 +1,5 @@
 ---
-description: "The `field` contextual keyword - access the compiler generated backing field for a property"
+description: "The `field` contextual keyword - access the compiler synthesized backing field for a property"
 title: "The `field` contextual keyword"
 ms.date: 10/30/2024
 f1_keywords: 
@@ -11,7 +11,7 @@ helpviewer_keywords:
 
 [!INCLUDE[field-preview](../../includes/field-preview.md)]
 
-The contextual keyword `field`, added as a preview feature in C# 13, can be used in a property accessor to access the compiler generated backing field of a property. This syntax enables you to define the body of a `get` or `set` accessor and let the compiler generate the other accessor as it would in an automatically implemented property.
+The contextual keyword `field`, added as a preview feature in C# 13, can be used in a property accessor to access the compiler synthesized backing field of a property. This syntax enables you to define the body of a `get` or `set` accessor and let the compiler generate the other accessor as it would in an automatically implemented property.
 
 The addition of the `field` contextual keywords provides a smooth path to add benefits such as range checking to an automatically implemented property. This practice is shown in the following example:
 

docs/csharp/language-reference/keywords/get.md

@@ -23,7 +23,7 @@ Often, the `get` accessor consists of a single statement that returns a value, a
 
 :::code language="csharp" source="./snippets/PropertyAccessors.cs" id="GetSetExpressions":::
 
-You might find that you need to implement one of the accessor bodies. You can use a field backed property to let the compiler generate one accessor while you write the other by hand. You use the `field` keyword, added as a preview feature in C# 13, to access the compiler generated backing field:
+You might find that you need to implement one of the accessor bodies. You can use a field backed property to let the compiler generate one accessor while you write the other by hand. You use the `field` keyword, added as a preview feature in C# 13, to access the compiler synthesized backing field:
 
 :::code language="csharp" source="./snippets/PropertyAccessors.cs" id="FieldBackedProperty":::
 

docs/csharp/language-reference/keywords/init.md

@@ -17,7 +17,7 @@ The following code demonstrates an `init` accessor in an automatically implement
 
 :::code language="csharp" source="snippets/InitExample2.cs":::
 
-You might need to implement one of the accessors to provide parameter validation. You can do that using the `field` keyword, introduced as a preview feature in C# 13. The `field` keyword accesses the compiler generated backing field for that property. The following example shows a property where the `init` accessor validates the range of the `value` parameter"
+You might need to implement one of the accessors to provide parameter validation. You can do that using the `field` keyword, introduced as a preview feature in C# 13. The `field` keyword accesses the compiler synthesized backing field for that property. The following example shows a property where the `init` accessor validates the range of the `value` parameter"
 
 :::code language="csharp" source="snippets/InitExample5.cs":::
 

docs/csharp/language-reference/keywords/set.md

@@ -19,7 +19,7 @@ For simple cases in which a property's `get` and `set` accessors perform no othe
 > [!IMPORTANT]
 > Automatically implemented properties aren't allowed for [interface property declarations](../../programming-guide/classes-and-structs/interface-properties.md) or the implementing declaration for a [partial property](./partial-member.md). The compiler interprets syntax matching an automatically implemented property as the declaring declaration, not an implementing declaration.
 
-You might find that you need to implement one of the accessor bodies. The `field` keyword, added as a preview feature in C# 13 declares a field backed property. You can use a field backed property to let the compiler generate one accessor while you write the other by hand. You use the `field` keyword to access the compiler generated backing field:
+You might find that you need to implement one of the accessor bodies. The `field` keyword, added as a preview feature in C# 13 declares a field backed property. You can use a field backed property to let the compiler generate one accessor while you write the other by hand. You use the `field` keyword to access the compiler synthesized backing field:
 
 :::code language="csharp" source="./snippets/PropertyAccessors.cs" id="FieldBackedProperty":::
 

docs/csharp/programming-guide/classes-and-structs/auto-implemented-properties.md

@@ -32,7 +32,7 @@ The class that is shown in the previous example is mutable. Client code can chan
 
 For more information, see [How to implement a lightweight class with automatically implemented properties](./how-to-implement-a-lightweight-class-with-auto-implemented-properties.md).
 
-You might need to add validation to an automatically implemented property. C# 13 adds [field backed properties](../../language-reference/keywords/field.md) as a preview feature. You use the `field` keyword to access the compiler generated backing field of an automatically implemented property. For example, you could ensure that the `FirstName` property in the preceding example can't be set to `null` or the empty string:
+You might need to add validation to an automatically implemented property. C# 13 adds [field backed properties](../../language-reference/keywords/field.md) as a preview feature. You use the `field` keyword to access the compiler synthesized backing field of an automatically implemented property. For example, you could ensure that the `FirstName` property in the preceding example can't be set to `null` or the empty string:
 
 ```csharp
 public string FirstName 

docs/csharp/programming-guide/classes-and-structs/partial-classes-and-methods.md

@@ -116,7 +116,7 @@ The method and all calls to the method are removed at compile time when there's
 
 Any method that doesn't conform to all those restrictions, including properties and indexers, must provide an implementation. That implementation might be supplied by a *source generator*. [Partial properties](../../language-reference/keywords/partial-member.md) can't be implemented using automatically implemented properties. The compiler can't distinguish between an automatically implemented property, and the declaring declaration of a partial property.
 
-Beginning with C# 13, the implementing declaration for a partial property can use [field backed properties](../../language-reference/keywords/field.md) to define the implementing declaration. A field backed property provides a concise syntax where the `field` keyword accesses the compiler generated backing field for the property. For example, you could write the following:
+Beginning with C# 13, the implementing declaration for a partial property can use [field backed properties](../../language-reference/keywords/field.md) to define the implementing declaration. A field backed property provides a concise syntax where the `field` keyword accesses the compiler synthesized backing field for the property. For example, you could write the following:
 
 :::code language="csharp" source="snippets/partial-classes-and-methods/Program.cs" id="FieldProperty":::
 

docs/csharp/programming-guide/classes-and-structs/properties.md

@@ -28,7 +28,7 @@ You can initialize a property to a value other than the default by setting a val
 
 ## Field backed properties
 
-In C# 13, you can add validation or other logic in the accessor for a property using the [`field`](../../language-reference/keywords/field.md) keyword preview feature. The `field` keyword accesses the compiler generated backing field for a property. It enables you to write a property accessor without explicitly declaring a separate backing field.
+In C# 13, you can add validation or other logic in the accessor for a property using the [`field`](../../language-reference/keywords/field.md) keyword preview feature. The `field` keyword accesses the compiler synthesized backing field for a property. It enables you to write a property accessor without explicitly declaring a separate backing field.
 
 :::code language="csharp" source="./snippets/properties/Person.cs" id="FieldBackedProperty":::
 

docs/csharp/whats-new/csharp-13.md

@@ -166,7 +166,7 @@ This feature is intended for library authors to avoid ambiguity when adding new
 
 ## The `field` keyword
 
-The [`field`](../language-reference/keywords/field.md) contextual keyword is in C# 13 as a preview feature. The token `field` accesses the compiler generated backing field in a property accessor. It enables you to write an accessor body without declaring an explicit backing field in your type declaration. You can declare a body for one or both accessors for a field backed property.
+The [`field`](../language-reference/keywords/field.md) contextual keyword is in C# 13 as a preview feature. The token `field` accesses the compiler synthesized backing field in a property accessor. It enables you to write an accessor body without declaring an explicit backing field in your type declaration. You can declare a body for one or both accessors for a field backed property.
 
 The `field` feature is released as a preview feature. We want to learn from your experiences using it. There's a potential a breaking change or confusion reading code in types that also include a field named `field`.  You can use `@field` or `this.field` to disambiguate between the `field` keyword and the identifier.