Move EH spec mismatches under -fms-compatibility

[rnk]

Summary

-fms-extensions is intended to enable conforming language extensions and
-fms-compatibility is intended to language rule relaxations, so a user
could plausibly compile with -fno-ms-compatibility on Windows while
still using dllexport, for example. This exception specification
validation behavior has been handled as a warning since before
-fms-compatibility was added in 2011. I think it's just an oversight
that it hasn't been moved yet.

This will help users find conformance issues in their code such as those
found in _com_ptr_t as described in https://llvm.org/PR42842.

[STL_MSFT]

This will definitely help us clean up our code, since we run the MSVC STL test suite with -fno-ms-compatibility -fno-delayed-template-parsing.

Other possible occurrences of ms-extensions that should be considered ms-compatibility:

• ParseDeclCXX.cpp says "MSVC permits pure specifier on inline functions defined at class scope." which sounds like a rule relaxation.
• Parser.cpp says "MS compatibility: MSVC permits using known types with typename. e.g. "typedef typename T* pointer_type"" while downgrading an error to a warning. Seems like this should be ms-compatibility.
• SemaCast.cpp says "C++ 5.2.10p4: A pointer can be explicitly converted to any integral type large enough to hold it; except in Microsoft mode, where the integral type size doesn't matter (except we don't allow bool)." This definitely seems like ms-compatibility.
• ParseExprCXX.cpp says "We have something like t::getAs<T>, where getAs is a member of an unknown specialization. However, this will only parse correctly as a template, so suggest the keyword 'template' before 'getAs' and treat this as a dependent template name." while downgrading an error to a warning.

I might regret asking about some of these, if Clang begins erroring on WinSDK etc. code that can't be rapidly updated.

[hans]

lgtm

clang/lib/Sema/SemaExceptionSpec.cpp

