Repo sync for protected branch

docs/build/reference/experimental-module.md

@@ -1,36 +1,57 @@
 ---
 title: "/experimental:module (Enable module support)"
 description: "Use the /experimental:module compiler option to enable experimental compiler support for named modules."
-ms.date: 01/27/2022
+ms.date: 02/12/2025
 f1_keywords: ["module", "/experimental:module"]
 helpviewer_keywords: ["module", "/experimental:module", "Enable module support"]
 ---
-# `/experimental:module` (Enable module support)
+# `/experimental:module` (Enable experimental module support)
 
-Enables experimental compiler support for C++ Standard modules. This option is obsolete for C++20 standard modules in Visual Studio version 16.11 and later. It's still required (along with [`/std:c++latest`](std-specify-language-standard-version.md)) for the experimental Standard library modules.
+Enables compiler support for Microsoft's experimental form of C++ Standard modules. This option is obsolete in Visual Studio 2019 version 16.11 and later.
 
 ## Syntax
 
 > **`/experimental:module`**\[**`-`**]
 
 ## Remarks
 
-In versions of Visual Studio before Visual Studio 2019 version 16.11, you can enable experimental modules support by use of the **`/experimental:module`** compiler option along with the [`/std:c++latest`](std-specify-language-standard-version.md) option. In Visual Studio 2019 version 16.11, module support is enabled automatically by either **`/std:c++20`** or **`/std:c++latest`**. Use **`/experimental:module-`** to disable module support explicitly.
+ This switch was for the time before the new, standardized, way of consuming the C++ Standard Library as modules described in [Import the C++ standard library using modules](../../cpp/tutorial-import-stl-named-module.md) was available. Although you can use this switch to use the older experimental named modules, we recommend that you use the new, standardized, way of consuming the C++ Standard Library as modules described in [Import the C++ standard library using modules](../../cpp/tutorial-import-stl-named-module.md).
 
-This option is available starting in Visual Studio 2015 Update 1. As of Visual Studio 2019 version 16.2, C++20 Standard modules aren't fully implemented in the Microsoft C++ compiler. Modules support is feature complete in Visual Studio 2019 version 16.10. You can use the modules feature import the Standard Library modules provided by Microsoft. A module and the code that consumes it must be compiled with the same compiler options.
+This compiler became available starting in Visual Studio 2015 Update 1. Ensure that **C++ Modules for v143 build tools (x64/x86 - experimental)** in selected the VS Installer. It's available in the **Individual components** tab of the installer. Search for **experimental** to see the option. For more information, see [Install C and C++ support in Visual Studio](../vscpp-step-0-installation.md).
 
-For more information on modules and how to use and create them, see [Overview of modules in C++](../../cpp/modules-cpp.md).
+| Version  | Status |
+|---|---|
+| Visual Studio 2015 Update 1  | `/experimental:module` introduced. |
+| Visual Studio 2019 version 16.10 | C++20 modules support is feature complete. |
+| Visual Studio 2019 16.11 and earlier | Enable experimental modules support using **`/experimental:module`** along with [`/std:c++latest`](std-specify-language-standard-version.md). |
+| Visual Studio 2019 version 16.11 and later | Modules support is enabled automatically with **`/std:c++20`** or later, or **`/std:c++latest`**. Use **`/experimental:module-`** to disable experimental module support. |
+
+The experimental library consists of the following named modules:
+
+- `std.regex` provides the content of header `<regex>`
+- `std.filesystem` provides the content of header `<filesystem>`
+- `std.memory` provides the content of header `<memory>`
+- `std.threading` provides the contents of headers `<atomic>`, `<condition_variable>`, `<future>`, `<mutex>`, `<shared_mutex>`, and `<thread>`
+- `std.core` provides everything else in the C++ Standard Library
+
+To consume these modules, add an import declaration to the top of the source code file. For example:
+
+```cpp
+import std.core;
+import std.regex;
+```
+
+To consume the experimental Microsoft Standard Library modules, compile your program with the [`/EHsc`](eh-exception-handling-model.md) and [`/MD`](md-mt-ld-use-run-time-library.md) options.
 
 ### To set this compiler option in the Visual Studio development environment
 
 1. Open the project's **Property Pages** dialog box. For details, see [Set C++ compiler and build properties in Visual Studio](../working-with-project-properties.md).
-
 1. Set the **Configuration** drop-down to **All Configurations**.
-
 1. Select the **Configuration Properties** > **C/C++** > **Language** property page.
-
 1. Modify the **Enable C++ Modules (experimental)** property, and then choose **OK**.
 
+For more information about how to use and create modules, see [Overview of modules in C++](../../cpp/modules-cpp.md).
+
 ## See also
 
 [`/headerUnit` (Use header unit IFC)](headerunit.md)\

docs/cpp/import-export-module.md

@@ -1,13 +1,13 @@
 ---
 title: "module, import, export"
