[Sema] Prevent InstantiateClass from checking unrelated exception specs.

[vsapsai]

Summary

Sema::InstantiateClass should check only exception specs added during
class instantiation and ignore already present delayed specs. This fixes
a case where we instantiate a class before parsing member initializers,
check exceptions for a different class and fail to find a member
initializer. Which is required for comparing exception specs for
explicitly-defaulted and implicit default constructor. With the fix we
are still checking exception specs but only after member initializers
are present.

Removing errors in crash-unparsed-exception.cpp is acceptable according
to discussion in PR24000 because other compilers accept code in
crash-unparsed-exception.cpp as valid.

rdar://problem/34167492

Cc Dimitry Andric due to participation in discussion about PR24000.

[vsapsai]

I don't like name SavePendingDelayedStateRAII as too vague. Hope you'll be able to suggest something better or I'll have better ideas later.

[rsmith]

In D37881#871556, @vsapsai wrote:

I don't like name SavePendingDelayedStateRAII as too vague. Hope you'll be able to suggest something better or I'll have better ideas later.

I like everything about this patch other than the name of the class :)

I think we need to clearly identify what state we're saving here and why. It's the state that is pending from a class that we're currently in the middle of parsing, so how about something like SavePendingParsedClassStateRAII?

[vsapsai]

Thanks for review.

In D37881#875574, @rsmith wrote:

I think we need to clearly identify what state we're saving here and why. It's the state that is pending from a class that we're currently in the middle of parsing, so how about something like SavePendingParsedClassStateRAII?

Agree with suggested name, will use it and will clarify comment about "Some delayed state".

[vsapsai]

• Rename SavePendingDelayedStateRAII to SavePendingParsedClassStateRAII.

clang/include/clang/Sema/Sema.h

static bool TooManyArguments(size_t NumParams, size_t NumArgs,
     return NumArgs > NumParams;
   }
 
   // Emitting members of dllexported classes is delayed until the class
   // (including field initializers) is fully parsed.
   SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses;
 
 private:
+  class SavePendingDelayedStateRAII {
+  public:
+    SavePendingDelayedStateRAII(Sema &S) : S(S) { swapSavedState(); }
+
+    ~SavePendingDelayedStateRAII() {
+      assert(S.DelayedExceptionSpecChecks.empty() &&
+             "there shouldn't be any pending delayed exception spec checks");
+      assert(S.DelayedDefaultedMemberExceptionSpecs.empty() &&
+             "there shouldn't be any pending delayed defaulted member "
+             "exception specs");
+      assert(S.DelayedDllExportClasses.empty() &&
+             "there shouldn't be any pending delayed DLL export classes");
+      swapSavedState();
+    }
+
+  private:
+    Sema &S;
+    decltype(DelayedExceptionSpecChecks) SavedExceptionSpecChecks;
+    decltype(DelayedDefaultedMemberExceptionSpecs)
+        SavedDefaultedMemberExceptionSpecs;
+    decltype(DelayedDllExportClasses) SavedDllExportClasses;
+
+    void swapSavedState() {
+      SavedExceptionSpecChecks.swap(S.DelayedExceptionSpecChecks);
+      SavedDefaultedMemberExceptionSpecs.swap(
+          S.DelayedDefaultedMemberExceptionSpecs);
+      SavedDllExportClasses.swap(S.DelayedDllExportClasses);
+    }
+  };
+
   /// \brief Helper class that collects misaligned member designations and
   /// their location info for delayed diagnostics.
   struct MisalignedMember {
     Expr *E;
     RecordDecl *RD;
     ValueDecl *MD;
     CharUnits Alignment;
 

clang/lib/Sema/SemaTemplateInstantiate.cpp

EnterExpressionEvaluationContext EvalContext(
       *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
 
   // If this is an instantiation of a local class, merge this local
   // instantiation scope with the enclosing scope. Otherwise, every
   // instantiation of a class has its own local instantiation scope.
   bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod();
   LocalInstantiationScope Scope(*this, MergeWithParentScope);
 
-  // All dllexported classes created during instantiation should be fully
-  // emitted after instantiation completes. We may not be ready to emit any
-  // delayed classes already on the stack, so save them away and put them back
-  // later.
-  decltype(DelayedDllExportClasses) ExportedClasses;
-  std::swap(ExportedClasses, DelayedDllExportClasses);
+  // Some delayed state created during instantiation should be fully processed
+  // after instantiation completes. We may not be ready to handle any delayed
+  // state already on the stack, so save it now and put it back later.
+  SavePendingDelayedStateRAII SavedPendingDelayedState(*this);
 
   // Pull attributes from the pattern onto the instantiation.
   InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
 
   // Start the definition of this instantiation.
   Instantiation->startDefinition();
 
   // The instantiation is visible here, even if it was first declared in an
Sema::InstantiateClass(SourceLocation PointOfInstantiation,
   ActOnFields(nullptr, Instantiation->getLocation(), Instantiation, Fields,
               SourceLocation(), SourceLocation(), nullptr);
   CheckCompletedCXXClass(Instantiation);
 
   // Default arguments are parsed, if not instantiated. We can go instantiate
   // default arg exprs for default constructors if necessary now.
   ActOnFinishCXXNonNestedClass(Instantiation);
 
-  // Put back the delayed exported classes that we moved out of the way.
-  std::swap(ExportedClasses, DelayedDllExportClasses);
-
   // Instantiate late parsed attributes, and attach them to their decls.
   // See Sema::InstantiateAttrs
   for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
        E = LateAttrs.end(); I != E; ++I) {
     assert(CurrentInstantiationScope == Instantiator.getStartingScope());
     CurrentInstantiationScope = I->Scope;
 
     // Allow 'this' within late-parsed attributes.

clang/test/SemaTemplate/crash-unparsed-exception.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify -fcxx-exceptions -fexceptions %s
+// expected-no-diagnostics
 
 struct A {
   virtual ~A();
 };
 template <class>
 struct B {};
 struct C {
   template <typename>
   struct D {
     ~D() throw();
   };
   struct E : A {
-    D<int> d; //expected-error{{exception specification is not available until end of class definition}}
+    D<int> d;
   };
-  B<int> b; //expected-note{{in instantiation of template class 'B<int>' requested here}}
+  B<int> b;
 };

clang/test/SemaTemplate/default-arguments-cxx0x.cpp

 namespace PR13986 {
   constexpr unsigned Dynamic = 0;
   template <unsigned> class A { template <unsigned = Dynamic> void m_fn1(); };
   class Test {
     ~Test() {}
     A<1> m_target;
   };
 }
+
+// rdar://problem/34167492
+// Template B is instantiated during checking if defaulted A copy constructor
+// is constexpr. For this we check if S<int> copy constructor is constexpr. And
+// for this we check S constructor template with default argument that mentions
+// template B. In  turn, template instantiation triggers checking defaulted
+// members exception spec. The problem is that it checks defaulted members not
+// for instantiated class only, but all defaulted members so far. In this case
+// we try to check exception spec for A default constructor which requires
+// initializer for the field _a. But initializers are added after constexpr
+// check so we reject the code because cannot find _a initializer.
+namespace rdar34167492 {
+  template <typename T> struct B { using type = bool; };
+
+  template <typename T> struct S {
+    S() noexcept;
+
+    template <typename U, typename B<U>::type = true>
+    S(const S<U>&) noexcept;
+  };
+
+  class A {
+    A() noexcept = default;
+    A(const A&) noexcept = default;
+    S<int> _a{};
+  };
+}