Fixes per comments

Author: Colin Robertson

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

@@ -53,13 +53,13 @@ By default, the **/permissive-** option is not set. When the option is set, the
 
 The **/permissive-** option sets the [/Zc:strictStrings](../../build/reference/zc-conformance.md) and [/Zc:rvalueCast](../../build/reference/zc-conformance.md) options to conforming behavior. They default to non-conforming behavior. You can pass specific **/Zc** options after **/permissive-** on the command line to override this behavior.  
 
-In versions of the compiler beginning in Visual Studio 2017 Update 3, the **/permissive-** option sets the [/Zc:ternary]() option. The compiler also implements more of the requirements for two-phase name look-up. When the **/permissive-** option is set, the compiler parses function and class template definitions, identifying dependent and non-dependent names used in the templates. In this release, only name dependency analysis is performed.  
+In versions of the compiler beginning in Visual Studio 2017 Update Version 15.3, the **/permissive-** option sets the [/Zc:ternary]() option. The compiler also implements more of the requirements for two-phase name look-up. When the **/permissive-** option is set, the compiler parses function and class template definitions, identifying dependent and non-dependent names used in the templates. In this release, only name dependency analysis is performed.  
 
 Environment-specific extensions and language areas that the standard leaves up to the implementation are not affected by **/permissive-**. For example, the Microsoft-specific `__declspec`, calling convention and structured exception handling keywords, and compiler-specific pragma directives or attributes are not flagged by the compiler in **/permissive-** mode.  
 
-The **/permissive-** option uses the conformance support in the current compiler version to determine which language constructs are non-conforming. The option does not 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:latest](../../build/reference/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](../../build/reference/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 does not 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:latest](../../build/reference/std-specify-language-standard-version.md) option. To restrict the compiler support to the currently implemented C++17 standard, use the [/std:c++17](../../build/reference/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](../../build/reference/std-specify-language-standard-version.md) option, which is the default.  
 
-Not all C++11, C++14, or draft C++17 standards-conforming code is supported by the Visual C++ compiler in Visual Studio 2017. The **/permissive-** option may not detect issues regarding two-phase name lookup, binding a non-const reference to a temporary, treating copy init as direct init, allowing multiple user-defined conversions in initialization, or alternative tokens for logical operators, and other non-supported conformance areas. For more information about conformance issues in Visual C++, see [Nonstandard Behavior](../../cpp/nonstandard-behavior.md).  
+Not all C++11, C++14, or C++17 standards-conforming code is supported by the Visual C++ compiler in Visual Studio 2017. The **/permissive-** option may not detect issues regarding some aspects of two-phase name lookup, binding a non-const reference to a temporary, treating copy init as direct init, allowing multiple user-defined conversions in initialization, or alternative tokens for logical operators, and other non-supported conformance areas. For more information about conformance issues in Visual C++, see [Nonstandard Behavior](../../cpp/nonstandard-behavior.md).  
 
 ### How to fix your code
 Here are some examples of code that is detected as non-conforming when you use **/permissive-**, along with suggested ways to fix the issues.
@@ -238,7 +238,7 @@ class ATL_NO_VTABLE CFooImpl : public ICustom,
   
 #### Ambiguous conditional operator arguments  
   
-In versions of the compiler before Visual Studio 2017 Update 3, the compiler accepted arguments to the conditional operator (or ternary operator) `?:` that are considered ambiguous by the C++17 standard. In **/permissive-** mode, the compiler now issues one or more diagnostics in cases that compiled without diagnostics in earlier versions.  
+In versions of the compiler before Visual Studio 2017 Update Version 15.3, the compiler accepted arguments to the conditional operator (or ternary operator) `?:` that are considered ambiguous by the Standard. In **/permissive-** mode, the compiler now issues one or more diagnostics in cases that compiled without diagnostics in earlier versions.  
   
 Commmon errors that may result from this change include:  
   
@@ -264,13 +264,13 @@ extern bool cond;
  
 A a(42); 
 // Accepted when /Zc:ternary or /permissive- is not used: 
-auto x = cond ? 7 : a; // A: permissive prefers A(7) over (int)a 
+auto x = cond ? 7 : a; // A: permissive behavior prefers A(7) over (int)a 
 // Accepted always: 
 auto y = cond ? 7 : int(a); 
 auto z = cond ? A(7) : a; 
 ```  
 
-There is 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 is 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.  
 
 ```cpp  
 // Example 2: exception from the above 
