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

[sammccall]

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

14

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

16

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

15

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

15

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/AST/DeclCXX.cpp

 /// Determine whether a class has a repeated base class. This is intended for
 /// use when determining if a class is standard-layout, so makes no attempt to
 /// handle virtual bases.
 static bool hasRepeatedBaseClass(const CXXRecordDecl *StartRD) {
   llvm::SmallPtrSet<const CXXRecordDecl*, 8> SeenBaseTypes;
   SmallVector<const CXXRecordDecl*, 8> WorkList = {StartRD};
   while (!WorkList.empty()) {
     const CXXRecordDecl *RD = WorkList.pop_back_val();
+    if (RD->getTypeForDecl()->isDependentType())
+      continue;
     for (const CXXBaseSpecifier &BaseSpec : RD->bases()) {
       if (const CXXRecordDecl *B = BaseSpec.getType()->getAsCXXRecordDecl()) {
         if (!SeenBaseTypes.insert(B).second)
           return true;
         WorkList.push_back(B);
       }
     }
   }

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->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> struct Foo2 {
+  struct Base1; // expected-note{{member is declared here}}
+  struct Base2; // expected-note{{member is declared here}}
+  // Should not crash on an incomplete-type and dependent base specifier.
+  struct Derived : Base1, Base2 {}; // expected-error {{implicit instantiation of undefined member 'Foo2<int>::Base1'}} \
+                                       expected-error {{implicit instantiation of undefined member 'Foo2<int>::Base2'}}
+};
+
+Foo2<int>::Derived a; // expected-note{{in instantiation of member class}}

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 and dependent base specifier.
+  __interface Foo : Base {};
+};