Bugfix in template instantiation.

[ABataev]

Summary

Fix for clang crash when instantiating a template with qualified lookup for members in non-class types

[majnemer]

lib/Sema/SemaCXXScopeSpec.cpp

144–146

No need to repeat TagType, we know what it is from the right hand side. I'd recommend:

if (const auto *Tag = NNS->getAsType()->getAs<TagType>())

lib/Sema/SemaExprMember.cpp

599–605

This is unusual in clang's codebase, I'd recommend:

DC = SemaRef.computeDeclContext(SS, /*EnteringContext=*/false);
if (!DC) {

[ABataev]

David, thanks. I'll fix this.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

14.10.2014 12:59, David Majnemer пишет:

Comment at: lib/Sema/SemaCXXScopeSpec.cpp:144
@@ -143,4 +143,3 @@

case NestedNameSpecifier::TypeSpecWithTemplate: {

• const TagType *Tag = NNS->getAsType()->getAs<TagType>();
• assert(Tag && "Non-tag type in nested-name-specifier");
• return Tag->getDecl();

+ if (const TagType *Tag = NNS->getAsType()->getAs<TagType>())

+ return Tag->getDecl();

No need to repeat TagType, we know what it is from the right hand side. I'd recommend:

if (const auto *Tag = NNS->getAsType()->getAs<TagType>())

Comment at: lib/Sema/SemaExprMember.cpp:599
@@ -598,2 +598,3 @@

// nested-name-specifier.

• DC = SemaRef.computeDeclContext(SS, false);

+ if ((DC = SemaRef.computeDeclContext(SS, false)) == nullptr) {

+ SemaRef.Diag(SS.getBeginLoc(), diag::err_expected_class_or_namespace)

This is unusual in clang's codebase, I'd recommend:

DC = SemaRef.computeDeclContext(SS, /*EnteringContext=*/false);
if (!DC) {

http://reviews.llvm.org/D5769

[ABataev]

Update after review.

[rsmith]

This is the wrong fix. The bug is that TreeTransform::RebuildCXXPseudoDestructorExpr is building a bogus CXXScopeSpec here:

// The scope type is now known to be a valid nested name specifier
// component. Tack it on to the end of the nested name specifier.
if (ScopeType)
  SS.Extend(SemaRef.Context, SourceLocation(),
            ScopeType->getTypeLoc(), CCLoc);

If ScopeType is not a class type, we should reject it at this point.

[ABataev]

Completely reworked patch after review.

[rsmith]

Please add tests for the case where the type before the ::~ instantiates as an enum type, in both C++98 and C++11.

Otherwise, this looks fine. Thanks!

[ABataev]

Closed by commit rL219897 (authored by @ABataev).

lib/Sema/SemaCXXScopeSpec.cpp

DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS,
   case NestedNameSpecifier::Namespace:
     return NNS->getAsNamespace();
 
   case NestedNameSpecifier::NamespaceAlias:
     return NNS->getAsNamespaceAlias()->getNamespace();
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate: {
-    const TagType *Tag = NNS->getAsType()->getAs<TagType>();
-    assert(Tag && "Non-tag type in nested-name-specifier");
+    if (const auto *Tag = NNS->getAsType()->getAs<TagType>())
       return Tag->getDecl();
+    return nullptr;
   }
 
   case NestedNameSpecifier::Global:
     return Context.getTranslationUnitDecl();
 
   case NestedNameSpecifier::Super:
     return NNS->getAsRecordDecl();
   }

lib/Sema/SemaExprMember.cpp

if (HasTemplateArgs) {
     SemaRef.LookupTemplateName(R, nullptr, SS, ObjectType, false, MOUS);
     return false;
   }
 
   DeclContext *DC = RDecl;
   if (SS.isSet()) {
     // If the member name was a qualified-id, look into the
     // nested-name-specifier.
     DC = SemaRef.computeDeclContext(SS, false);
+    if (!DC) {
+      SemaRef.Diag(SS.getBeginLoc(), diag::err_expected_class_or_namespace)
+          << QualType(SS.getScopeRep()->getAsType(), /*Quals*/ 0)
+          << SemaRef.getLangOpts().CPlusPlus;
+      return true;
+    }
 
     if (SemaRef.RequireCompleteDeclContext(SS, DC)) {
       SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag)
         << SS.getRange() << DC;
       return true;
     }
 
     assert(DC && "Cannot handle non-computable dependent contexts in lookup");

test/SemaTemplate/instantiate-non-dependent-types.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 template<typename T>
 struct X1 {
   static void member() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
 };
 
 template<void(*)()> struct instantiate { };
 
 template<typename T>
 struct X2 {
   typedef instantiate<&X1<int>::member> i; // expected-note{{in instantiation of}}
 };
 
-X2<int> x; 
+X2<int> x;
+
+template <class T, class A> class C {
+public:
+  int i;
+  void f(T &t) {
+    T *q = new T();
+    t.T::~T();
+    q->~T();
+    // expected-error@+1 {{'int' is not a class, namespace, or scoped enumeration}}
+    q->A::~A();
+    // expected-error@+1 {{no member named '~int' in 'Q'}}
+    q->~A();
+
+    delete q;
+  }
+};
+
+class Q {
+public:
+  Q() {}
+  ~Q() {}
+};
+
+C<Q, int> dummy;
+int main() {
+  Q qinst;
+  // expected-note@+1 {{in instantiation of member function 'C<Q, int>::f' requested here}}
+  dummy.f(qinst);
+}
+