@@ -279,11 +279,15 @@ struct MyString
     MyString(const char* s = "") noexcept;  // from char* 
     operator const char* () const noexcept; //   to char* 
 }; 
+
+extern bool cond;
 
 MyString s; 
-// Accepted when /Zc:ternary or /permissive- is not used: 
-auto x = cond ? "A" : s; // MyString: permissive prefers MyString("A") over (const char*)s 
-// Accepted always:
+// Using /std:c++14, /permissive- or /Zc:ternary behavior 
+// is to prefer MyString("A") over (const char*)s
+// but under /std:c++17 this line causes error C2445:
+auto x = cond ? "A" : s;  
+// You can use a static_cast to resolve the ambiguity:
 auto y = cond ? "A" : static_cast<const char*>(s); 
 ```  
   
@@ -293,48 +297,50 @@ Another case where you may see errors is in conditional optators with one argume
 // Example 3: void arguments 
 void myassert(const char* text, const char* file, int line); 
 // Accepted when /Zc:ternary or /permissive- is not used: 
-#define ASSERT(ex) (void)((ex) ? 0 : myassert(#ex, __FILE__, __LINE__)) 
+#define ASSERT_A(ex) (void)((ex) ? 1 : myassert(#ex, __FILE__, __LINE__)) 
 // Accepted always:
-#define ASSERT(ex) (void)((ex) ? void() : myassert(#ex, __FILE__, __LINE__)) 
+#define ASSERT_B(ex) (void)((ex) ? void() : myassert(#ex, __FILE__, __LINE__)) 
 ```  
 
-You may also see errors in template metaprogramming, where conditional operator result types may change under **/Zc:ternary** and **/permissive-**. One way to resolve this issue is to use `std::remove_reference` on the resulting type.  
+You may also see errors in template metaprogramming, where conditional operator result types may change under **/Zc:ternary** and **/permissive-**. One way to resolve this issue is to use [std::remove_reference](../../standard-library/remove-reference-class.md) on the resulting type.  
 
 ```cpp  
 // Example 4: different result types 
+extern bool cond;
+extern int count;
 char  a = 'A'; 
 const char  b = 'B'; 
 decltype(auto) x = cond ? a : b; // char without, const char& with /Zc:ternary 
-const char (&z)[2] = argc > 3 ? "A" : "B"; // const char* without /Zc:ternary 
+const char (&z)[2] = count > 3 ? "A" : "B"; // const char* without /Zc:ternary 
 ```  
   
-#### Name dependency analysis  
+#### Two-phase name look up (partial)  
   
-When the **/permissive-** option is set in Visual Studio 2017 Update 3, the compiler parses function and class template definitions, identifying dependent and non-dependent names used in templates as required for two-phase name look-up. In this release, only name dependency analysis is performed. In particular, non-dependent names that are not declared in the context of a template definition cause a diagnostic message as required by the ISO C++ standards. However, binding of non-dependent names that require argument dependent look up in the definition context is not done.  
+When the **/permissive-** option is set in Visual Studio 2017 Update Version 15.3, the compiler parses function and class template definitions, identifying dependent and non-dependent names used in templates as required for two-phase name look-up. In this release, only name dependency analysis is performed. In particular, non-dependent names that are not declared in the context of a template definition cause a diagnostic message as required by the ISO C++ standards. However, binding of non-dependent names that require argument dependent look up in the definition context is not done.  
   
 ```cpp 
-// dependency.cpp 
-// For previous behavior, compile with: cl /W4 dependency.cpp
-// For name dependency analysis, compile with: cl /W4 /permissive- dependency.cpp
-#include <stdio.h>
-
-void f(long) {
-    puts("Standard two-phase name dependency");
-}
-
-template <typename T> void g(T t) {
-    f(t);
-}
+// dependent base
+struct B {
+    void g();
+};
 
-void f(int) {
-    puts("Microsoft one-phase name dependency");
-}
+template<typename T>
+struct D : T {
+void f() {
+        // The call to g was incorrectly allowed in VS2017:
+        g();  // Now under /permissive-: C3861 
+        // Possible fixes:
+        // this->g();
+        // T::g();
+    }
+};
 
-int main() {
-    g(42);
+int main()
+{
+	D<B> d;
+	d.f();
 }
 ```  
-
 
 ### To set this compiler option in the Visual Studio development environment  
 

docs/build/reference/std-specify-language-standard-version.md