bool Sema::CheckSpecifiedExceptionType(QualType &T, SourceRange Range) {
   //   A type denoted in an exception-specification shall not denote an
   //   incomplete type other than a class currently being defined [...].
   //   A type denoted in an exception-specification shall not denote a
   //   pointer or reference to an incomplete type, other than (cv) void* or a
   //   pointer or reference to a class currently being defined.
   // In Microsoft mode, downgrade this to a warning.
   unsigned DiagID = diag::err_incomplete_in_exception_spec;
   bool ReturnValueOnError = true;
-  if (getLangOpts().MicrosoftExt) {
+  if (getLangOpts().MSVCCompat) {
     DiagID = diag::ext_incomplete_in_exception_spec;
     ReturnValueOnError = false;
   }
   if (!(PointeeT->isRecordType() &&
         PointeeT->getAs<RecordType>()->isBeingDefined()) &&
       RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range))
     return ReturnValueOnError;
 
bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {
 
   OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator();
   bool IsOperatorNew = OO == OO_New || OO == OO_Array_New;
   bool MissingExceptionSpecification = false;
   bool MissingEmptyExceptionSpecification = false;
 
   unsigned DiagID = diag::err_mismatched_exception_spec;
   bool ReturnValueOnError = true;
-  if (getLangOpts().MicrosoftExt) {
+  if (getLangOpts().MSVCCompat) {
     DiagID = diag::ext_mismatched_exception_spec;
     ReturnValueOnError = false;
   }
 
   // If we're befriending a member function of a class that's currently being
   // defined, we might not be able to work out its exception specification yet.
   // If not, defer the check until later.
   if (exceptionSpecNotKnownYet(Old) || exceptionSpecNotKnownYet(New)) {
bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {
   } else {
     // Update the type of the function with the appropriate exception
     // specification.
     New->setType(Context.getFunctionType(
         NewProto->getReturnType(), NewProto->getParamTypes(),
         NewProto->getExtProtoInfo().withExceptionSpec(ESI)));
   }
 
-  if (getLangOpts().MicrosoftExt && ESI.Type != EST_DependentNoexcept) {
+  if (getLangOpts().MSVCCompat && ESI.Type != EST_DependentNoexcept) {
     // Allow missing exception specifications in redeclarations as an extension.
     DiagID = diag::ext_ms_missing_exception_specification;
     ReturnValueOnError = false;
   } else if (New->isReplaceableGlobalAllocationFunction() &&
              ESI.Type != EST_DependentNoexcept) {
     // Allow missing exception specifications in redeclarations as an extension,
     // when declaring a replaceable global allocation function.
     DiagID = diag::ext_missing_exception_specification;

 /// that is achieved. See C++ [except.spec]p2.
 bool Sema::CheckEquivalentExceptionSpec(
     const FunctionProtoType *Old, SourceLocation OldLoc,
     const FunctionProtoType *New, SourceLocation NewLoc) {
   if (!getLangOpts().CXXExceptions)
     return false;
 
   unsigned DiagID = diag::err_mismatched_exception_spec;
-  if (getLangOpts().MicrosoftExt)
+  if (getLangOpts().MSVCCompat)
     DiagID = diag::ext_mismatched_exception_spec;
   bool Result = CheckEquivalentExceptionSpecImpl(
       *this, PDiag(DiagID), PDiag(diag::note_previous_declaration),
       Old, OldLoc, New, NewLoc);
 
   // In Microsoft mode, mismatching exception specifications just cause a warning.
-  if (getLangOpts().MicrosoftExt)
+  if (getLangOpts().MSVCCompat)
     return false;
   return Result;
 }
 
 /// CheckEquivalentExceptionSpec - Check if the two types have compatible
 /// exception specifications. See C++ [except.spec]p3.
 ///
 /// \return \c false if the exception specifications match, \c true if there is
bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
   // perform this check when we get to the end of the outermost
   // lexically-surrounding class.
   if (exceptionSpecNotKnownYet(Old) || exceptionSpecNotKnownYet(New)) {
     DelayedOverridingExceptionSpecChecks.push_back({New, Old});
     return false;
   }
 
   unsigned DiagID = diag::err_override_exception_spec;
-  if (getLangOpts().MicrosoftExt)
+  if (getLangOpts().MSVCCompat)
     DiagID = diag::ext_override_exception_spec;
   return CheckExceptionSpecSubset(PDiag(DiagID),
                                   PDiag(diag::err_deep_exception_specs_differ),
                                   PDiag(diag::note_overridden_virtual_function),
                                   PDiag(diag::ext_override_exception_spec),
                                   Old->getType()->getAs<FunctionProtoType>(),
                                   Old->getLocation(),
                                   New->getType()->getAs<FunctionProtoType>(),

clang/test/CodeGenCXX/pr18661.cpp

-// RUN: %clang_cc1 %s -triple %itanium_abi_triple -fcxx-exceptions -fms-extensions -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 %s -triple %itanium_abi_triple -fcxx-exceptions -fms-compatibility -emit-llvm -o - | FileCheck %s
 
 extern "C" {
   void f();
 
   // In MS mode we don't validate the exception specification.
   void f() throw() {
   }
 }
 
 // PR18661: Clang would fail to emit function definition with mismatching
 // exception specification, even though it was just treated as a warning.
 
 // CHECK: define {{.*}}void @f()

clang/test/SemaCXX/MicrosoftCompatibility.cpp

 // This could confuse name lookup in cases such as this
 template<typename T>
 size_t ConfuseLookup<T>::m_val::ms_test
   = size_t(&(char&)(reinterpret_cast<ConfuseLookup<T>*>(0)->m_val));
 
 void instantiate() { ConfuseLookup<int>::m_val::ms_test = 1; }
 }
 
+
+// Microsoft doesn't validate exception specification.
+namespace microsoft_exception_spec {
+
+void foo(); // expected-note {{previous declaration}}
+void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}}
+
+void r6() throw(...); // expected-note {{previous declaration}}
+void r6() throw(int); // expected-warning {{exception specification in declaration does not match previous declaration}}
+
+struct Base {
+  virtual void f2();
+  virtual void f3() throw(...);
+};
+
+struct Derived : Base {
+  virtual void f2() throw(...);
+  virtual void f3();
+};
+
+class A {
+  virtual ~A() throw();
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{overridden virtual function is here}}
+#endif
+};
+
+class B : public A {
+  virtual ~B();
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{exception specification of overriding function is more lax than base version}}
+#endif
+};
+
+}
+
+namespace PR25265 {
+struct S {
+  int fn() throw(); // expected-note {{previous declaration is here}}
+};
+
+int S::fn() { return 0; } // expected-warning {{is missing exception specification}}
+}
+

clang/test/SemaCXX/MicrosoftExtensions.cpp

 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
 // RUN: %clang_cc1 -std=c++98 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
 // RUN: %clang_cc1 -std=c++11 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fexceptions -fcxx-exceptions -DTEST2
 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -fms-compatibility -verify -DTEST3
 
 #if TEST1
 
-// Microsoft doesn't validate exception specification.
-namespace microsoft_exception_spec {
-
-void foo(); // expected-note {{previous declaration}}
-void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}}
-
-void r6() throw(...); // expected-note {{previous declaration}}
-void r6() throw(int); // expected-warning {{exception specification in declaration does not match previous declaration}}
-
-struct Base {
-  virtual void f2();
-  virtual void f3() throw(...);
-};
-
-struct Derived : Base {
-  virtual void f2() throw(...);
-  virtual void f3();
-};
-
-class A {
-  virtual ~A() throw();
-#if __cplusplus <= 199711L
-  // expected-note@-2 {{overridden virtual function is here}}
-#endif
-};
-
-class B : public A {
-  virtual ~B();
-#if __cplusplus <= 199711L
-  // expected-warning@-2 {{exception specification of overriding function is more lax than base version}}
-#endif
-};
-
-}
-
 // MSVC allows type definition in anonymous union and struct
 struct A
 {
   union
   {
     int a;
     struct B  // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
     {

 template <typename TX> struct A {
   template <bool> struct largest_type_select;
   template <> struct largest_type_select<false> {
     blah x;  // expected-error {{unknown type name 'blah'}}
   };
 };
 }
 
-namespace PR25265 {
-struct S {
-  int fn() throw(); // expected-note {{previous declaration is here}}
-};
-
-int S::fn() { return 0; } // expected-warning {{is missing exception specification}}
-}
-
 class PR34109_class {
   PR34109_class() {}
   virtual ~PR34109_class() {}
 };
 
 void operator delete(void *) throw();
 // expected-note@-1 {{previous declaration is here}}
 __declspec(dllexport) void operator delete(void *) throw();

clang/test/SemaCXX/ms-exception-spec.cpp

-// RUN: %clang_cc1 %s -fsyntax-only -verify -fms-extensions -fexceptions -fcxx-exceptions
+// RUN: %clang_cc1 %s -fsyntax-only -verify -fms-compatibility -fexceptions -fcxx-exceptions
 
 void f() throw(...) { }
 
 namespace PR28080 {
 struct S;           // expected-note {{forward declaration}}
 void fn() throw(S); // expected-warning {{incomplete type}} expected-note{{previous declaration}}
 void fn() throw();  // expected-warning {{does not match previous declaration}}
 }