Fix code completion crash with unresolved member expr and explicit base

[erikjv]

Summary

This is actually a failing assert. When doing object argument
initialization, it is valid to have e.g. 'this' as a base in a member
access expression (which is a prvalue). It's also possible to have a
scope specifier as part of the member expression, in which case a base
that is an actual lvalue gets wrapped in an ImplicitCastExpr, which in
turn is an rvalue.

lib/Sema/SemaOverload.cpp

unsigned Quals = isa<CXXDestructorDecl>(Method) ?
     Qualifiers::Const | Qualifiers::Volatile : Method->getTypeQualifiers();
   QualType ImplicitParamType =  S.Context.getCVRQualifiedType(ClassType, Quals);
 
   // Set up the conversion sequence as a "bad" conversion, to allow us
   // to exit early.
   ImplicitConversionSequence ICS;
 
   // We need to have an object of class type.
-  if (const PointerType *PT = FromType->getAs<PointerType>()) {
+  if (const PointerType *PT = FromType->getAs<PointerType>())
     FromType = PT->getPointeeType();
 
-    // When we had a pointer, it's implicitly dereferenced, so we
-    // better have an lvalue.
-    assert(FromClassification.isLValue());
-  }
-
   assert(FromType->isRecordType());
 
   // C++0x [over.match.funcs]p4:
   //   For non-static member functions, the type of the implicit object
   //   parameter is
   //
   //     - "lvalue reference to cv X" for functions declared without a
   //        ref-qualifier or with the & ref-qualifier

test/CodeCompletion/member-access.cpp

struct Test1 {
   }
 };
 
 struct Foo {
   void foo() const;
   static void foo(bool);
 };
 
-struct Bar {
+struct Bar: Foo {
   void foo(bool param) {
     Foo::foo(  );// unresolved member expression with an implicit base
   }
+
+  void mooze(bool param) {
+    this->Foo::foo(  );// unresolved member expression with an explicit base
+  }
+
+  void mooze(bool param, int anotherParam) {
+    Bar *that = new Bar;
+    that->Foo::foo(  );// unresolved member expression with an explicit base wrapped in a ImplicitCastExpr
+  }
 };
 
   // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:29:6 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
   // CHECK-CC1: Base1 : Base1::
   // CHECK-CC1: member1 : [#int#][#Base1::#]member1
   // CHECK-CC1: member1 : [#int#][#Base2::#]member1
   // CHECK-CC1: member2 : [#float#][#Base1::#]member2
   // CHECK-CC1: member3
   // CHECK-CC1: member4
   // CHECK-CC1: memfun1 : [#void#][#Base3::#]memfun1(<#float#>)
   // CHECK-CC1: memfun1 : [#void#][#Base3::#]memfun1(<#double#>)[# const#]
   // CHECK-CC1: memfun1 (Hidden) : [#void#]Base2::memfun1(<#int#>)
   // CHECK-CC1: memfun2 : [#void#][#Base3::#]memfun2(<#int#>)
   // CHECK-CC1: memfun3 : [#int#]memfun3(<#int#>)
 
 // Make sure this doesn't crash
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:36:7 %s -verify
 
 // Make sure this also doesn't crash
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:47:14 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:51:21 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:56:21 %s
 
 
 template<typename T>
 class BaseTemplate {
 public:
   T baseTemplateFunction();
 
   T baseTemplateField;

 // CHECK-CC2: baseTemplateFunction : [#T#][#BaseTemplate<T>::#]baseTemplateFunction()
 // CHECK-CC2: field : [#T#]field
 // CHECK-CC2: function : [#T#]function()
 // CHECK-CC2: member1 : [#int#][#Base1::#]member1
 // CHECK-CC2: member2 : [#float#][#Base1::#]member2
 // CHECK-CC2: overload1 : [#void#]overload1(<#const T &#>)
 // CHECK-CC2: overload1 : [#void#]overload1(<#const S &#>)
 
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:92:10 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:93:12 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:103:10 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:104:12 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
 }
 
 
 void completeDependentSpecializedMembers(TemplateClass<int, double> &object,
                                          TemplateClass<int, double> *object2) {
   object.field;
   object2->field;
 // CHECK-CC3: baseTemplateField : [#int#][#BaseTemplate<int>::#]baseTemplateField
 // CHECK-CC3: baseTemplateFunction : [#int#][#BaseTemplate<int>::#]baseTemplateFunction()
 // CHECK-CC3: field : [#int#]field
 // CHECK-CC3: function : [#int#]function()
 // CHECK-CC3: member1 : [#int#][#Base1::#]member1
 // CHECK-CC3: member2 : [#float#][#Base1::#]member2
 // CHECK-CC3: overload1 : [#void#]overload1(<#const int &#>)
 // CHECK-CC3: overload1 : [#void#]overload1(<#const double &#>)
 
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:110:10 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:111:12 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:121:10 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:122:12 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
 }
 
 template <typename T>
 class Template {
 public:
   BaseTemplate<int> o1;
   BaseTemplate<T> o2;
 
   void function() {
     o1.baseTemplateField;
 // CHECK-CC4: BaseTemplate : BaseTemplate::
 // CHECK-CC4: baseTemplateField : [#int#]baseTemplateField
 // CHECK-CC4: baseTemplateFunction : [#int#]baseTemplateFunction()
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:132:8 %s -o - | FileCheck -check-prefix=CHECK-CC4 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:143:8 %s -o - | FileCheck -check-prefix=CHECK-CC4 %s
     o2.baseTemplateField;
 // CHECK-CC5: BaseTemplate : BaseTemplate::
 // CHECK-CC5: baseTemplateField : [#T#]baseTemplateField
 // CHECK-CC5: baseTemplateFunction : [#T#]baseTemplateFunction()
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:137:8 %s -o - | FileCheck -check-prefix=CHECK-CC5 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:148:8 %s -o - | FileCheck -check-prefix=CHECK-CC5 %s
     this->o1;
 // CHECK-CC6: [#void#]function()
 // CHECK-CC6: o1 : [#BaseTemplate<int>#]o1
 // CHECK-CC6: o2 : [#BaseTemplate<T>#]o2
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:142:11 %s -o - | FileCheck -check-prefix=CHECK-CC6 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:153:11 %s -o - | FileCheck -check-prefix=CHECK-CC6 %s
   }
 
   static void staticFn(T &obj);
 
   struct Nested { };
 };
 
 template<typename T>
 void dependentColonColonCompletion() {
   Template<T>::staticFn();
 // CHECK-CC7: function : [#void#]function()
 // CHECK-CC7: Nested : Nested
 // CHECK-CC7: o1 : [#BaseTemplate<int>#]o1
 // CHECK-CC7: o2 : [#BaseTemplate<T>#]o2
 // CHECK-CC7: staticFn : [#void#]staticFn(<#T &obj#>)
 // CHECK-CC7: Template : Template
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:156:16 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:167:16 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
   typename Template<T>::Nested m;
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:164:25 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:175:25 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
 }