Use the preferred terms

BillWagner · BillWagner · commit 188211ee974c · 2026-06-12T12:03:45.000-04:00
Use the preferred terms for memory safety.
diff --git a/docfx.json b/docfx.json
@@ -648,6 +648,7 @@
                 "_csharplang/proposals/collection-expression-arguments.md": "Collection expression arguments",
                 "_csharplang/proposals/unions.md": "Unions",
                 "_csharplang/proposals/closed-hierarchies.md": "Closed hierarchies",
+                "_csharplang/proposals/unsafe-evolution.md": "Memory safety",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md": "C# compiler breaking changes since C# 10",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 8.md": "C# compiler breaking changes since C# 11",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 9.md": "C# compiler breaking changes since C# 12",
@@ -732,6 +733,7 @@
                 "_csharplang/proposals/collection-expression-arguments.md": "This proposal introduces collection expression arguments.",
                 "_csharplang/proposals/unions.md": "This proposal describes union types and union declarations. Unions allow expressing values from a closed set of types with exhaustive pattern matching.",
                 "_csharplang/proposals/closed-hierarchies.md": "This proposal describes closed class hierarchies. A closed class restricts derivation to its declaring assembly, enabling exhaustive `switch` expressions over its direct descendants.",
+                "_csharplang/proposals/unsafe-evolution.md": "This proposal describes the evolution of memory safety in C#. It ties the `unsafe` context to operations that access unmanaged memory, rather than to the existence of pointer types.",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md": "Learn about any breaking changes since the initial release of C# 10 and included in C# 11",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 8.md": "Learn about any breaking changes since the initial release of C# 11 and included in C# 12",
                 "_roslyn/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 9.md": "Learn about any breaking changes since the initial release of C# 12 and included in C# 13",
