[Modules] Handle ObjC/C ODR-like semantics for EnumConstantDecl

[bruno]

Summary

Support for ObjC/C ODR-like semantics with structural equivalence checking was added back in r306918. There enums are handled and also checked for structural equivalence. However, at use time of EnumConstantDecl, support was missing for preventing ambiguous name lookup.

Add the missing bits for properly merging EnumConstantDecl.

rdar://problem/38374569

[rsmith]

lib/Serialization/ASTReaderDecl.cpp

2568–2570

I think this comment would benefit from more rewriting, since we've basically decided that we do want to apply the ODR merging rule to C.

[bruno]

lib/Serialization/ASTReaderDecl.cpp

2568–2570

Sure, will update that!

[bruno]

Landed in r331232 & r331233.

lib/Serialization/ASTReaderDecl.cpp

if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
           TemplatePatternID, Redecl.isKeyDecl());
 
     // If this declaration is a key declaration, make a note of that.
     if (Redecl.isKeyDecl())
       Reader.KeyDecls[ExistingCanon].push_back(Redecl.getFirstID());
   }
 }
 
+/// ODR-like semantics for C/ObjC allow us to merge tag types and a structural
+/// check in Sema guarantees the types can be merged (see C11 6.2.7/1 or C89
+/// 6.1.2.6/1). Although most merging is done in Sema, we need to guarantee
+/// that some types are mergeable during deserialization, otherwise name
+/// lookup fails. This is the case for EnumConstantDecl.
+bool allowODRLikeMergeInC(NamedDecl *ND) {
+  if (!ND)
+    return false;
+  // TODO: implement merge for other necessary decls.
+  if (dyn_cast<EnumConstantDecl>(ND))
+    return true;
+  return false;
+}
+
 /// \brief Attempts to merge the given declaration (D) with another declaration
 /// of the same entity, for the case where the entity is not actually
 /// redeclarable. This happens, for instance, when merging the fields of
 /// identical class definitions from two different modules.
 template<typename T>
 void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
   // If modules are not available, there is no reason to perform this merge.
   if (!Reader.getContext().getLangOpts().Modules)
     return;
 
   // ODR-based merging is only performed in C++. In C, identically-named things
   // in different translation units are not redeclarations (but may still have
-  // compatible types).
-  if (!Reader.getContext().getLangOpts().CPlusPlus)
+  // compatible types). However, clang is able to merge tag types with ODR-like
+  // semantics if it meets some requirements.
+  if (!Reader.getContext().getLangOpts().CPlusPlus &&
+      !allowODRLikeMergeInC(dyn_cast<NamedDecl>(static_cast<T*>(D))))
     return;
 
   if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
     if (T *Existing = ExistingRes)
       Reader.getContext().setPrimaryMergedDecl(static_cast<T *>(D),
                                                Existing->getCanonicalDecl());
 }
 

test/Modules/Inputs/non-ambiguous-enum/A.framework/Headers/a.h

+#include <A/a0.h>

test/Modules/Inputs/non-ambiguous-enum/A.framework/Headers/a0.h

+#include <B/b.h>

test/Modules/Inputs/non-ambiguous-enum/A.framework/Modules/module.modulemap

+
+framework module A {
+  header "a.h"
+  //module * { export * }
+  export *
+}

test/Modules/Inputs/non-ambiguous-enum/B.framework/Headers/b.h

+typedef long NSInteger;
+typedef enum __attribute__((flag_enum,enum_extensibility(open))) MyObjCEnum : NSInteger MyObjCEnum;
+
+enum MyObjCEnum : NSInteger {
+    MyEnumCst = 1,
+} __attribute__((availability(ios,introduced=11.0))) __attribute__((availability(tvos,unavailable))) ;

test/Modules/non-ambiguous-enum.m

+// RUN: rm -rf %t
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -F%S/Inputs/non-ambiguous-enum -fsyntax-only %s -verify
+#import <B/B.h>
+#import <A/A.h>
+
+// expected-no-diagnostics
+
+int foo() {
+  return MyEnumCst;
+}