[Clang] Plan 9 member resolution

[ksaunders]

Summary

This patch implements the Plan 9 member resolution algorithm which is described referenced in the original revision: https://reviews.llvm.org/D127462. The test code is illustrative as to what is considered valid, as it was derived from samples compiled using the Plan 9 C compiler.

It is not clear what the policy on issuing diagnostics is for extensions usage, so there is a warning emitted for usage of duplicated members (which is a Plan 9 extension). However this might not be a good idea, as there could be potentially a large number of warnings emitted, as this is used throughout headers Plan 9 C.

clang/include/clang/Basic/DiagnosticGroups.td

 // A warning group for warnings about code that clang accepts but gcc doesn't.
 def GccCompat : DiagGroup<"gcc-compat">;
 
 // A warning group for warnings about code that may be incompatible on AIX.
 def AIXCompat : DiagGroup<"aix-compat">;
 
 // Warnings for Plan 9 extensions.
 def Plan9AnonTag : DiagGroup<"plan9-anon-tag">;
+def Plan9DuplicateMember : DiagGroup<"plan9-duplicate-member">;
 
 // Warnings group for warnings about Plan 9 extensions.
-def Plan9 : DiagGroup<"plan9", [Plan9AnonTag]>;
+def Plan9 : DiagGroup<"plan9", [Plan9AnonTag, Plan9DuplicateMember]>;
 
 // Warnings for Microsoft extensions.
 def MicrosoftCharize : DiagGroup<"microsoft-charize">;
 def MicrosoftDrectveSection : DiagGroup<"microsoft-drectve-section">;
 def MicrosoftInclude : DiagGroup<"microsoft-include">;
 def MicrosoftCppMacro : DiagGroup<"microsoft-cpp-macro">;
 def MicrosoftFixedEnum : DiagGroup<"microsoft-fixed-enum">;
 def MicrosoftSealed : DiagGroup<"microsoft-sealed">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

def ext_ms_forward_ref_enum : ExtWarn<
   "forward references to 'enum' types are a Microsoft extension">,
   InGroup<MicrosoftEnumForwardReference>;
 def ext_forward_ref_enum_def : Extension<
   "redeclaration of already-defined enum %0 is a GNU extension">,
   InGroup<GNURedeclaredEnum>;
 
 def err_redefinition_of_enumerator : Error<"redefinition of enumerator %0">;
 def err_duplicate_member : Error<"duplicate member %0">;
+def ext_plan9_duplicate_member : ExtWarn<
+  "duplicate member %0 is a Plan 9 extension">,
+  InGroup<Plan9DuplicateMember>;
 def err_misplaced_ivar : Error<
   "instance variables may not be placed in %select{categories|class extension}0">;
 def warn_ivars_in_interface : Warning<
   "declaration of instance variables in the interface is deprecated">,
   InGroup<DiagGroup<"objc-interface-ivars">>, DefaultIgnore;
 def ext_enum_value_not_int : Extension<
   "ISO C restricts enumerator values to range of 'int' (%0 is too "
   "%select{small|large}1)">;

clang/lib/AST/Expr.cpp

 
 MemberExpr::MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
                        ValueDecl *MemberDecl,
                        const DeclarationNameInfo &NameInfo, QualType T,
                        ExprValueKind VK, ExprObjectKind OK,
                        NonOdrUseReason NOUR)
     : Expr(MemberExprClass, T, VK, OK), Base(Base), MemberDecl(MemberDecl),
       MemberDNLoc(NameInfo.getInfo()), MemberLoc(NameInfo.getLoc()) {
-  assert(!NameInfo.getName() ||
-         MemberDecl->getDeclName() == NameInfo.getName());
   MemberExprBits.IsArrow = IsArrow;
   MemberExprBits.HasQualifierOrFoundDecl = false;
   MemberExprBits.HasTemplateKWAndArgsInfo = false;
   MemberExprBits.HadMultipleCandidates = false;
   MemberExprBits.NonOdrUseReason = NOUR;
   MemberExprBits.OperatorLoc = OperatorLoc;
   setDependence(computeDependence(this));
 }
 
 MemberExpr *MemberExpr::Create(
     const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
     ValueDecl *MemberDecl, DeclAccessPair FoundDecl,
     DeclarationNameInfo NameInfo, const TemplateArgumentListInfo *TemplateArgs,
     QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR) {
   bool HasQualOrFound = QualifierLoc || FoundDecl.getDecl() != MemberDecl ||
                         FoundDecl.getAccess() != MemberDecl->getAccess();
   bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();
   std::size_t Size =
       totalSizeToAlloc<MemberExprNameQualifier, ASTTemplateKWAndArgsInfo,
                        TemplateArgumentLoc>(
           HasQualOrFound ? 1 : 0, HasTemplateKWAndArgsInfo ? 1 : 0,
           TemplateArgs ? TemplateArgs->size() : 0);
 
+  // In Plan 9 C unnamed record fields can be accessed by their typedef'd name.
+  if (!C.getLangOpts().Plan9) {
+    assert(!NameInfo.getName() ||
+           MemberDecl->getDeclName() == NameInfo.getName());
+  }
+
   void *Mem = C.Allocate(Size, alignof(MemberExpr));
   MemberExpr *E = new (Mem) MemberExpr(Base, IsArrow, OperatorLoc, MemberDecl,
                                        NameInfo, T, VK, OK, NOUR);
 
   // FIXME: remove remaining dependence computation to computeDependence().
   auto Deps = E->getDependence();
   if (HasQualOrFound) {
     // FIXME: Wrong. We should be looking at the member declaration we found.

clang/lib/Sema/SemaDecl.cpp

static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
 
   // Pick a representative declaration.
   NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
   assert(PrevDecl && "Expected a non-null Decl");
 
   if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
     return false;
 
+  // Plan 9 C allows duplicate record member names.
+  if (SemaRef.getLangOpts().Plan9) {
+    SemaRef.Diag(NameLoc, diag::ext_plan9_duplicate_member) << Name;
+    SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
+    return false;
+  }
+
   SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl)
     << IsUnion << Name;
   SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
 
   return true;
 }
 
 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