diff --git a/docs/csharp/language-reference/keywords/unsafe.md b/docs/csharp/language-reference/keywords/unsafe.md
@@ -41,7 +41,7 @@ unsafe
 To compile unsafe code, you must specify the [**AllowUnsafeBlocks**](../compiler-options/language.md#allowunsafeblocks) compiler option. The common language runtime can't verify unsafe code.
 
 > [!NOTE]
-> Beginning with C# 15, the [unsafe evolution](../unsafe-code.md#unsafe-evolution-preview) preview feature narrows the operations that require an `unsafe` context. Creating a pointer, the `fixed` statement, and converting a `stackalloc` to a pointer no longer require an `unsafe` context. Only operations that access the pointed-to memory, such as pointer indirection, do. A later preview also changes `unsafe` on a member to mark it as *requires-unsafe*, so callers must use the member from an `unsafe` context.
+> Beginning with C# 15, the [memory safety](../unsafe-code.md#memory-safety-preview) preview feature narrows the operations that require an `unsafe` context. Creating a pointer, the `fixed` statement, and converting a `stackalloc` to a pointer no longer require an `unsafe` context. Only operations that access the pointed-to memory, such as pointer indirection, do. A later preview also changes `unsafe` on a member to mark it as *requires-unsafe*, so callers must use the member from an `unsafe` context.
 
 ## Example
 
diff --git a/docs/csharp/language-reference/operators/pointer-related-operators.md b/docs/csharp/language-reference/operators/pointer-related-operators.md
@@ -41,7 +41,7 @@ For information about pointer types, see [Pointer types](../unsafe-code.md#point
 > Any operation with pointers requires an [unsafe](../keywords/unsafe.md) context. You must compile the code that contains unsafe blocks with the [**AllowUnsafeBlocks**](../compiler-options/language.md#allowunsafeblocks) compiler option.
 
 > [!NOTE]
-> Beginning with C# 15, the [unsafe evolution](../unsafe-code.md#unsafe-evolution-preview) preview feature lets you use the address-of `&` operator outside an `unsafe` context. The pointer indirection, member access, and element access operators that read or write the pointed-to memory still require an `unsafe` context.
+> Beginning with C# 15, the [memory safety](../unsafe-code.md#memory-safety-preview) preview feature lets you use the address-of `&` operator outside an `unsafe` context. The pointer indirection, member access, and element access operators that read or write the pointed-to memory still require an `unsafe` context.
 
 ## <a name="address-of-operator-"></a> Address-of operator &amp;
 
diff --git a/docs/csharp/language-reference/operators/sizeof.md b/docs/csharp/language-reference/operators/sizeof.md
@@ -37,7 +37,7 @@ The size of the types in the preceding table is a compile-time constant.
 In [unsafe](../keywords/unsafe.md) code, you can use `sizeof` on any non-`void` type, including types constructed from type parameters.
 
 > [!NOTE]
-> Beginning with C# 15, the [unsafe evolution](../unsafe-code.md#unsafe-evolution-preview) preview feature lets you use `sizeof` on any unmanaged type outside an `unsafe` context.
+> Beginning with C# 15, the [memory safety](../unsafe-code.md#memory-safety-preview) preview feature lets you use `sizeof` on any unmanaged type outside an `unsafe` context.
 
 - The size of a reference or pointer type is the size of a reference or pointer, not the size of the object it might refer to.
 - The size of a value type, unmanaged or not, is the size of such a value.
diff --git a/docs/csharp/language-reference/operators/stackalloc.md b/docs/csharp/language-reference/operators/stackalloc.md
@@ -39,7 +39,7 @@ You can assign the result of a `stackalloc` expression to a variable of one of t
   As the preceding example shows, you must use an `unsafe` context when you work with pointer types.
 
   > [!NOTE]
-  > Beginning with C# 15, the [unsafe evolution](../unsafe-code.md#unsafe-evolution-preview) preview feature lets you convert a `stackalloc` expression to a pointer outside an `unsafe` context. Operations that access the allocated memory through the pointer still require an `unsafe` context.
+  > Beginning with C# 15, the [memory safety](../unsafe-code.md#memory-safety-preview) preview feature lets you convert a `stackalloc` expression to a pointer outside an `unsafe` context. Operations that access the allocated memory through the pointer still require an `unsafe` context.
 
   For pointer types, you can use a `stackalloc` expression only in a local variable declaration to initialize the variable.
 
diff --git a/docs/csharp/language-reference/snippets/memory-safety/Program.cs b/docs/csharp/language-reference/snippets/memory-safety/Program.cs
@@ -0,0 +1,6 @@
+// Entry point so the snippet project produces an executable and is verified by a build.
+MemorySafety.Relaxations.CreatePointer();
+MemorySafety.Relaxations.PinArray([1, 2, 3]);
+MemorySafety.Relaxations.AllocateOnStack();
+System.Console.WriteLine(MemorySafety.Relaxations.SizeOfStruct());
+System.Console.WriteLine(MemorySafety.Relaxations.ReadValue([10, 20, 30]));
diff --git a/docs/csharp/language-reference/snippets/memory-safety/Relaxations.cs b/docs/csharp/language-reference/snippets/memory-safety/Relaxations.cs
@@ -1,9 +1,9 @@
-// This file demonstrates the C# 15 unsafe evolution relaxations verified against
+// This file demonstrates the C# 15 memory safety relaxations verified against
 // .NET 11 Preview 5. Creating pointers, the fixed statement, stackalloc-to-pointer,
 // and sizeof no longer require an unsafe context. Only operations that access the
 // pointed-to memory still require one.
 
-namespace UnsafeEvolution;
+namespace MemorySafety;
 
 public class Relaxations
 {
diff --git a/docs/csharp/language-reference/snippets/memory-safety/memory-safety.csproj b/docs/csharp/language-reference/snippets/memory-safety/memory-safety.csproj
diff --git a/docs/csharp/language-reference/snippets/unsafe-evolution/Program.cs b/docs/csharp/language-reference/snippets/unsafe-evolution/Program.cs
diff --git a/docs/csharp/language-reference/statements/fixed.md b/docs/csharp/language-reference/statements/fixed.md
@@ -21,7 +21,7 @@ The `fixed` statement prevents the [garbage collector](../../../standard/garbage
 > You can use the `fixed` statement only in an [unsafe](../keywords/unsafe.md) context. The code that contains unsafe blocks must be compiled by using the [**AllowUnsafeBlocks**](../compiler-options/language.md#allowunsafeblocks) compiler option.
 
 > [!NOTE]
-> Beginning with C# 15, the [unsafe evolution](../unsafe-code.md#unsafe-evolution-preview) preview feature lets you use the `fixed` statement outside an `unsafe` context. Only operations that access the pinned memory through the pointer, such as pointer indirection, still require an `unsafe` context.
+> Beginning with C# 15, the [memory safety](../unsafe-code.md#memory-safety-preview) preview feature lets you use the `fixed` statement outside an `unsafe` context. Only operations that access the pinned memory through the pointer, such as pointer indirection, still require an `unsafe` context.
 
 You can initialize the declared pointer as follows:
 
diff --git a/docs/csharp/language-reference/unsafe-code.md b/docs/csharp/language-reference/unsafe-code.md
@@ -31,12 +31,12 @@ Unsafe code has the following properties:
 
 For information about best practices for unsafe code in C#, see [Unsafe code best practices](../../standard/unsafe-code/best-practices.md).
 
-## Unsafe evolution (preview)
+## Memory safety (preview)
 
 > [!IMPORTANT]
-> Unsafe evolution is a preview feature in C# 15. The behavior described in this section can change before the feature ships. To try the relaxations, set the [`LangVersion`](compiler-options/language.md#langversion) compiler option to `preview`.
+> Memory safety is a preview feature in C# 15. The behavior described in this section can change before the feature ships. To try the relaxations, set the [`LangVersion`](compiler-options/language.md#langversion) compiler option to `preview`.
 
-Unsafe evolution narrows the definition of an unsafe context. Historically, the `unsafe` context covered the existence of pointer types. The updated rules tie the `unsafe` context to the operations that access memory the runtime doesn't manage. The existence of a pointer isn't unsafe; the dereference of a pointer is.
+The memory safety feature narrows the definition of an unsafe context. Historically, the `unsafe` context covered the existence of pointer types. The updated rules tie the `unsafe` context to the operations that access memory the runtime doesn't manage. The existence of a pointer isn't unsafe; the dereference of a pointer is.
 
 Under the updated rules, the following operations no longer require an `unsafe` context:
 
@@ -47,9 +47,9 @@ Under the updated rules, the following operations no longer require an `unsafe`
 
 The following example creates and pins pointers without an `unsafe` context:
 
-:::code language="csharp" source="snippets/unsafe-evolution/Relaxations.cs" id="CreatePointer":::
+:::code language="csharp" source="snippets/memory-safety/Relaxations.cs" id="CreatePointer":::
 
-:::code language="csharp" source="snippets/unsafe-evolution/Relaxations.cs" id="FixedStatement":::
+:::code language="csharp" source="snippets/memory-safety/Relaxations.cs" id="FixedStatement":::
 
 These relaxations apply whenever you compile with the `preview` language version, whether or not an assembly opts in to the updated memory safety rules.
 
@@ -61,13 +61,13 @@ The operations that access the pointed-to memory still require an `unsafe` conte
 
 The following example pins an array without an `unsafe` context but dereferences the pointer inside one:
 
-:::code language="csharp" source="snippets/unsafe-evolution/Relaxations.cs" id="Dereference":::
+:::code language="csharp" source="snippets/memory-safety/Relaxations.cs" id="Dereference":::
 
 ### Updated memory safety rules
 
 Later previews extend the meaning of `unsafe` as a member modifier. Today, `unsafe` on a member only allows pointers in the signature and body. Under the updated memory safety rules, `unsafe` on a member marks it as *requires-unsafe*: callers must use the member from an `unsafe` context. The audit obligation moves to the caller. An assembly opts in to this enforcement, and the compiler records the choice with the `System.Runtime.CompilerServices.MemorySafetyRulesAttribute` attribute. The feature also adds a `safe` contextual keyword that marks `extern` members and explicit-layout fields as safe.
 
-The compiler in .NET 11 Preview 5 implements the pointer relaxations but doesn't yet enforce the *requires-unsafe* rules, the assembly opt-in, or the `safe` keyword. For the full design, see the [unsafe evolution feature specification](~/_csharplang/proposals/unsafe-evolution.md).
+The compiler in .NET 11 Preview 5 implements the pointer relaxations but doesn't yet enforce the *requires-unsafe* rules, the assembly opt-in, or the `safe` keyword. For the full design, see the [memory safety feature specification](~/_csharplang/proposals/unsafe-evolution.md).
 
 ## Pointer types
 
diff --git a/docs/csharp/misc/sorry-we-don-t-have-specifics-on-this-csharp-error.md b/docs/csharp/misc/sorry-we-don-t-have-specifics-on-this-csharp-error.md
@@ -272,7 +272,7 @@ f1_keywords:
   - "CS9357"
   - "CS9358"
   - "CS9359"
-# unsafe evolution
+# memory safety
   - "CS9360"
   - "CS9361"
   - "CS9362"
diff --git a/docs/csharp/specification/toc.yml b/docs/csharp/specification/toc.yml
@@ -159,7 +159,7 @@ items:
       href: ../../../_csharplang/proposals/csharp-12.0/experimental-attribute.md
   - name: Unsafe code
     items:
-    - name: Unsafe evolution
+    - name: Memory safety
       href: ../../../_csharplang/proposals/unsafe-evolution.md
 - name: Deviations from the C# standard
   href: ../../../_roslyn/docs/compilers/CSharp/Deviations from Standard.md
diff --git a/docs/csharp/whats-new/csharp-15.md b/docs/csharp/whats-new/csharp-15.md
@@ -13,7 +13,7 @@ C# 15 includes the following new features. Try these features by using the lates
 - [Collection expression arguments](#collection-expression-arguments)
 - [Union types](#union-types)
 - [Closed hierarchies](#closed-hierarchies)
-- [Unsafe evolution](#unsafe-evolution)
+- [Memory safety](#memory-safety)
 
 C# 15 is the latest C# preview release. .NET 11 preview versions support C# 15. For more information, see [C# language versioning](../language-reference/configure-language-version.md).
 
@@ -108,7 +108,7 @@ The `closed` modifier is a contextual keyword. A `closed` class is implicitly `a
 
 For more information, see the [closed modifier](../language-reference/keywords/closed.md) and [Closed hierarchy patterns](../language-reference/operators/patterns.md#closed-hierarchy-patterns) in the language reference, or the [feature specification](~/_csharplang/proposals/closed-hierarchies.md). You can copy the examples in this section, including the `ClosedAttribute` workaround, from the [keywords snippets project](https://github.com/dotnet/docs/blob/main/docs/csharp/language-reference/keywords/snippets/shared) in the `dotnet/docs` GitHub repository.
 
-## Unsafe evolution
+## Memory safety
 
 C# 15 begins to evolve the rules for unsafe code. Historically, the `unsafe` context covered the existence of pointer types. The updated rules tie the `unsafe` context to the operations that access unmanaged memory, not to the existence of a pointer.
 
@@ -136,7 +136,7 @@ The operations that access the pointed-to memory, such as pointer indirection (`
 
 The .NET 11 Preview 5 compiler implements these relaxations. A later preview adds the *requires-unsafe* member model, the assembly opt-in to the updated memory safety rules, and the `safe` contextual keyword.
 
-For more information, see [Unsafe code, pointer types, and function pointers](../language-reference/unsafe-code.md#unsafe-evolution-preview) in the language reference or the [feature specification](~/_csharplang/proposals/unsafe-evolution.md).
+For more information, see [Unsafe code, pointer types, and function pointers](../language-reference/unsafe-code.md#memory-safety-preview) in the language reference or the [feature specification](~/_csharplang/proposals/unsafe-evolution.md).
 
 <!-- Add when available
 ## See also
