[clang] Don't crash on an incomplete-type base specifier in template context.

[sammccall]

clang/test/SemaCXX/base-class-ambiguity-check.cpp

15

maybe put (dependent) in this comment, as it's the reason this code is valid without diagnostics

17

we're asserting here there are no diagnostics, maybe instantiate the template and assert those?

clang/test/SemaCXX/ms-interface.cpp

114

is there some tricky interaction with __interface here that justifies testing this again? If it's testing the same codepath, I'd say one test is enough

[hokein]

address comments and added a missing case

[hokein]

clang/test/SemaCXX/base-class-ambiguity-check.cpp

16

The diagnostic is suboptimal (I'd expect it is "invalid use of incomplete type"), but it is not regression, clang shows the same diagnostics for the following non-crash case:

template <typename T> struct Foo2 {
  struct Base1;
  struct Derived : Base1 {};
}

clang/test/SemaCXX/ms-interface.cpp

114

They test different paths (this was founded in my previous-and-incomplete fix):

• this tests isInterface() on Line 2740 in SemaDeclCxx.cpp;
• the above one tests NoteIndirectBases (multiple base classes) on Line 2736 in SemaDeclCXX.cpp;

[sammccall]

clang/test/SemaCXX/base-class-ambiguity-check.cpp

16

Or even

template <int> struct X;
X<42> y;

I think the diagnostic is OK - it's diagnosing why the type *is* incomplete, rather than why the type *may not* be complete.

Typical use of this pattern would be to provide an out-of-line definition template:

template <typename T> struct Foo2<T>::Base1 {
  T contents;
}

in which case instantiation is the right idea.

clang/lib/Sema/SemaDeclCXX.cpp

if (KnownBase) {
       Context.Deallocate(Bases[idx]);
 
       Invalid = true;
     } else {
       // Okay, add this new base class.
       KnownBase = Bases[idx];
       Bases[NumGoodBases++] = Bases[idx];
 
+      if (NewBaseType->isIncompleteType()) {
+        assert(NewBaseType->isDependentType());
+        continue;
+      }
       // Note this base's direct & indirect bases, if there could be ambiguity.
       if (Bases.size() > 1)
         NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
 
       if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
         const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
         if (Class->isInterface() &&
               (!RD->isInterfaceLike() ||

clang/test/SemaCXX/base-class-ambiguity-check.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // expected-no-diagnostics
 
 template <typename T> class Foo {
   struct Base : T {};
 
   // Test that this code no longer causes a crash in Sema. rdar://23291875
   struct Derived : Base, T {};
 };
+
+
+template <typename T> class Foo2 {
+  struct Base;
+
+  // Should not crash on an incomplete-type base specifier.
+  struct Derived : Base {};
+};

clang/test/SemaCXX/ms-interface.cpp

struct IFaceStruct : IUnknown {
   void Put2(int);
 };
 
 __interface IFaceInheritsStruct : IFaceStruct {};
 static_assert(!__is_interface_class(HasProp), "oops");
 static_assert(!__is_interface_class(IUnknown), "oops");
 static_assert(!__is_interface_class(IFaceStruct), "oops");
 static_assert(!__is_interface_class(IFaceInheritsStruct), "oops");
+
+template<typename>
+class TemplateContext {
+  class Base;
+  // Should not crash on an incomplete-type base specifier.
+  __interface Foo : Base {};
+};