Merge pull request MicrosoftDocs#3310 from MicrosoftDocs/master637648189299061962

Repo sync for protected CLA branch

Author: Colin Robertson

docs/build/reference/c-cpp-prop-page.md

@@ -335,14 +335,15 @@ Enables OpenMP 2.0 language extensions. Sets [`/openmp`](openmp-enable-openmp-2-
 
 ### C++ Language Standard
 
-Determines the C++ language standard the compiler enables. Use the latest version when possible. Sets [`/std:c++14`, `/std:c++17`, `/std:c++latest`](std-specify-language-standard-version.md).
+Determines the C++ language standard the compiler enables. The default value doesn't set a standard option, so the compiler uses its default C++14 setting. If you select a specific value, the corresponding [`/std`](std-specify-language-standard-version.md) compiler option is set.md).
 
 #### Choices
 
-- **Default**
-- **ISO C++14 Standard**
-- **ISO C++17 Standard**
-- **Preview - Features from the Latest C++ Working Draft**
+- **Default (ISO C++14 Standard)**
+- **ISO C++14 Standard (/std:c++14)**
+- **ISO C++17 Standard (/std:c++17)**
+- **ISO C++20 Standard (/std:c++20)**
+- **Preview - Features from the Latest C++ Working Draft  (/std:c++latest)**
 
 ### Enable C++ Modules (experimental)
 

docs/build/reference/experimental-module.md

@@ -7,17 +7,17 @@ helpviewer_keywords: ["module", "/experimental:module", "Enable module support"]
 ---
 # `/experimental:module` (Enable module support)
 
-Enables experimental compiler support for Standard Template Library named modules.
+Enables experimental compiler support for C++ Standard modules. This option is obsolete in Visual Studio version 16.11 and later.
 
 ## Syntax
 
-> **/experimental:module**[**-**]
+> **`/experimental:module`**\[**`-`**]
 
 ## Remarks
 
-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. Use **`/experimental:module-`** to disable module support explicitly.
+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 option is available starting in Visual Studio 2015 Update 1. As of Visual Studio 2019 version 16.2, Draft C++20 Standard modules aren't fully implemented in the Microsoft C++ compiler. You can use the modules feature to create single-partition modules and to 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 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.
 
 For more information on modules and how to use and create them, see [Overview of modules in C++](../../cpp/modules-cpp.md).
 

docs/build/reference/general-property-page-project.md

@@ -113,7 +113,7 @@ To programmatically access this property, see <xref:Microsoft.VisualStudio.VCPro
 
 ### C++ Language Standard
 
-Specifies which C++ language standard to use. The default is **`/std:c++14`**. Specify **`/std:c++17`** to use C++17 features, and **`/std:c++latest`** to use C++20 or other experimental features. For more information, see [`/std` (Specify language standard version)](std-specify-language-standard-version.md)
+Specifies which C++ language standard to use. The default is **`/std:c++14`**. Specify **`/std:c++17`** to use C++17 features, **`/std:c++20`** to use C++20 features, and **`/std:c++latest`** to use proposed C++23 features or other experimental features. For more information, see [`/std` (Specify language standard version)](std-specify-language-standard-version.md).
 
 ### C Language Standard
 

docs/build/reference/headername.md

@@ -23,9 +23,9 @@ The name of a header file that the compiler should compile into a header unit (*
 
 ## Remarks
 
-The **`/headerName`** compiler option is available starting in Visual Studio 2019 version 16.10 preview 2.
+The **`/headerName`** compiler option is available starting in Visual Studio 2019 version 16.10.
 
-The **`/headerName`** compiler option, in all its forms, requires the [/std:c++latest](std-specify-language-standard-version.md) option.\
+The **`/headerName`** compiler option, in all its forms, requires the [`/std:c++20`](std-specify-language-standard-version.md) or later compiler option (such as **`/std:c++latest`**).\
 If you specify **`/headerName:{quote,angle}`**, you must also specify [`/exportHeader`](module-exportheader.md).
 
 **`/headerName:quote`** looks up *`header-filename`* using the same rules as `#include "header-name"` and builds it as a header unit (*`.ifc`* file).\
@@ -39,14 +39,14 @@ Given a project that references a header file it defines called `m.h`, the compi
 cl /std:c++latest /exportHeader /headerName:quote m.h /Fom.h.obj
 ```
 
-The `/headerName:{quote,angle}`switch acts like a flag and does not explicitly need an argument. The following examples are valid:
+The `/headerName:{quote,angle}` option acts like a flag and does not explicitly need an argument. The following examples are valid:
 
 ```Bash
 cl /std:c++latest /exportHeader /headerName:angle /MP /Fo.\ vector iostream algorithm
 cl /std:c++latest /exportHeader /headerName:quote /MP /Fo.\ my-utilities.h a/b/my-core.h
 ```
 
-You can specify multiple `/headerName` switches on the same command line, and every argument after that switch will be processed with the specified *`header-filename`* lookup rules. The following example processes all the headers as the previous two command line examples in the same way. It looks up the headers using the lookup rules applied as if they had been specified as: `#include <vector>`, `#include "my-utilties.h"`, and `#include "a/b/my-core.h"`:
+You can specify multiple `/headerName` options on the same command line, and every argument after that option will be processed with the specified *`header-filename`* lookup rules. The following example processes all the headers as the previous two command line examples in the same way. It looks up the headers using the lookup rules applied as if they had been specified as: `#include <vector>`, `#include "my-utilties.h"`, and `#include "a/b/my-core.h"`:
 
 ```bash
 cl /std:c++latest /exportHeader /headerName:angle /MP /Fo.\ vector iostream algorithm /headerName:quote my-utilities.h a/b/my-core.h
@@ -55,7 +55,7 @@ cl /std:c++latest /exportHeader /headerName:angle /MP /Fo.\ vector iostream algo
 ### To set this compiler option in the Visual Studio development environment
 
 > [!NOTE]
-> Users don't typically set this command line switch. It is set by the build system.
+> Users don't typically set this command line option. It's set by the build system.
 
 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).
 

docs/build/reference/headerunit.md

@@ -27,11 +27,11 @@ The name of a file that contains compiled header unit information. To import mor
 
 ## Remarks
 
-The **`/headerUnit`** compiler option requires the [/std:c++latest](std-specify-language-standard-version.md) option.
+The **`/headerUnit`** compiler option requires the [`/std:c++20`](std-specify-language-standard-version.md) or later compiler option (such as **`/std:c++latest`**).
 
-The **`/headerUnit`** compiler option is available starting in Visual Studio 2019 version 16.10 preview 2.
+The **`/headerUnit`** compiler option is available starting in Visual Studio 2019 version 16.10.
 
-When the compiler comes across `import "file";` or `import <file>;`, this compiler switch helps the compiler find the compiled header unit (*`.ifc`*) for the specified header file. The path to this file can be expressed in three ways:
+When the compiler comes across `import "file";` or `import <file>;`, this compiler option helps the compiler find the compiled header unit (*`.ifc`*) for the specified header file. The path to this file can be expressed in three ways:
 
 **`/headerUnit`** looks up the compiled header unit in the current directory, or at the location specified in *`ifc-filename`*.
 
@@ -41,7 +41,7 @@ When the compiler comes across `import "file";` or `import <file>;`, this compil
 
 The compiler can't map a single *`header-name`* to multiple *`.ifc`* files. While mapping multiple *`header-name`* arguments to a single *`.ifc`* is possible, we don't recommend it. The contents of the *`.ifc`* get imported as if it was only the header specified by *`header-name`*.
 
-The compiler implicitly enables the new preprocessor when this switch is used. That is, [`/Zc:preprocessor`](zc-preprocessor.md) is added to the command line by the compiler if any form of `/headerUnit` is specified on the command line. To opt out of the implicit `/Zc:preprocessor`, specify: `/Zc:preprocessor-`
+The compiler implicitly enables the new preprocessor when this option is used. That is, [`/Zc:preprocessor`](zc-preprocessor.md) is added to the command line by the compiler if any form of `/headerUnit` is specified on the command line. To opt out of the implicit `/Zc:preprocessor`, specify: `/Zc:preprocessor-`
 
 If you disable the new preprocessor, but a file you compile imports a header unit, the compiler will report an error.
 

docs/build/reference/module-exportheader.md

@@ -23,13 +23,13 @@ The argument to `/exportHeader` is a `/headerName` command-line option that spec
 
 ## Remarks
 
-**`/exportHeader`** is available starting in Visual Studio 2019 version 16.10 Preview 2.
+**`/exportHeader`** is available starting in Visual Studio 2019 version 16.10.
 
-The **`/exportHeader`** compiler option requires you enable the [`/std:c++latest`](std-specify-language-standard-version.md) option.
+The **`/exportHeader`** compiler option requires you enable the [`/std:c++20`](std-specify-language-standard-version.md) or later compiler option (such as **`/std:c++latest`**).
 
 One **`/exportHeader`** compiler option can specify as many header-name arguments as your build requires. You don't need to specify them separately.
 
-The compiler implicitly enables the new preprocessor when this switch is used. That is, [`/Zc:preprocessor`](zc-preprocessor.md) is added to the command line by the compiler if any form of `/exportHeader` is used on the command line. To opt out of the implicit `/Zc:preprocessor`, use: `/Zc:preprocessor-`
+The compiler implicitly enables the new preprocessor when this option is used. That is, [`/Zc:preprocessor`](zc-preprocessor.md) is added to the command line by the compiler if any form of `/exportHeader` is used on the command line. To opt out of the implicit `/Zc:preprocessor`, use: `/Zc:preprocessor-`
 
 By default, the compiler doesn't produce an object file when a header unit is compiled. To produce an object file, specify the **`/Fo`** compiler option. For more information, see [`/Fo` (Object File Name)](fo-object-file-name.md).
 
@@ -57,7 +57,7 @@ You normally shouldn't set this in the Visual Studio development environment. It
 
 ## See also
 
-[`/headerName (Build a header unit from the specified header)`](headername.md) \
+[`/headerName (Build a header unit from the specified header)`](headername.md)\
 [`/headerUnit` (Use header unit IFC)](headerunit.md)\
 [`/reference` (Use named module IFC)](module-reference.md)\
 [`/translateInclude` (Translate include directives into import directives)](translateinclude.md)

docs/build/reference/module-reference.md

@@ -26,7 +26,7 @@ A valid name of an exported primary module interface unit name or full module pa
 
 In most cases you won't need to specify this switch because  the project system discovers module dependencies within a solution automatically.
 
-The **`/reference`** compiler option requires you enable the [/std:c++latest](std-specify-language-standard-version.md) option. The **`/reference`** option is available starting in Visual Studio 2019 version 16.10 Preview 2.
+The **`/reference`** compiler option requires you enable the [`/std:c++20`](std-specify-language-standard-version.md) or later compiler option (such as **`/std:c++latest`**). The **`/reference`** option is available starting in Visual Studio 2019 version 16.10.
 
 If the **`/reference`** argument is a *`filename`* without a *`module-name`*, the file gets opened at runtime to verify the *`filename`* argument names a specific import. It can result in slower runtime performance in scenarios that have many **`/reference`** arguments.
 

docs/build/reference/permissive-standards-conformance.md

@@ -21,9 +21,9 @@ The **`/permissive-`** option is supported in Visual Studio 2017 and later. **`/
 
 You can use the **`/permissive-`** compiler option to specify standards-conforming compiler behavior. This option disables permissive behaviors, and sets the [`/Zc`](zc-conformance.md) compiler options for strict conformance. In the IDE, this option also makes the IntelliSense engine underline non-conforming code.
 
-The **`/permissive-`** option uses the conformance support in the current compiler version to determine which language constructs are non-conforming. The option doesn't determine if your code conforms to a specific version of the C++ standard. To enable all implemented compiler support for the latest draft standard, use the [`/std:c++latest`](std-specify-language-standard-version.md) option. To restrict the compiler support to the currently implemented C++17 standard, use the [`/std:c++17`](std-specify-language-standard-version.md) option. To restrict the compiler support to more closely match the C++14 standard, use the [`/std:c++14`](std-specify-language-standard-version.md) option, which is the default.
+The **`/permissive-`** option uses the conformance support in the current compiler version to determine which language constructs are non-conforming. The option doesn't determine if your code conforms to a specific version of the C++ standard. To enable all implemented compiler support for the latest draft standard, use the [`/std:c++latest`](std-specify-language-standard-version.md) option. To restrict the compiler support to the currently implemented C++20 standard, use the [`/std:c++20`](std-specify-language-standard-version.md) option. To restrict the compiler support to the currently implemented C++17 standard, use the [`/std:c++17`](std-specify-language-standard-version.md) option. To restrict the compiler support to more closely match the C++14 standard, use the [`/std:c++14`](std-specify-language-standard-version.md) option, which is the default.
 
-Starting in Visual Studio 2019 version 16.8, the **`/std:c++latest`** option implicitly sets the **`/permissive-`** option. It's required for C++20 Modules support. Perhaps your code doesn't need modules support but requires other features enabled under **`/std:c++latest`**. You can explicitly enable Microsoft extension support by using the **`/permissive`** option without the trailing dash.
+The **`/permissive-`** option is implicitly set by the **`/std:c++latest`** option starting in Visual Studio 2019 version 16.8, and in version 16.11 by the **`/std:c++20`** option. **`/permissive-`** is required for C++20 Modules support. Perhaps your code doesn't need modules support but requires other features enabled under **`/std:c++20`** or **`/std:c++latest`**. You can explicitly enable Microsoft extension support by using the **`/permissive`** option without the trailing dash.
 
 By default, the **`/permissive-`** option is set in new projects created by Visual Studio 2017 version 15.5 and later versions. It's not set by default in earlier versions. When the option is set, the compiler generates diagnostic errors or warnings when non-standard language constructs are detected in your code. These constructs include some common bugs in pre-C++11 code.
 
@@ -261,7 +261,7 @@ auto y = cond ? 7 : int(a);
 auto z = cond ? A(7) : a;
 ```
 
-There's an important exception to this common pattern when T represents one of the null-terminated string types (for example, `const char *`, `const char16_t *`, and so on) and the actual argument to `?:` is a string literal of corresponding type. C++17 has changed semantics from C++14. As a result, the code in example 2 is accepted under **`/std:c++14`** and rejected under **`/std:c++17`** when **`/Zc:ternary`** or **`/permissive-`** is used.
+There's an important exception to this common pattern when T represents one of the null-terminated string types (for example, `const char *`, `const char16_t *`, and so on) and the actual argument to `?:` is a string literal of corresponding type. C++17 has changed semantics from C++14. As a result, the code in example 2 is accepted under **`/std:c++14`** and rejected under **`/std:c++17`** or later when **`/Zc:ternary`** or **`/permissive-`** is used.
 
 ```cpp
 // Example 2: exception from the above

docs/build/reference/sourcedependencies-directives.md

@@ -9,14 +9,14 @@ helpviewer_keywords: ["/sourceDependencies:directives compiler option", "/source
 ---
 # `/sourceDependencies:directives` (List module and header unit dependencies)
 
-This command-line switch generates a JSON file that lists module and header-unit dependencies.
+This command-line option generates a JSON file that lists module and header-unit dependencies.
 
 It identifies which modules and header units need to be compiled before the project that uses them is compiled. For instance, it will list `import <library>;` or `import "library";` as a header unit dependency, and `import name;` as a module dependency.
 
 This command-line option is similar to [`/sourceDependencies`](sourcedependencies.md), but differs in the following ways:
 
 - The compiler doesn't produce compiled output. Instead, the files are scanned for module directives. No compiled code, modules, or header units are produced.
-- The output JSON file doesn't list imported modules and imported header units (*`.ifc`* files) because this switch does a scan of the project files, not a compilation. So there are no built modules or header units to list.
+- The output JSON file doesn't list imported modules and imported header units (*`.ifc`* files) because this option does a scan of the project files, not a compilation. So there are no built modules or header units to list.
 - Only directly imported modules or header units are listed. It doesn't list the dependencies of the imported modules or header units themselves.
 - Header file dependencies are not listed. That is, `#include <file>` or `#include "file"` dependencies are not listed.
 - `/sourceDependencies:directives` is meant to be used before *`.ifc`* files are built.
@@ -40,7 +40,7 @@ If the argument is a directory, the compiler generates source dependency files i
 
 ## Remarks
 
-**`/sourceDependencies:directives`** is available starting in Visual Studio 2019 version 16.10 Preview 2. It's not enabled by default.
+**`/sourceDependencies:directives`** is available starting in Visual Studio 2019 version 16.10. It's not enabled by default.
 
 When you specify the **`/MP`** compiler option, we recommend you use **`/sourceDependencies`** with a directory argument. If you provide a single filename argument, two instances of the compiler may attempt to open the output file simultaneously and cause an error. For more information on **`/MP`**, see [`/MP` (Build with multiple processes)](mp-build-with-multiple-processes.md).