PR20716 - Crash when recovering from type in known dependent base (ms-compatibility)

[nikola]

Summary

The call to cast crashes because getTemplateDecl returns null for TemplateTemplateParmDecls.

[nlewycky]

Looks good to Richard Smith.

[nikola]

We have to extend the check to cover type aliases as well. I've also updated the comment because TypeAliasDecl::Create never calls this constructor overload.

[rnk]

Feel free to land with fixes.

lib/Sema/SemaDecl.cpp

155–156

I think this change can just be s/cast/dyn_cast_or_null/ and inserting "if (!BasePrimaryTemplate) continue;"

test/SemaTemplate/ms-lookup-template-base-classes.cpp

468–470

These 'foo' identifiers are getting delayed by ADL because they are function calls. I would try to use an unqualified name to try to declare a member, since I believe only a type can occur there.

[nikola]

Done in r216352.

include/clang/AST/DeclTemplate.h

 protected:
   // This is probably never used.
   TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L,
                DeclarationName Name)
     : NamedDecl(DK, DC, L, Name), TemplatedDecl(nullptr),
       TemplateParams(nullptr) {}
 
   // Construct a template decl with the given name and parameters.
-  // Used when there is not templated element (tt-params, alias?).
+  // Used when there is not templated element (tt-params).
   TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L,
                DeclarationName Name, TemplateParameterList *Params)
     : NamedDecl(DK, DC, L, Name), TemplatedDecl(nullptr),
       TemplateParams(Params) {}
 
   // Construct a template decl with name, parameters, and templated element.
   TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L,
                DeclarationName Name, TemplateParameterList *Params,

lib/Sema/SemaDecl.cpp

   bool FoundTypeDecl = false;
   for (const auto &Base : RD->bases()) {
     auto *TST = Base.getType()->getAs<TemplateSpecializationType>();
     if (!TST || !TST->isDependentType())
       continue;
     auto *TD = TST->getTemplateName().getAsTemplateDecl();
     if (!TD)
       continue;
-    auto *BasePrimaryTemplate = cast<CXXRecordDecl>(TD->getTemplatedDecl());
-    // FIXME: Allow lookup into non-dependent bases of dependent bases, possibly
-    // by calling or integrating with the main LookupQualifiedName mechanism.
-    for (NamedDecl *ND : BasePrimaryTemplate->lookup(&II)) {
-      if (FoundTypeDecl)
-        return ParsedType();
-      FoundTypeDecl = isa<TypeDecl>(ND);
-      if (!FoundTypeDecl)
-        return ParsedType();
+    if (CXXRecordDecl *BasePrimaryTemplate =
+            dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
+      // FIXME: Allow lookup into non-dependent bases of dependent bases, possibly
+      // by calling or integrating with the main LookupQualifiedName mechanism.
+      for (NamedDecl *ND : BasePrimaryTemplate->lookup(&II)) {
+        if (FoundTypeDecl)
+          return ParsedType();
+        FoundTypeDecl = isa<TypeDecl>(ND);
+        if (!FoundTypeDecl)
+          return ParsedType();
+      }
     }
   }
   if (!FoundTypeDecl)
     return ParsedType();
 
   // We found some types in dependent base classes.  Recover as if the user
   // wrote 'typename MyClass::II' instead of 'II'.  We'll fully resolve the
   // lookup during template instantiation.

test/SemaTemplate/ms-lookup-template-base-classes.cpp

 
 // Dependent base class with enum.
 template <typename T> struct C { enum { NameFromBase = 4 }; };
 template <typename T> struct D : C<T> {
   // expected-warning@+1 {{use of undeclared identifier 'NameFromBase'; unqualified lookup into dependent bases}}
   int x = f<NameFromBase>();
 };
 }
+
+namespace PR20716 {
+template <template <typename T> class A>
+struct B : A<int>
+{
+  void bar() {
+    foo();
+  }
+};
+
+template <typename T>
+struct C {};
+
+template <typename T>
+using D = C<T>;
+
+template <typename T>
+struct E : D<T>
+{
+  void bar() {
+    foo();
+  }
+};
+}