[Sema] Fix PR35832 - Ambiguity accessing anonymous struct/union with multiple bases.

[EricWF]

Summary

Currently clang doesn't do qualified lookup when building indirect field decl references. This causes ambiguity when the field is in a base class to which there are multiple valid paths even though a qualified name is used.

For example:

class B {
protected:
 int i;
 union { int j; };
};

class X : public B { };
class Y : public B { };

class Z : public X, public Y {
 int a() { return X::i; } // works
 int b() { return X::j; } // fails
};

[EricWF]

• Upload with correct test.

[rjmccall]

Well, that is a really silly bug. Fix LGTM.

[EricWF]

I missed a test failure. Reuploading and recommiting latest diff to keep the history.

lib/Sema/SemaExprMember.cpp

if (!baseVariable) {
     bool baseObjectIsPointer = baseObjectExpr->getType()->isPointerType();
 
     // Make a nameInfo that properly uses the anonymous name.
     DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
 
     // Build the first member access in the chain with full information.
     result =
         BuildFieldReferenceExpr(result, baseObjectIsPointer, SourceLocation(),
-                                EmptySS, field, foundDecl, memberNameInfo)
+                                SS, field, foundDecl, memberNameInfo)
             .get();
     if (!result)
       return ExprError();
   }
   
   // In all cases, we should now skip the first declaration in the chain.
   ++FI;
   

lib/Sema/TreeTransform.h

                         const TemplateArgumentListInfo *ExplicitTemplateArgs,
                                NamedDecl *FirstQualifierInScope) {
     ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
                                                                       isArrow);
     if (!Member->getDeclName()) {
       // We have a reference to an unnamed field.  This is always the
       // base of an anonymous struct/union member access, i.e. the
       // field is always of record type.
-      assert(!QualifierLoc && "Can't have an unnamed field with a qualifier!");
       assert(Member->getType()->isRecordType() &&
              "unnamed member not of record type?");
 
       BaseResult =
         getSema().PerformObjectMemberConversion(BaseResult.get(),
                                                 QualifierLoc.getNestedNameSpecifier(),
                                                 FoundDecl, Member);
       if (BaseResult.isInvalid())

test/SemaCXX/PR35832.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// expected-no-diagnostics
+
+class B {
+public:
+ int i;
+ struct {  struct { union { int j; }; };  };
+ union { int k; };
+};
+
+class X : public B { };
+class Y : public B { };
+
+class Z : public X, public Y {
+public:
+ int a() { return X::i; }
+ int b() { return X::j; }
+ int c() { return X::k; }
+ int d() { return this->X::j; }
+};