@@ -22,13 +22,14 @@ Enable supported C++ language features from the specified version of the C++ lan
 ## Syntax  
 
 ```  
-/std:[c++14|c++latest]  
+/std:[c++14|c++17|c++latest]  
 ```  
 
 ## Remarks  
- The **/std** option is used to control the version-specific ISO C++ programming language standard features enabled during compilation of your code. This option allows you to disable support for certain new language and library features that may break your existing code that conforms to a particular version of the language standard. By default, **/std:c++14** is specified, which disables language and standard library features found in later versions of the C++ language standard. To explicitly enable the latest supported compiler and standard library features, use **/std:c++latest**.  
 
- The default **/std:c++14** option enables the set of C++14 features implemented by the Visual C++ compiler. This option disables compiler and standard library support for features that are changed or new in more recent versions of the language standard, with the exception of some C++17 features already implemented in previous releases of the Visual C++ compiler. To avoid breaking changes for users who have already taken dependencies on the features available as of Visual Studio 2015 Update 2, these features remain enabled when the **/std:c++14** option is specified:  
+The **/std** option is used to control the version-specific ISO C++ programming language standard features enabled during compilation of your code. This option allows you to disable support for certain new language and library features that may break your existing code that conforms to a particular version of the language standard. By default, **/std:c++14** is specified, which disables language and standard library features found in later versions of the C++ language standard. To explicitly enable the latest supported compiler and standard library features, use **/std:c++latest**.  
+  
+The default **/std:c++14** option enables the set of C++14 features implemented by the Visual C++ compiler. This option disables compiler and standard library support for features that are changed or new in more recent versions of the language standard, with the exception of some C++17 features already implemented in previous releases of the Visual C++ compiler. To avoid breaking changes for users who have already taken dependencies on the features available as of Visual Studio 2015 Update 2, these features remain enabled when the **/std:c++14** option is specified:  
 
 -   [Rules for auto with braced-init-lists](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3922.html)  
 
@@ -40,9 +41,11 @@ Enable supported C++ language features from the specified version of the C++ lan
 
 -   [u8 character literals](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4267.html)  
 
- The **/std:c++latest** option enables the set of C++ language and library features implemented by Visual C++ to track the most recent Working Draft and defect updates of the C++ Standard. Use this switch to get the latest language features supported by the compiler. For a list of supported language and library features, see [What's New for Visual C++](../../what-s-new-for-visual-cpp-in-visual-studio.md). The **/std:c++latest** option does not enable features guarded by the **/experimental** switch.  
+The **/std:c++17** option enables the set of C++17 features implemented by the Visual C++ compiler. This option disables compiler and standard library support for features that are changed or new in more recent versions of the Working Draft and defect updates of the C++ Standard.  
+  
+The **/std:c++latest** option enables the set of C++ language and library features implemented by Visual C++ to track the most recent Working Draft and defect updates of the C++ Standard. Use this switch to get the latest language features supported by the compiler. For a list of supported language and library features, see [What's New for Visual C++](../../what-s-new-for-visual-cpp-in-visual-studio.md). The **/std:c++latest** option does not enable features guarded by the **/experimental** switch.  
 
- The **/std:c++14** and **/std:c++latest** options are available beginning in Visual C++ 2015 Update 3.  
+The **/std:c++14** and **/std:c++latest** options are available beginning in Visual C++ 2015 Update 3. The **/std:c++17** option is available beginning in Visual C++ 2017 Update Version 15.3.  
 
 > [!NOTE]
 >  Depending on the Visual C++ compiler version or update level, certain C++14 features may not be fully implemented or fully conformant when you specify the **/std:c++14** option. For example, the Visual C++ 2017 RTM compiler does not fully support C++14-conformant `constexpr`, expression SFINAE, or 2-phase name lookup. For an overview of C++ language conformance in Visual C++, see [Visual C++ Language Conformance](../../visual-cpp-language-conformance.md). 
@@ -56,5 +59,6 @@ Enable supported C++ language features from the specified version of the C++ lan
 3.  In **Additional Options**, enter **/std:c++latest** to enable the latest language feature support, or **/std:c++14** to disable it and use only C++14 language features.  
 
 ## See Also  
- [Compiler Options](../../build/reference/compiler-options.md)   
- [Setting Compiler Options](../../build/reference/setting-compiler-options.md)
+  
+[Compiler Options](../../build/reference/compiler-options.md)   
+[Setting Compiler Options](../../build/reference/setting-compiler-options.md)