-ms.date: 02/14/2022
+ms.date: 02/13/2025
 f1_keywords: ["module_cpp", "import_cpp", "export_cpp"]
 helpviewer_keywords: ["modules [C++]", "modules [C++], import", "modules [C++], export"]
 description: Use import and export declarations to access and to publish types and functions defined in the specified module.
 ---
 # `module`, `import`, `export`
 
-The **`module`**, **`import`**, and **`export`** declarations are available in C++20 and require the [`/experimental:module`](../build/reference/experimental-module.md) compiler switch along with [`/std:c++20`](../build/reference/std-specify-language-standard-version.md) or later (such as **`/std:c++latest`**). For more information, see [Overview of modules in C++](modules-cpp.md).
+The **`module`**, **`import`**, and **`export`** declarations are available in C++20 and require the compiler switch [`/std:c++20`](../build/reference/std-specify-language-standard-version.md) or later (such as **`/std:c++latest`**). For more information, see [Overview of modules in C++](modules-cpp.md).
 
 ## `module`
 
@@ -19,7 +19,7 @@ module ModuleA;
 
 ## `export`
 
-Use an **`export module`** declaration for the module's primary interface file, which must have extension *`.ixx`*:
+Use an **`export module`** declaration for the module's primary interface file, which has an extension *`.ixx`* by default. If you want to use a different extension, use the [/interface](../build/reference/interface.md) switch to compile it as a module interface.
 
 ```cpp
 export module ModuleA;

docs/cpp/modules-cpp.md

@@ -1,6 +1,6 @@
 ---
 title: "Overview of modules in C++"
-ms.date: 01/29/2024
+ms.date: 02/11/2025
 helpviewer_keywords: ["modules [C++]", "modules [C++], overview"]
 description: Modules in C++20 provide a modern alternative to header files.
 ---
@@ -14,44 +14,15 @@ You can use modules side by side with header files. A C++ source file can `impor
 
 To contrast modules with other ways to import the standard library, see [Compare header units, modules, and precompiled headers](../build/compare-inclusion-methods.md).
 
-## Enable modules in the Microsoft C++ compiler
+Starting with Visual Studio 2022 version 17.5, importing the Standard Library as a module is both standardized and fully implemented in the Microsoft C++ compiler. To learn how to import the Standard Library using modules, see [Import the C++ standard library using modules](tutorial-import-stl-named-module.md).
 
-As of Visual Studio 2022 version 17.1, C++20 standard modules are fully implemented in the Microsoft C++ compiler.
+## Single-partition modules
 
-Before it was specified by the C++20 standard, Microsoft had experimental support for modules. The compiler also supported importing prebuilt Standard Library modules, described below.
+A single-partition module is a module that consists of a single source file. The module interface and implementation are in the same file.
 
-Starting with Visual Studio 2022 version 17.5, importing the Standard Library as a module is both standardized and fully implemented in the Microsoft C++ compiler. This section describes the older, experimental method, which is still supported. For information about the new standardized way to import the Standard Library using modules, see [Import the C++ standard library using modules](tutorial-import-stl-named-module.md).
+The following single-partition module example shows a simple module definition in a source file called *`Example.ixx`*. The *`.ixx`* extension is the default extension for module interface files in Visual Studio. If you want to use a different extension, use the [/interface](../build/reference/interface.md) switch to compile it as a module interface. In this example, the interface file contains both the function definition and the declaration. You can also place the definitions in one or more separate module implementation files, as shown in a later example, but this is an example of a single-partition module.
 
-You can use the modules feature to create single-partition modules and to import the Standard Library modules provided by Microsoft. To enable support for Standard Library modules, compile with [`/experimental:module`](../build/reference/experimental-module.md) and [`/std:c++latest`](../build/reference/std-specify-language-standard-version.md). In a Visual Studio project, right-click the project node in **Solution Explorer** and choose **Properties**. Set the **Configuration** drop-down to **All Configurations**, then choose **Configuration Properties** > **C/C++** > **Language** > **Enable C++ Modules (experimental)**.
-
-A module and the code that consumes it must be compiled with the same compiler options.
-
-## Consume C++ Standard Library as modules (experimental)
-
-This section describes the experimental implementation, which is still supported. The new standardized way of consuming the C++ Standard Library as modules is described in [Import the C++ standard library using modules](tutorial-import-stl-named-module.md).
-
-By importing the C++ Standard Library as modules rather than including it through header files, you can potentially speed up compilation times depending on the size of your project. The experimental library is split into the following named modules:
-
-- `std.regex` provides the content of header `<regex>`
-- `std.filesystem` provides the content of header `<filesystem>`
-- `std.memory` provides the content of header `<memory>`
-- `std.threading` provides the contents of headers `<atomic>`, `<condition_variable>`, `<future>`, `<mutex>`, `<shared_mutex>`, and `<thread>`
-- `std.core` provides everything else in the C++ Standard Library
-
-To consume these modules, add an import declaration to the top of the source code file. For example:
-
-```cpp
-import std.core;
-import std.regex;
-```
-
-To consume the Microsoft Standard Library modules, compile your program with the [`/EHsc`](../build/reference/eh-exception-handling-model.md) and [`/MD`](../build/reference/md-mt-ld-use-run-time-library.md) options.
-
-## Example
-
-The following example shows a simple module definition in a source file called *`Example.ixx`*. The *`.ixx`* extension is required for module interface files in Visual Studio. In this example, the interface file contains both the function definition and the declaration. However, you can also place the definitions in one or more separate module implementation files, as shown in a later example.
-
-The `export module Example;` statement indicates that this file is the primary interface for a module called `Example`. The **`export`** modifier on `f()` indicates that this function is visible when another program or module imports `Example`.
+The `export module Example;` statement indicates that this file is the primary interface for a module called `Example`. The **`export`** modifier before `int f()` indicates that this function is visible when another program or module imports `Example`:
 
 ```cpp
 // Example.ixx
@@ -61,12 +32,14 @@ export module Example;
 
 namespace Example_NS
 {
-   int f_internal() {
-        return ANSWER;
-      }
+   int f_internal()
+   {
+     return ANSWER;
+   }
 
-   export int f() {
-      return f_internal();
+   export int f()
+   {
+     return f_internal();
    }
 }
 ```
