Merge pull request MicrosoftDocs#5074 from MicrosoftDocs/FromPublicMasterBranch

Confirm merge from FromPublicMasterBranch to main to sync with https://github.com/MicrosoftDocs/cpp-docs (branch main)

Author: PhilKang0704

docs/error-messages/compiler-errors-1/compiler-error-c2061.md

@@ -14,30 +14,54 @@ The compiler found an identifier where it wasn't expected. Make sure that `ident
 
 An initializer may be enclosed by parentheses. To avoid this problem, enclose the declarator in parentheses or make it a **`typedef`**.
 
-This error could also be caused when the compiler detects an expression as a class template argument; use [typename](../../cpp/typename.md) to tell the compiler it is a type.
+This error could also be caused when the compiler detects an expression as a class template argument; use [typename](../../cpp/typename.md) to tell the compiler it is a type, as shown in the following example:
 
 The following sample generates C2061:
 
 ```cpp
 // C2061.cpp
-// compile with: /c
-template < A a >   // C2061
-// try the following line instead
-// template < typename b >
-class c{};
+// compile with: /std:c++17
+
+template <A a> // C2061
+class C1 {};
+
+template <typename A a> // ok
+class C2 {};
+
+template <typename T>
+class C3
+{
+   // Both are valid since C++20
+   using Type1 = T::Type; // C2061
+   using Type2 = typename T::Type; // OK
+};
+
+int main()
+{
+   int x;
+   unsigned a1 = alignof(x);   // C2061
+   unsigned a2 = alignof(int); // OK
+   unsigned a3 = alignof(decltype(x)); // OK
+}
 ```
 
+To resolve the error with `template<A a> class C1{};`, use `template <typename a> class C1 {};`\
+To resolve the issue with `using Type1 = T::Type;`, use `using Type1 = typename T::Type;`\
+To resolve the issue with `alignof(x)`, replace the argument with the type of `x`. In this case, `int` or `decltype(x);`
+
 C2061 can occur if you pass an instance name to [typeid](../../extensions/typeid-cpp-component-extensions.md):
 
 ```cpp
 // C2061b.cpp
 // compile with: /clr
-ref struct G {
+ref struct G
+{
    int i;
 };
 
-int main() {
-   G ^ pG = gcnew G;
+int main()
+{
+   G ^pG = gcnew G;
    System::Type ^ pType = typeid<pG>;   // C2061
    System::Type ^ pType2 = typeid<G>;   // OK
 }

docs/error-messages/compiler-errors-2/compiler-error-c2993.md

@@ -1,43 +1,51 @@
 ---
 description: "Learn more about: Compiler Error C2993"
 title: "Compiler Error C2993"
-ms.date: "11/04/2016"
+ms.date: "10/03/2023"
 f1_keywords: ["C2993"]
 helpviewer_keywords: ["C2993"]
-ms.assetid: 4ffd2b78-654b-46aa-95a6-b62101cf91c8
 ---
 # Compiler Error C2993
 
 'identifier' : illegal type for non-type template parameter 'parameter'
 
-You cannot declare a template with a structure or union argument. Use pointers to pass structures and unions as template parameters.
+- Prior to C++20, you cannot declare a template with a structure, class, or union argument. Pointers can be used in place of these types as template parameters.
+- Since C++20, structure, class, or unions *can* be used as non-type template parameters. A non-type template parameter can't be a rvalue reference type or a parameter pack of rvalue types.
 
 The following sample generates C2993:
 
 ```cpp
-// C2993.cpp
-// compile with: /c
-// C2993 expected
-struct MyStruct {
-   int a;char b;
-};
-
-template <class T, struct MyStruct S>   // C2993
-
-// try the following line instead
-// template <class T, struct MyStruct * S>
-class CMyClass {};
+// compile with: /c and /std:c++17
+template <int&& I>   // C2993
+struct S1 {};
+
+template <int&&... Is>   // C2993
+struct S2 {};
+```
+
+Before MSVC 19.26, the following code emitted C2993. It now emits C7582:
+
+```cpp
+// compile with: /c /std:c++17
+struct MyStruct {};
+
+template <class T, MyStruct S>   // Was C2993 prior to MSVC 19.26. Now emits C7582.
+class MyClass1 {};
+
+template <class T, MyStruct* S>   // OK
+class MyClass2 {};
 ```
 
-This error will also be generated as a result of compiler conformance work that was done in Visual Studio .NET 2003: floating point non-type template parameters no longer allowed. The C++ standard does not allow floating point non-type template parameters.
+With C++17 and earlier, you can't have floating point non-type template parameters. Since C++20, floating point non-type template parameters are allowed. Use a function argument to pass the floating point non-type template parameter to function templates.
 
-If it is a function template, use a function argument to pass in the floating point non-type template parameter (this code will be valid in the Visual Studio .NET 2003 and Visual Studio .NET versions of Visual C++). If it is a class template, there is no easy workaround.
+Before MSVC 19.26, the following code emitted C2993. It now emits C7582:
 
 ```cpp
 // C2993b.cpp
-// compile with: /c
-template<class T, float f> void func(T) {}   // C2993
+// compile with: /c /std:c++17
+template<class T, float F>   // Was C2993 prior to MSVC 19.26. Now emits C7592
+void func1(T t) {}
 
-// OK
-template<class T>   void func2(T, float) {}
+template<class T>   // OK
+void func2(T t, float F) {}
 ```