if (InitStyle != ICIS_NoInit)
     checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
 
   FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
                                        BitWidth, Mutable, InitStyle);
   if (InvalidDecl)
     NewFD->setInvalidDecl();
 
   if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
+    // Plan 9 C allows duplicate record member names.
+    if (getLangOpts().Plan9 && !getLangOpts().CPlusPlus) {
+      Diag(Loc, diag::ext_plan9_duplicate_member) << II;
+      Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
+    } else {
       Diag(Loc, diag::err_duplicate_member) << II;
       Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
       NewFD->setInvalidDecl();
     }
+  }
 
   if (!InvalidDecl && getLangOpts().CPlusPlus) {
     if (Record->isUnion()) {
       if (const RecordType *RT = EltTy->getAs<RecordType>()) {
         CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
         if (RDecl->getDefinition()) {
           // C++ [class.union]p1: An object of a class with a non-trivial
           // constructor, a non-trivial copy constructor, a non-trivial

clang/lib/Sema/SemaLookup.cpp

case DeclarationName::CXXDeductionGuideName:
     S.DeclareImplicitDeductionGuides(Name.getCXXDeductionGuideTemplate(), Loc);
     break;
 
   default:
     break;
   }
 }
 
+// Resolves fields in a record like a Plan 9 compiler.  The resolution
+// is performed in 3 passes:
+//
+//   Pass 1: Look for field names that match the lookup name.
+//   Pass 2: Look for unnamed embedded records who's typedef'd name
+//           match the lookup name.
+//   Pass 3: Look for candidate fields in unnamed embedded records.
+//
+// Returns true if any matches were found.
+static bool LookupPlan9(Sema &S, LookupResult &R, const RecordDecl *RD,
+                        const DeclContext *Owner) {
+  bool Found = false;
+
+  // Pass 1 & 2 are fused: conflicts are an error.
+  for (FieldDecl *Field : RD->fields()) {
+    // Pass 1
+    if (Field->getDeclName() == R.getLookupName()) {
+      R.addDecl(Field);
+      Found = true;
+    }
+
+    // Pass 2
+    if (isa<RecordType>(Field->getType()) && Field->getDeclName().isEmpty()) {
+      if (const auto *Typedef =
+              Field->getTypeSourceInfo()->getType()->getAs<TypedefType>()) {
+        if (Typedef->getDecl()->getDeclName() == R.getLookupName()) {
+          R.addDecl(Field);
+          Found = true;
+        }
+      }
+    }
+  }
+
+  if (Found)
+    return true;
+
+  LookupResult LocalR(LookupResult::Temporary, R);
+
+  // Pass 3
+  for (FieldDecl *Field : RD->fields()) {
+    const auto *EmbeddedRecord = Field->getType()->getAs<RecordType>();
+    if (EmbeddedRecord && Field->getDeclName().isEmpty()) {
+      if (LookupPlan9(S, LocalR, EmbeddedRecord->getDecl(), Owner)) {
+        for (auto D = LocalR.begin(); D != LocalR.end(); ++D) {
+          IndirectFieldDecl *IF;
+          NamedDecl *ND = *D;
+
+          // If we resolve to an indirect field: prepend our field to the chain.
+          if (auto *OldField = dyn_cast<IndirectFieldDecl>(ND)) {
+            auto OldChain = OldField->chain();
+            unsigned OldChainSize = OldChain.size();
+
+            NamedDecl **NamedChain =
+                new (S.Context) NamedDecl *[OldChainSize + 1];
+            NamedChain[0] = Field;
+            for (unsigned I = 0; I < OldChainSize; I++)
+              NamedChain[I + 1] = OldChain[I];
+
+            IF = IndirectFieldDecl::Create(
+                S.Context, const_cast<DeclContext *>(Owner),
+                OldField->getLocation(), OldField->getIdentifier(),
+                OldField->getType(), {NamedChain, OldChainSize + 1});
+          } else {
+            // If the field is not indirect, make it so.  This lets us perform
+            // nested lookup.
+            auto *FD = cast<FieldDecl>(ND);
+
+            NamedDecl **NamedChain = new (S.Context) NamedDecl *[2];
+            NamedChain[0] = Field;
+            NamedChain[1] = FD;
+
+            IF = IndirectFieldDecl::Create(
+                S.Context, const_cast<DeclContext *>(Owner), FD->getLocation(),
+                FD->getIdentifier(), FD->getType(), {NamedChain, 2});
+          }
+
+          for (const auto *Attr : ND->attrs())
+            IF->addAttr(Attr->clone(S.Context));
+
+          IF->setImplicit();
+
+          R.addDecl(IF);
+          Found = true;
+        }
+
+        LocalR.clear();
+      }
+    }
+  }
+
+  return Found;
+}
+
 // Adds all qualifying matches for a name within a decl context to the
 // given lookup result.  Returns true if any matches were found.
 static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC) {
   bool Found = false;
 
   // Lazily declare C++ special member functions.
   if (S.getLangOpts().CPlusPlus)
     DeclareImplicitMemberFunctionsWithName(S, R.getLookupName(), R.getNameLoc(),
                                            DC);
 
+  // If in Plan 9 C mode, resolve fields in a record like a Plan 9 compiler.
+  if (DC->isRecord() && S.getLangOpts().Plan9 && !S.getLangOpts().CPlusPlus) {
+    const RecordDecl *RD = cast<RecordDecl>(DC);
+    Found = LookupPlan9(S, R, RD, DC);
+  } else {
     // Perform lookup into this declaration context.
     DeclContext::lookup_result DR = DC->lookup(R.getLookupName());
     for (NamedDecl *D : DR) {
       if ((D = R.getAcceptableDecl(D))) {
         R.addDecl(D);
         Found = true;
       }
     }
+  }
 
   if (!Found && DC->isTranslationUnit() && S.LookupBuiltin(R))
     return true;
 
   if (R.getLookupName().getNameKind()
         != DeclarationName::CXXConversionFunctionName ||
       R.getLookupName().getCXXNameType()->isDependentType() ||
       !isa<CXXRecordDecl>(DC))

clang/test/Sema/2c-anon-record.c

 // RUN: %clang_cc1 %s -fsyntax-only -Wplan9 -verify -fplan9-extensions
 
-struct A {
+typedef struct {
+  int x; // expected-note {{previous declaration is here}}
+} A;
+
+struct B {
+  A;       // expected-warning {{anonymous structs are a Plan 9 extension}}
+  char *x; // expected-warning {{duplicate member 'x' is a Plan 9 extension}}
+};
+
+char *f0(struct B *b) {
+  return b->x;
+}
+
+typedef struct {
   int x;
+} C;
+
+struct D {
+  // expected-warning@+2 {{anonymous structs are a Plan 9 extension}}
+  // expected-note@+1 {{candidate found by name lookup is 'D::(anonymous)'}}
+  C;
+  int C; // expected-note {{candidate found by name lookup is 'D::C'}}
 };
 
-struct B {
-  struct A; // expected-warning {{anonymous structs are a Plan 9 extension}}
+int f1(struct D *d) {
+  int x = d->x;
+  return d->C; // expected-error {{reference to 'C' is ambiguous}}
+}
+
+typedef struct {
+  int x; // expected-note {{previous declaration is here}}
+} E;
+
+struct F {
+  E;     // expected-warning {{anonymous structs are a Plan 9 extension}}
+  int x; // expected-warning {{duplicate member 'x' is a Plan 9 extension}}
+};
+
+E f2(struct F *f) {
+  int x = f->x;
+  return f->E;
+}
+
+typedef struct {
+  // expected-note@+3 {{previous declaration is here}}
+  // expected-note@+2 {{previous declaration is here}}
+  // expected-note@+1 {{candidate found by name lookup is 'H::a'}}
+  int a;
+  // expected-warning@+3 {{duplicate member 'a' is a Plan 9 extension}}
+  // expected-warning@+2 {{duplicate member 'a' is a Plan 9 extension}}
+  // expected-note@+1 {{candidate found by name lookup is 'H::a'}}
+  int a;
+} G;
+
+struct H {
+  G; // expected-warning {{anonymous structs are a Plan 9 extension}}
+  int b;
 };
+
+int f3(struct H *h) {
+  int b = h->b;
+  return h->a; // expected-error {{reference to 'a' is ambiguous}}
+}
+
+typedef union {
+  int a;
+} I;
+
+union J {
+  I; // expected-warning {{anonymous unions are a Plan 9 extension}}
+  int b : 4;
+};
+
+int f4(union J *j) {
+  int b = j->b;
+  return j->a;
+}
+
+typedef struct K TK;
+
+struct K {
+  int x;
+};
+
+struct L {
+  TK; // expected-warning {{anonymous structs are a Plan 9 extension}}
+  int l;
+};
+
+TK f5(struct L *l) {
+  struct K k = l->K; // expected-error {{no member named 'K' in 'struct L'}}
+  return l->TK;
+}