@@ -88,7 +61,7 @@ int main()
 }
 ```
 
-The `import` declaration can appear only at global scope.
+The `import` declaration can appear only at global scope.  A module and the code that consumes it must be compiled with the same compiler options.
 
 ## Module grammar
 
@@ -138,6 +111,7 @@ When the compiler does argument-dependent lookup for overload resolutions in the
 ### Module partitions
 
 A module partition is similar to a module, except:
+
 - It shares ownership of all declarations in the entire module.
 - All names exported by partition interface files are imported and exported by the primary interface file.
 - A partition's name must begin with the module name followed by a colon (`:`).

docs/cpp/tutorial-import-stl-named-module.md

@@ -24,7 +24,7 @@ This tutorial requires Visual Studio 2022 17.5 or later.
 
 ## Introduction to standard library modules
 
-Header files suffer from semantics that can change depending on macro definitions, the order in which you include them, and they slow compilation. Modules solve these problems.
+Header file semantics can change depending on macro definitions, the order in which you include them, and they slow compilation. Modules solve these problems.
 
 It's now possible to import the standard library as a module instead of as a tangle of header files. This is much faster and more robust than including header files or header units or precompiled headers (PCH).
 
@@ -39,14 +39,12 @@ Because named modules don't expose macros, macros like `assert`, `errno`, `offse
 
 ## About C++ modules
 
-Header files are how declarations and definitions have been shared between source files in C++. Prior to standard library modules, you'd include the part of the standard library you needed with a directive like `#include <vector>`. Header files are fragile and difficult to compose because their semantics may change depending on the order you include them, or whether certain macros are defined. They also slow compilation because they're reprocessed by every source file that includes them.
+Header files are how declarations and definitions have been shared between source files in C++. Before standard library modules, you'd include the part of the standard library you needed with a directive like `#include <vector>`. Header files are fragile and difficult to compose because their semantics may change depending on the order you include them, or whether certain macros are defined. They also slow compilation because they're reprocessed by every source file that includes them.
 
 C++20 introduces a modern alternative called *modules*. In C++23, we were able to capitalize on module support to introduce named modules to represent the standard library.
 
 Like header files, modules allow you to share declarations and definitions across source files. But unlike header files, modules aren't fragile and are easier to compose because their semantics don't change due to macro definitions or the order in which you import them. The compiler can process modules much faster than it can process `#include` files, and uses less memory at compile time as well. Named modules don't expose macro definitions or private implementation details.
 
-For in depth information about modules, see [Overview of modules in C++](modules-cpp.md) That article also discusses consuming the C++ standard library as modules, but uses an older and experimental way of doing it.
-
 This article demonstrates the new and best way to consume the standard library. For more information about alternative ways to consume the standard library, see [Compare header units, modules, and precompiled headers](../build/compare-inclusion-methods.md).
 
 ## Import the standard library with `std`
@@ -57,7 +55,7 @@ The statement `import std;` or `import std.compat;` imports the standard library
 
 ### Example: How to build and import `std`
 
-1. Open a x86 Native Tools Command Prompt for VS: from the Windows **Start** menu, type *x86 native* and the prompt should appear in the list of apps. Ensure that the prompt is for Visual Studio 2022 version 17.5 or above. You'll get errors if you use the wrong version of the prompt. The examples used in this tutorial are for the CMD shell.
+1. Open a x86 Native Tools Command Prompt for VS: from the Windows **Start** menu, type *x86 native* and the prompt should appear in the list of apps. Ensure that the prompt is for Visual Studio 2022 version 17.5 or above. You get errors if you use the wrong version of the prompt. The examples used in this tutorial are for the CMD shell.
 1. Create a directory, such as `%USERPROFILE%\source\repos\STLModules`, and make it the current directory. If you choose a directory that you don't have write access to, you'll get errors during compilation.
 1. Compile the `std` named module with the following command: