Implement P1766R1: diagnose giving non-C-compatible classes a typedef name for linkage purposes.

[rsmith]

Summary

Due to a recent (but retroactive) C++ rule change, only sufficiently
C-compatible classes are permitted to be given a typedef name for
linkage purposes. Add an enabled-by-default warning for these cases, and
rephrase our existing error for the case where we encounter the typedef
name for linkage after we've already computed and used a wrong linkage
in terms of the new rule.

[rjmccall]

Oh thank goodness, they finally fixed this.

clang/lib/Sema/SemaDecl.cpp

4365

Starting the quote here makes it look like it's describing the invalid-decl short-circuit just below.

4394

This is essentially part of the next paragraph.

I believe friend declarations also do not declare "members", under the same logic allowing static_assert.

4404

Do lambdas in nested expressions really get added to the class's decls list? I wouldn't have expected that, but it definitely makes this check a lot easier.

[rsmith]

Updates based on review comments from @rjmccall.

clang/lib/Sema/SemaDecl.cpp

4394

I think you're right, but that's a defect in the wording -- a friend definition, at least, could use the class in a way that requires a linkage calculation, and the design intent as approved by the Evolution Working Group did not permit friend declarations. I'll take this back to the committee for some rewording, but I think it makes sense to proceed under the assumption that friends won't be allowed. In any case, I'm updating the diagnostic to treat friends as a special case, since they're not member declarations.

4404

They end up in some enclosing DeclContext, which is either the class itself or something else that we also disallow.

[rsmith]

Add test coverage for the 'friend' case.

[rjmccall]

clang/lib/Sema/SemaDecl.cpp

4394

Could it? I think the same inability to write a self-reference that makes the C-like cases okay should also apply to friends. If you can write a self-reference in a friend declaration, you can write one in a template argument list in the type of a field declaration. Well, okay, I suppose a friend function *definition* might need to be forbidden.

Anyway, I don't think it's actually a problem if the committee wants to outlaw friends here, just wondering at the effective rule they're aiming for in case we need to figure out how to apply it to extensions.

4404

Yeah, obviously their DC should be the class, but I didn't think the decl-to-DC link always implied membership in the decls list. But hey, it seems to work in the case we care about.

4491

Might be good to tell future maintainers how to fix it: probably, by adding something to the forbidden list above.

[rsmith]

Extend assert comment to suggest likely remediations.

[rjmccall]

Thanks, LGTM, assuming that we do indeed want to ban friends.

[rsmith]

Add back a diagnostic for remaining cases that the new langauge rule doesn't handle.

[rsmith]

Ugh, you mentioned template argument lists and made me realize we can still reach problem cases that way. And with array bounds. :(

I've added back in a diagnostic for the case where we compute the linkage too early for a "C-like" struct. Hopefully people won't hit it too much.

clang/lib/Sema/SemaDecl.cpp

4394

Hm. Now you come to mention it, I think friends might actually be fine -- or at least no worse than non-static data members -- from a linkage perspective.

The intended rule is described in P1766R1 section 2.3. If there are extensions that we permit in C structs, it would presumably be reasonable to permit them here too, but I would expect that C++-specific extensions should be disallowed here.

[rjmccall]

Okay, if the basic idea is to avoid anything that would need the linkage to be computed, that seems like exactly the right goal.

I know one of the awful ways to get an early reference to the anonymous type is to define a typedef of like a pointer to it, then use that in a second declarator, then try to give it a typedef-for-linkage-purposes in yet another declarator. I don't know of any way to get an expression whose type involves the anonymous type without a non-static member function or initializer or something like that.

clang/docs/ReleaseNotes.rst

 C11 Feature Support
 ^^^^^^^^^^^^^^^^^^^
 
 ...
 
 C++ Language Changes in Clang
 -----------------------------
 
+- Clang now implements a restriction on giving non-C-compatible anonymous
+  structs a typedef name for linkage purposes, as described in C++ committee
+  paper `P1766R1 <http://wg21.link/p1766r1>`. This paper was adopted by the
+  C++ committee as a Defect Report resolution, so it is applied retroactively
+  to all C++ standard versions. This affects code such as:
+
+  .. code-block:: c++
+
+    typedef struct {
+      int f() { return 0; }
+    } S;
+
+  Previous versions of Clang rejected some constructs of this form
+  (specifically, where the linkage of the type happened to be computed
+  before the parser reached the typedef name); those cases are still rejected
+  in Clang 11.  In addition, cases that previous versions of Clang did not
+  reject now produce an extension warning. This warning can be disabled with
+  the warning flag ``-Wno-non-c-typedef-for-linkage``.
+
+  Affected code should be updated to provide a tag name for the anonymous
+  struct:
+
+  .. code-block:: c++
+
+    struct S {
+      int f() { return 0; }
+    };
+
+  If the code is shared with a C compilation (for example, if the parts that
+  are not C-compatible are guarded with ``#ifdef __cplusplus``), the typedef
+  declaration should be retained, but a tag name should still be provided:
+
+  .. code-block:: c++
+
+    typedef struct S {
+      int f() { return 0; }
+    } S;
 
 C++1z Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 ...
 
 Objective-C Language Changes in Clang
 -------------------------------------

clang/include/clang/Basic/DiagnosticSemaKinds.td

def ext_main_used : Extension<
   "ISO C++ does not allow 'main' to be used by a program">, InGroup<Main>;
 
 /// parser diagnostics
 def ext_no_declarators : ExtWarn<"declaration does not declare anything">,
   InGroup<MissingDeclarations>;
 def ext_typedef_without_a_name : ExtWarn<"typedef requires a name">,
   InGroup<MissingDeclarations>;
 def err_typedef_not_identifier : Error<"typedef name must be an identifier">;
-def err_typedef_changes_linkage : Error<"unsupported: typedef changes linkage"
-  " of anonymous type, but linkage was already computed">;
-def note_typedef_changes_linkage : Note<"use a tag name here to establish "
-  "linkage prior to definition">;
+
+def ext_non_c_like_anon_struct_in_typedef : ExtWarn<
+  "anonymous non-C-compatible type given name for linkage purposes "
+  "by %select{typedef|alias}0 declaration; "
+  "add a tag name here">, InGroup<DiagGroup<"non-c-typedef-for-linkage">>;
+def err_non_c_like_anon_struct_in_typedef : Error<
+  "anonymous non-C-compatible type given name for linkage purposes "
+  "by %select{typedef|alias}0 declaration after its linkage was computed; "
+  "add a tag name here to establish linkage prior to definition">;
+def err_typedef_changes_linkage : Error<
+  "unsupported: anonymous type given name for linkage purposes "
+  "by %select{typedef|alias}0 declaration after its linkage was computed; "
+  "add a tag name here to establish linkage prior to definition">;
+def note_non_c_like_anon_struct : Note<
+  "type is not C-compatible due to this "
+  "%select{base class|default member initializer|lambda expression|"
+  "friend declaration|member declaration}0">;
+def note_typedef_for_linkage_here : Note<
+  "type is given name %0 for linkage purposes by this "
+  "%select{typedef|alias}1 declaration">;
+
 def err_statically_allocated_object : Error<
   "interface type cannot be statically allocated">;
 def err_object_cannot_be_passed_returned_by_value : Error<
   "interface type %1 cannot be %select{returned|passed}0 by value"
   "; did you forget * in %1?">;
 def err_parameters_retval_cannot_have_fp16_type : Error<
   "%select{parameters|function return value}0 cannot have __fp16 type; did you forget * ?">;
 def err_opencl_half_load_store : Error<

 def note_nontrivial_variadic : Note<"because it is a variadic function">;
 def note_nontrivial_subobject : Note<
   "because the function selected to %select{construct|copy|move|copy|move|"
   "destroy}2 %select{base class|field}0 of type %1 is not trivial">;
 def note_nontrivial_objc_ownership : Note<
   "because type %0 has a member with %select{no|no|__strong|__weak|"
   "__autoreleasing}1 ownership">;
 
+/// Selector for a TagTypeKind value.
+def select_tag_type_kind : TextSubstitution<
+  "%select{struct|interface|union|class|enum}0">;
+
 def err_static_data_member_not_allowed_in_anon_struct : Error<
-  "static data member %0 not allowed in anonymous struct">;
+  "static data member %0 not allowed in anonymous "
+  "%sub{select_tag_type_kind}1">;
 def ext_static_data_member_in_union : ExtWarn<
   "static data member %0 in union is a C++11 extension">, InGroup<CXX11>;
 def warn_cxx98_compat_static_data_member_in_union : Warning<
   "static data member %0 in union is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def ext_union_member_of_reference_type : ExtWarn<
   "union member %0 has reference type %1, which is a Microsoft extension">,
   InGroup<MicrosoftUnionMemberReference>;
def ext_ms_anonymous_record : ExtWarn<
   InGroup<MicrosoftAnonTag>;
 
 // C++ local classes
 def err_reference_to_local_in_enclosing_context : Error<
   "reference to local %select{variable|binding}1 %0 declared in enclosing "
   "%select{%3|block literal|lambda expression|context}2">;
 
 def err_static_data_member_not_allowed_in_local_class : Error<
-  "static data member %0 not allowed in local class %1">;
+  "static data member %0 not allowed in local %sub{select_tag_type_kind}2 %1">;
 
 // C++ derived classes
 def err_base_clause_on_union : Error<"unions cannot have base classes">;
 def err_base_must_be_class : Error<"base specifier must name a class">;
 def err_union_as_base_class : Error<"unions cannot be base classes">;
 def err_circular_inheritance : Error<
   "circular inheritance between %0 and %1">;
 def err_base_class_has_flexible_array_member : Error<

clang/lib/Sema/SemaDecl.cpp

std::tie(MCtx, ManglingContextDecl) =
       getCurrentMangleNumberContext(Tag->getDeclContext());
   if (MCtx) {
     Context.setManglingNumber(
         Tag, MCtx->getManglingNumber(
                  Tag, getMSManglingNumber(getLangOpts(), TagScope)));
   }
 }
 
+namespace {
+struct NonCLikeKind {
+  enum {
+    None,
+    BaseClass,
+    DefaultMemberInit,
+    Lambda,
+    Friend,
+    OtherMember,
+    Invalid,
+  } Kind = None;
+  SourceRange Range;
+
+  explicit operator bool() { return Kind != None; }
+};
+}
+
+/// Determine whether a class is C-like, according to the rules of C++
+/// [dcl.typedef] for anonymous classes with typedef names for linkage.
+static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD) {
+  if (RD->isInvalidDecl())
+    return {NonCLikeKind::Invalid, {}};
+
+  // C++ [dcl.typedef]p9: [P1766R1]
+  //   An unnamed class with a typedef name for linkage purposes shall not
+  //
+  //    -- have any base classes
+  if (RD->getNumBases())
+    return {NonCLikeKind::BaseClass,
+            SourceRange(RD->bases_begin()->getBeginLoc(),
+                        RD->bases_end()[-1].getEndLoc())};
+  bool Invalid = false;
+  for (Decl *D : RD->decls()) {
+    // Don't complain about things we already diagnosed.
+    if (D->isInvalidDecl()) {
+      Invalid = true;
+      continue;
+    }
+
+    //  -- have any [...] default member initializers
+    if (auto *FD = dyn_cast<FieldDecl>(D)) {
+      if (FD->hasInClassInitializer()) {
+        auto *Init = FD->getInClassInitializer();
+        return {NonCLikeKind::DefaultMemberInit,
+                Init ? Init->getSourceRange() : D->getSourceRange()};
+      }
+      continue;
+    }
+
+    // FIXME: We don't allow friend declarations. This violates the wording of
+    // P1766, but not the intent.
+    if (isa<FriendDecl>(D))
+      return {NonCLikeKind::Friend, D->getSourceRange()};
+
+    //  -- declare any members other than non-static data members, member
+    //     enumerations, or member classes,
+    if (isa<StaticAssertDecl>(D) || isa<IndirectFieldDecl>(D) ||
+        isa<EnumDecl>(D))
+      continue;
+    auto *MemberRD = dyn_cast<CXXRecordDecl>(D);
+    if (!MemberRD)
+      return {NonCLikeKind::OtherMember, D->getSourceRange()};
+
+    //  -- contain a lambda-expression,
+    if (MemberRD->isLambda())
+      return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
+
+    //  and all member classes shall also satisfy these requirements
+    //  (recursively).
+    if (MemberRD->isThisDeclarationADefinition()) {
+      if (auto Kind = getNonCLikeKindForAnonymousStruct(MemberRD))
+        return Kind;
+    }
+  }
+
+  return {Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};
+}
+
 void Sema::setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
                                         TypedefNameDecl *NewTD) {
   if (TagFromDeclSpec->isInvalidDecl())
     return;
 
   // Do nothing if the tag already has a name for linkage purposes.
   if (TagFromDeclSpec->hasNameForLinkage())
     return;
 
   // A well-formed anonymous tag must always be a TUK_Definition.
   assert(TagFromDeclSpec->isThisDeclarationADefinition());
 
   // The type must match the tag exactly;  no qualifiers allowed.
   if (!Context.hasSameType(NewTD->getUnderlyingType(),
                            Context.getTagDeclType(TagFromDeclSpec))) {
     if (getLangOpts().CPlusPlus)
       Context.addTypedefNameForUnnamedTagDecl(TagFromDeclSpec, NewTD);
     return;
   }
 
-  // If we've already computed linkage for the anonymous tag, then
-  // adding a typedef name for the anonymous decl can change that
-  // linkage, which might be a serious problem.  Diagnose this as
-  // unsupported and ignore the typedef name.  TODO: we should
-  // pursue this as a language defect and establish a formal rule
-  // for how to handle it.
-  if (TagFromDeclSpec->hasLinkageBeenComputed()) {
-    Diag(NewTD->getLocation(), diag::err_typedef_changes_linkage);
-
-    SourceLocation tagLoc = TagFromDeclSpec->getInnerLocStart();
-    tagLoc = getLocForEndOfToken(tagLoc);
-
-    llvm::SmallString<40> textToInsert;
-    textToInsert += ' ';
-    textToInsert += NewTD->getIdentifier()->getName();
-    Diag(tagLoc, diag::note_typedef_changes_linkage)
-        << FixItHint::CreateInsertion(tagLoc, textToInsert);
+  // C++ [dcl.typedef]p9: [P1766R1, applied as DR]
+  //   An unnamed class with a typedef name for linkage purposes shall [be
+  //   C-like].
+  //
+  // FIXME: Also diagnose if we've already computed the linkage. That ideally
+  // shouldn't happen, but there are constructs that the language rule doesn't
+  // disallow for which we can't reasonably avoid computing linkage early.
+  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec);
+  NonCLikeKind NonCLike = RD ? getNonCLikeKindForAnonymousStruct(RD)
+                             : NonCLikeKind();
+  bool ChangesLinkage = TagFromDeclSpec->hasLinkageBeenComputed();
+  if (NonCLike || ChangesLinkage) {
+    if (NonCLike.Kind == NonCLikeKind::Invalid)
+      return;
+
+    unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef;
+    if (ChangesLinkage) {
+      // If the linkage changes, we can't accept this as an extension.
+      if (NonCLike.Kind == NonCLikeKind::None)
+        DiagID = diag::err_typedef_changes_linkage;
+      else
+        DiagID = diag::err_non_c_like_anon_struct_in_typedef;
+    }
+
+    SourceLocation FixitLoc =
+        getLocForEndOfToken(TagFromDeclSpec->getInnerLocStart());
+    llvm::SmallString<40> TextToInsert;
+    TextToInsert += ' ';
+    TextToInsert += NewTD->getIdentifier()->getName();
+
+    Diag(FixitLoc, DiagID)
+      << isa<TypeAliasDecl>(NewTD)
+      << FixItHint::CreateInsertion(FixitLoc, TextToInsert);
+    if (NonCLike.Kind != NonCLikeKind::None) {
+      Diag(NonCLike.Range.getBegin(), diag::note_non_c_like_anon_struct)
+        << NonCLike.Kind - 1 << NonCLike.Range;
+    }
+    Diag(NewTD->getLocation(), diag::note_typedef_for_linkage_here)
+      << NewTD << isa<TypeAliasDecl>(NewTD);
+
+    if (ChangesLinkage)
       return;
   }
 
-  // Otherwise, set this is the anon-decl typedef for the tag.
+  // Otherwise, set this as the anon-decl typedef for the tag.
   TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
 }
 
 static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T) {
   switch (T) {
   case DeclSpec::TST_class:
     return 0;
   case DeclSpec::TST_struct:
if (DS.getTypeQualifiers()) {
       DS.ClearTypeQualifiers();
     }
 
     // C++ [class.union]p2:
     //   The member-specification of an anonymous union shall only
     //   define non-static data members. [Note: nested types and
     //   functions cannot be declared within an anonymous union. ]
     for (auto *Mem : Record->decls()) {
+      // Ignore invalid declarations; we already diagnosed them.
+      if (Mem->isInvalidDecl())
+        continue;
+
       if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
         // C++ [class.union]p3:
         //   An anonymous union shall not have private or protected
         //   members (clause 11).
         assert(FD->getAccess() != AS_none);
         if (FD->getAccess() != AS_public) {
           Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
             << Record->isUnion() << (FD->getAccess() == AS_protected);
if (DC->isRecord() && !CurContext->isRecord()) {
         break;
       case SC_PrivateExtern:
         llvm_unreachable("C storage class in c++!");
       }
     }
 
     if (SC == SC_Static && CurContext->isRecord()) {
       if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
-        if (RD->isLocalClass())
+        // C++ [class.static.data]p2:
+        //   A static data member shall not be a direct member of an unnamed
+        //   or local class
+        // FIXME: or of a (possibly indirectly) nested class thereof.
+        if (RD->isLocalClass()) {
           Diag(D.getIdentifierLoc(),
                diag::err_static_data_member_not_allowed_in_local_class)
-            << Name << RD->getDeclName();
-
+            << Name << RD->getDeclName() << RD->getTagKind();
+        } else if (!RD->getDeclName()) {
+          Diag(D.getIdentifierLoc(),
+               diag::err_static_data_member_not_allowed_in_anon_struct)
+            << Name << RD->getTagKind();
+          Invalid = true;
+        } else if (RD->isUnion()) {
           // C++98 [class.union]p1: If a union contains a static data member,
           // the program is ill-formed. C++11 drops this restriction.
-        if (RD->isUnion())
           Diag(D.getIdentifierLoc(),
                getLangOpts().CPlusPlus11
                  ? diag::warn_cxx98_compat_static_data_member_in_union
                  : diag::ext_static_data_member_in_union) << Name;
-        // We conservatively disallow static data members in anonymous structs.
-        else if (!RD->getDeclName())
-          Diag(D.getIdentifierLoc(),
-               diag::err_static_data_member_not_allowed_in_anon_struct)
-            << Name << RD->isUnion();
+        }
       }
     }
 
     // Match up the template parameter lists with the scope specifier, then
     // determine whether we have a template or a template specialization.
+    bool InvalidScope = false;
     TemplateParams = MatchTemplateParametersToScopeSpecifier(
         D.getDeclSpec().getBeginLoc(), D.getIdentifierLoc(),
         D.getCXXScopeSpec(),
         D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId
             ? D.getName().TemplateId
             : nullptr,
         TemplateParamLists,
-        /*never a friend*/ false, IsMemberSpecialization, Invalid);
+        /*never a friend*/ false, IsMemberSpecialization, InvalidScope);
+    Invalid |= InvalidScope;
 
     if (TemplateParams) {
       if (!TemplateParams->size() &&
           D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
         // There is an extraneous 'template<>' for this variable. Complain
         // about it, but allow the declaration of the variable.
         Diag(TemplateParams->getTemplateLoc(),
              diag::err_template_variable_noparams)

clang/test/Analysis/inlining/eager-reclamation-path-notes.cpp

 // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=text -analyzer-config graph-trim-interval=5 -analyzer-config suppress-null-return-paths=false -verify %s
 // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-output=plist-multi-file -analyzer-config graph-trim-interval=5 -analyzer-config suppress-null-return-paths=false %s -o %t.plist
 // RUN: %normalize_plist <%t.plist | diff -ub %S/Inputs/expected-plists/eager-reclamation-path-notes.cpp.plist -
 
-typedef struct {
+struct IntWrapper {
   int getValue();
-} IntWrapper;
+};
 
 IntWrapper *getNullWrapper() {
   return 0;
   // expected-note@-1 {{Returning null pointer}}
 }
 
 int memberCallBaseDisappears() {
   // In this case, we need the lvalue-to-rvalue cast for 'ptr' to disappear,

clang/test/Analysis/padding_cpp.cpp

 };
 
 class Holder1 { // no-warning
   TemplateSandwich<int> t1;
   TemplateSandwich<char> t2;
   TemplateSandwich<void *> t3;
 };
 
-typedef struct { // expected-warning{{Excessive padding in 'TypedefSandwich2'}}
+typedef struct TypedefSandwich2 { // expected-warning{{Excessive padding in 'struct TypedefSandwich2'}}
   char c1;
   typedef struct { // expected-warning{{Excessive padding in 'TypedefSandwich2::NestedTypedef'}}
     char c1;
     int i;
     char c2;
   } NestedTypedef;
   NestedTypedef t;
   char c2;

clang/test/Analysis/padding_message.cpp

 }}
 class LotsOfSpace {
   Empty e1;
   int i;
   Empty e2;
 };
 
 // expected-warning@+7{{\
-Excessive padding in 'TypedefSandwich2' (6 padding bytes, where 2 is optimal). \
+Excessive padding in 'struct TypedefSandwich2' (6 padding bytes, where 2 is optimal). \
 Optimal fields order: \
 t, \
 c1, \
 c2, \
 }}
-typedef struct {
+typedef struct TypedefSandwich2 {
   char c1;
   // expected-warning@+7{{\
 Excessive padding in 'TypedefSandwich2::NestedTypedef' (6 padding bytes, where 2 is optimal). \
 Optimal fields order: \
 i, \
 c1, \
 c2, \
 }}

clang/test/CXX/class/class.local/p4.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s 
 
 void f() {
   struct X {
-    static int a; // expected-error {{static data member 'a' not allowed in local class 'X'}}
+    static int a; // expected-error {{static data member 'a' not allowed in local struct 'X'}}
     int b;
-    
     static void f() { }
   };
 }

clang/test/CXX/class/class.union/p2-0x.cpp

 
 union U3 {
   static const int k;
   U3() : k(0) {} // expected-error {{does not name a non-static data member}}
 };
 
 struct S {
   union {
-    static const int n; // expected-error {{static members cannot be declared in an anonymous union}}
+    static const int n; // expected-error {{static data member 'n' not allowed in anonymous union}}
     int a;
     int b;
   };
 };
 static union {
-  static const int k; // expected-error {{static members cannot be declared in an anonymous union}}
+  static const int k; // expected-error {{static data member 'k' not allowed in anonymous union}}
   int n;
 };

clang/test/CXX/drs/dr4xx.cpp

 
 // dr404: na
 // (NB: also sup 594)
 
 namespace dr406 { // dr406: yes
   typedef struct {
     static int n; // expected-error {{static data member 'n' not allowed in anonymous struct}}
   } A;
+  typedef union {
+    static int n; // expected-error {{static data member 'n' not allowed in anonymous union}}
+  } B;
 }
 
 namespace dr407 { // dr407: 3.8
   struct S;
   typedef struct S S;
   void f() {
     struct S *p;
     {

clang/test/Modules/submodules-merge-defs.cpp

 // RUN: rm -rf %t
 // RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -DTEXTUAL
 // RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery
 // RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -DTEXTUAL
 // RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility
 // RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -DTEXTUAL -DEARLY_INDIRECT_INCLUDE
 // RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -fmodule-feature use_defs_twice -DIMPORT_USE_2
 
 // Trigger import of definitions, but don't make them visible.
 #include "empty.h"
 #ifdef EARLY_INDIRECT_INCLUDE
 #include "indirect.h"
+// expected-warning@defs.h:28 3{{anonymous non-C-compatible type}}
+// expected-note@defs.h:28 6{{type is}}
 #endif
 
 A pre_a;
 #ifdef IMPORT_USE_2
 // expected-error-re@-2 {{must be imported from one of {{.*}}stuff.use{{.*}}stuff.use-2}}
 #elif EARLY_INDIRECT_INCLUDE
 // expected-error@-4 {{must be imported from module 'merged-defs'}}
 #else

clang/test/OpenMP/target_map_codegen.cpp

 // CK30: [[MTYPE00:@.+]] = private {{.*}}constant [6 x i64] [i64 32, i64 281474976710659, i64 281474976710659, i64 281474976710659, i64 281474976710675, i64 281474976710675]
 
 typedef struct {
   int *ptrBase;
   int valBase;
   int *ptrBase1;
 } Base;
 
-typedef struct : public Base {
+typedef struct StructWithPtrTag : public Base {
   int *ptr;
   int *ptr2;
   int val;
   int *ptr1;
 } StructWithPtr;
 
 // CK30-DAG: call i32 @__tgt_target(i64 -1, i8* @.__omp_offloading_{{.*}}map_with_deep_copy{{.*}}_l{{[0-9]+}}.region_id, i32 6, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], i64* getelementptr inbounds ([6 x i64], [6 x i64]* [[MTYPE00]], i32 0, i32 0))
 // CK30-DAG: [[GEPS]] = getelementptr inbounds [6 x i{{64|32}}], [6 x i64]* [[SIZES:%.+]], i32 0, i32 0

clang/test/SemaCXX/anonymous-struct.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2a %s
 
 struct S {
   S();
 #if __cplusplus <= 199711L
   // expected-note@-2 {{because type 'S' has a user-provided default constructor}}
 #endif
 };
 
#endif
   static struct { // expected-warning {{does not declare anything}}
   };
   class {
     int anon_priv_field; // expected-error {{anonymous struct cannot contain a private data member}}
   };
 };
 
 template <class T> void foo(T);
-typedef struct { // expected-note {{use a tag name here to establish linkage prior to definition}}
+typedef struct { // expected-error {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration after its linkage was computed; add a tag name here to establish linkage prior to definition}}
 #if __cplusplus <= 199711L
 // expected-note@-2 {{declared here}}
 #endif
 
-  void test() {
+  void test() { // expected-note {{type is not C-compatible due to this member declaration}}
     foo(this);
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{template argument uses unnamed type}}
 #endif
   }
-} A; // expected-error {{unsupported: typedef changes linkage of anonymous type, but linkage was already computed}}
+} A; // expected-note {{type is given name 'A' for linkage purposes by this typedef declaration}}
+
+typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+  int x = 0; // expected-note {{type is not C-compatible due to this default member initializer}} expected-warning 0-1{{extension}}
+} B; // expected-note {{type is given name 'B' for linkage purposes by this typedef declaration}}
+
+typedef struct // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+: B { // expected-note {{type is not C-compatible due to this base class}}
+} C; // expected-note {{type is given name 'C' for linkage purposes by this typedef declaration}}
+
+#if __cplusplus > 201703L
+typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+  static_assert([]{ return true; }()); // expected-note {{type is not C-compatible due to this lambda expression}}
+} Lambda1; // expected-note {{type is given name 'Lambda1' for linkage purposes by this typedef declaration}}
+
+template<int> struct X {};
+typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+  X<[]{ return 0; }()> x; // expected-note {{type is not C-compatible due to this lambda expression}}
+  // FIXME: expected-error@-1 {{lambda expression cannot appear}}
+} Lambda2; // expected-note {{type is given name 'Lambda2' for linkage purposes by this typedef declaration}}
+
+typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+  enum E {
+    a = []{ return 1; }() // expected-note {{type is not C-compatible due to this lambda expression}}
+  };
+} Lambda3; // expected-note {{type is given name 'Lambda3' for linkage purposes by this typedef declaration}}
+#endif
+
+typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+  template<int> void f() {} // expected-note {{type is not C-compatible due to this member declaration}}
+} Template; // expected-note {{type is given name 'Template' for linkage purposes by this typedef declaration}}
+
+typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+  struct U {
+    void f(); // expected-note {{type is not C-compatible due to this member declaration}}
+  };
+} Nested; // expected-note {{type is given name 'Nested' for linkage purposes by this typedef declaration}}
+
+typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+  friend void f() {} // expected-note {{type is not C-compatible due to this friend declaration}}
+} Friend; // expected-note {{type is given name 'Friend' for linkage purposes by this typedef declaration}}
+
+typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
+  template<typename T> friend void f() {} // expected-note {{type is not C-compatible due to this friend declaration}}
+} FriendTemplate; // expected-note {{type is given name 'FriendTemplate' for linkage purposes by this typedef declaration}}
+
+// Check that we don't diagnose the permitted cases:
+typedef struct {
+  // (non-members)
+  _Static_assert(true, "");
+  int : 0;
+  /*empty-declaration*/;
+
+  // non-static data members
+  int a;
+  // member enumerations
+  enum E { x, y, z };
+  // member classes
+  struct S {};
+
+  // recursively
+  struct T { int a; };
+} OK;
+
+// There are still some known permitted cases that require an early linkage
+// computation. Ensure we diagnose those too.
+namespace ValidButUnsupported {
+#if __cplusplus >= 201402L
+  template<typename T> auto compute_linkage() {
+    static int n;
+    return &n;
+  }
+
+  typedef struct { // expected-error {{unsupported: anonymous type given name for linkage purposes by typedef declaration after its linkage was computed; add a tag name here to establish linkage}}
+    struct X {};
+    decltype(compute_linkage<X>()) a;
+  } A; // expected-note {{by this typedef declaration}}
+#endif
+
+  // This fails in some language modes but not others.
+  template<typename T> struct Y {
+    static const int value = 10;
+  };
+  typedef struct { // expected-error 0-1{{unsupported}}
+    enum X {};
+    int arr[Y<X>::value];
+  } B; // expected-note 0-1{{by this typedef}}
+
+  template<typename T> void f() {}
+  typedef struct { // expected-error {{unsupported}}
+    enum X {};
+    int arr[&f<X> ? 1 : 2];
+  } C; // expected-note {{by this typedef}}
+}

clang/test/SemaCXX/linkage.cpp

 // This is an IR generation test because the calculation of visibility
 // during IR gen will cause linkage to be implicitly recomputed and
 // compared against the earlier cached value.  If we had a way of
 // testing linkage directly in Sema, that would be better.
 
-// RUN: %clang_cc1 -Werror -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -Werror -Wno-non-c-typedef-for-linkage -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck %s
 
 // CHECK: @_ZZN5test61A3fooEvE3bar = linkonce_odr global i32 0, align 4
 
 // PR8926
 namespace test0 {
   typedef struct {
     void *foo() { return 0; }
   } A;

clang/test/SemaCXX/linkage2.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -std=gnu++11 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions -Wno-local-type-template-args %s -std=gnu++98
-// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions -Wno-local-type-template-args -fmodules %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-non-c-typedef-for-linkage -std=gnu++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-non-c-typedef-for-linkage -Wno-c++11-extensions -Wno-local-type-template-args %s -std=gnu++98
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-non-c-typedef-for-linkage -Wno-c++11-extensions -Wno-local-type-template-args -fmodules %s
 
 namespace test1 {
   int x; // expected-note {{previous definition is here}}
   static int y;
   void f() {} // expected-note {{previous definition is here}}
 
   extern "C" {
     extern int x; // expected-error {{declaration of 'x' has a different language linkage}}
namespace typedef_name_for_linkage {
 
   // FIXME: Ideally this would be accepted in all modes. In C++98, we trigger a
   // linkage calculation to drive the "internal linkage type as template
   // argument" warning.
   typedef struct {
     void f() { struct Inner {}; Use<Inner> ui; }
   } F;
 #if __cplusplus < 201103L
-  // expected-error@-2 {{unsupported: typedef changes linkage of anonymous type, but linkage was already computed}}
-  // expected-note@-5 {{use a tag name here}}
+  // expected-error@-4 {{given name for linkage purposes by typedef declaration after its linkage was computed}}
+  // expected-note@-4 {{due to this member}}
+  // expected-note@-4 {{by this typedef}}
 #endif
 }

clang/test/SemaCXX/undefined-internal.cpp

 #if __cplusplus < 201103L
     // expected-warning@-3 {{non-type template argument referring to function 'f' with internal linkage}}
     // expected-warning@-3 {{non-type template argument referring to function 'f' with internal linkage}}
 #endif
   }
 }
 
 namespace test7 {
-  typedef struct {
-    void bar();
+  typedef struct { // expected-warning {{add a tag name}}
+    void bar(); // expected-note {{this member}}
     void foo() {
       bar();
     }
-  } A;
+  } A; // expected-note {{this typedef}}
 }
 
 namespace test8 {
   typedef struct {
     void bar(); // expected-warning {{function 'test8::(anonymous struct)::bar' has internal linkage but is not defined}}
     void foo() {
       bar(); // expected-note {{used here}}
     }

clang/test/SemaCXX/warn-unused-filescoped.cpp

 namespace unused {
   struct {
     void func() { // expected-warning {{unused member function}}
     }
   } x; // expected-warning {{unused variable}}
 }
 
 namespace test6 {
-  typedef struct {
-    void bar();
-  } A;
+  typedef struct { // expected-warning {{add a tag name}}
+    void bar(); // expected-note {{}}
+  } A; // expected-note {{}}
 
   typedef struct {
     void bar();  // expected-warning {{unused member function 'bar'}}
   } *B;
 
   struct C {
     void bar();
   };

clang/test/SemaCXX/warn-unused-local-typedef.cpp

void template_fun_user() {
   struct Local {
     typedef int Foo; // no-diag
     typedef int Bar; // expected-warning {{unused typedef 'Bar'}}
   } p;
   template_fun(p);
 }
 
 void typedef_in_nested_name() {
-  typedef struct {
-    typedef int Foo;
-  } A;
+  typedef struct { // expected-warning {{add a tag name}}
+    typedef int Foo; // expected-note {{}}
+  } A; // expected-note {{}}
   A::Foo adsf;
 
-  using A2 = struct {
-    typedef int Foo;
+  using A2 = struct { // expected-warning {{add a tag name}} expected-note {{this alias declaration}}
+    typedef int Foo; // expected-note {{}}
   };
   A2::Foo adsf2;
 }
 
 auto sneaky() {
   struct S {
     // Local typedefs can be used after the scope they were in has closed:
     typedef int t;

clang/test/SemaTemplate/instantiate-function-2.cpp

namespace PR9654 {
   void g() {
     f<int>(0);
   }
 }
 
 namespace AliasTagDef {
   template<typename T>
   T f() {
-    using S = struct {
+    using S = struct { // expected-warning {{add a tag name}} expected-note {{}}
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{alias declarations are a C++11 extension}}
 #endif
-      T g() {
+      T g() { // expected-note {{}}
         return T();
       }
     };
     return S().g();
   }
 
   int n = f<int>();
 }

clang/www/cxx_status.html

</tr>
       </tr>
     <tr>
       <td rowspan="6">Modules</td>
       <td><a href="https://wg21.link/p1103r3">P1103R3</a></td>
       <td class="partial" align="center">Partial</td>
     </tr>
       <tr> <!-- from Cologne -->
         <td><a href="https://wg21.link/p1766r1">P1766R1</a> (<a href="#dr">DR</a>)</td>
-        <td rowspan="3" class="none" align="center">No</td>
+        <td rowspan="3" class="unreleased" align="center">Clang 11</td>
       </tr>
       <tr>
         <td><a href="https://wg21.link/p1811r0">P1811R0</a></td>
       </tr>
       <tr>
         <td><a href="https://wg21.link/p1703r1">P1703R1</a></td>
       </tr>
       <tr> <!-- from Belfast -->