[clang][modules] Add support for merging lifetime-extended temporaries

[Tyker]

Summary

Add support for merging lifetime-extended temporaries

[rsmith]

Functionally, this looks good, thanks.

clang/include/clang/Serialization/ASTReader.h

555

Typos:

"[...] merging.
containg the [...]"

->

"[...] merging,
containing the [...]"

clang/lib/AST/TextNodeDumper.cpp

1349–1350

We shouldn't need this: the address of the declaration is dumped anyway by the infrastructure. (If you meant to dump the subexpression, I don't think that's what this does.)

Traversing from the LifetimeExtendedTemporaryDecl to its subexpression for dumping purposes should be done by ASTNodeTraverser (in include/clang/AST/ASTNodeTraverser.h).

clang/lib/Serialization/ASTReaderDecl.cpp

2594

* on the right, please.

2602

This case is essentially entirely different from the primary implementation of mergeMergeable. Consider adding an overload or explicit specialization for the LifetimeExtendedTemporaryDecl case instead; we don't need the branch on the dyn_cast result below, and we don't need the allowODRLikeMergeInC check above (because lifetime-extended temporaries only exist in C++).

2603

We shouldn't be dumping from here :)

2605

Prefer the normal container interface here -- insert or operator[] -- rather than the nonstandard extension FindAndConstruct.

[Tyker]

fixed most comments.

[Tyker]

clang/lib/AST/TextNodeDumper.cpp

1349–1350

I needed it during debugging and I thought i could be useful to others. but yes it is unreachable from -ast-dump

If you meant to dump the subexpression, I don't think that's what this does.

it dumps the value of the pointer which can be used to know which MaterializedTemporaryExpr it is associated with.

[Tyker]

clang/lib/AST/TextNodeDumper.cpp

1349–1350

ill add the traversal in the previous patch and remove subexpr here because it is better

[Tyker]

fixed comments

[Tyker]

@rsmith ping

[xbolva00]

clang/test/Modules/Inputs/merge-lifetime-extended-temporary/module.modulemap

15

Add newline here.

Dtto in other tests above.

[Tyker]

rebased
added new lines.

clang/include/clang/AST/DeclCXX.h

public:
   }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == NamespaceAlias; }
 };
 
 /// Implicit declaration of a temporary that was materialized by
 /// a MaterializeTemporaryExpr and lifetime-extended by a declaration
-class LifetimeExtendedTemporaryDecl final : public Decl {
+class LifetimeExtendedTemporaryDecl final
+    : public Decl,
+      public Mergeable<LifetimeExtendedTemporaryDecl> {
   friend class MaterializeTemporaryExpr;
   friend class ASTDeclReader;
 
   Stmt *ExprWithTemporary = nullptr;
 
   /// The declaration which lifetime-extended this reference, if any.
   /// Either a VarDecl, or (for a ctor-initializer) a FieldDecl.
   ValueDecl *ExtendingDecl = nullptr;

clang/include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitObjCProtocolDecl(const ObjCProtocolDecl *D);
   void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D);
   void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
   void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
   void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
   void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
   void VisitBlockDecl(const BlockDecl *D);
   void VisitConceptDecl(const ConceptDecl *D);
+  void
+  VisitLifetimeExtendedTemporaryDecl(const LifetimeExtendedTemporaryDecl *D);
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_TEXTNODEDUMPER_H

clang/include/clang/Serialization/ASTReader.h

private:
   llvm::DenseMap<std::pair<DeclContext *, IdentifierInfo *>, NamedDecl *>
       ImportedTypedefNamesForLinkage;
 
   /// Mergeable declaration contexts that have anonymous declarations
   /// within them, and those anonymous declarations.
   llvm::DenseMap<Decl*, llvm::SmallVector<NamedDecl*, 2>>
     AnonymousDeclarationsForMerging;
 
+  /// Key used to identify LifetimeExtendedTemporaryDecl for merging,
+  /// containing the lifetime-extending declaration and the mangling number.
+  using LETemporaryKey = std::pair<Decl *, unsigned>;
+
+  /// Map of already deserialiazed temporaries.
+  llvm::DenseMap<LETemporaryKey, LifetimeExtendedTemporaryDecl *>
+      LETemporaryForMerging;
+
   struct FileDeclsInfo {
     ModuleFile *Mod = nullptr;
     ArrayRef<serialization::LocalDeclID> Decls;
 
     FileDeclsInfo() = default;
     FileDeclsInfo(ModuleFile *Mod, ArrayRef<serialization::LocalDeclID> Decls)
         : Mod(Mod), Decls(Decls) {}
   };

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitFunctionDecl(const FunctionDecl *D) {
   // Since NumParams comes from the FunctionProtoType of the FunctionDecl and
   // the Params are set later, it is possible for a dump during debugging to
   // encounter a FunctionDecl that has been created but hasn't been assigned
   // ParmVarDecls yet.
   if (!D->param_empty() && !D->param_begin())
     OS << " <<<NULL params x " << D->getNumParams() << ">>>";
 }
 
+void TextNodeDumper::VisitLifetimeExtendedTemporaryDecl(
+    const LifetimeExtendedTemporaryDecl *D) {
+  OS << " extended by ";
+  dumpBareDeclRef(D->getExtendingDecl());
+  OS << " mangling ";
+  {
+    ColorScope Color(OS, ShowColors, ValueColor);
+    OS << D->getManglingNumber();
+  }
+}
+
 void TextNodeDumper::VisitFieldDecl(const FieldDecl *D) {
   dumpName(D);
   dumpType(D->getType());
   if (D->isMutable())
     OS << " mutable";
   if (D->isModulePrivate())
     OS << " __module_private__";
 }

clang/lib/Serialization/ASTReaderDecl.cpp

public:
     template<typename T>
     void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
                            RedeclarableResult &Redecl,
                            DeclID TemplatePatternID = 0);
 
     template<typename T>
     void mergeMergeable(Mergeable<T> *D);
 
+    template <>
+    void mergeMergeable(Mergeable<LifetimeExtendedTemporaryDecl> *D);
+
     void mergeTemplatePattern(RedeclarableTemplateDecl *D,
                               RedeclarableTemplateDecl *Existing,
                               DeclID DsID, bool IsKeyDecl);
 
     ObjCTypeParamList *ReadObjCTypeParamList();
 
     // FIXME: Reorder according to DeclNodes.td?
     void VisitObjCMethodDecl(ObjCMethodDecl *D);

 void ASTDeclReader::VisitLifetimeExtendedTemporaryDecl(
     LifetimeExtendedTemporaryDecl *D) {
   VisitDecl(D);
   D->ExtendingDecl = ReadDeclAs<ValueDecl>();
   D->ExprWithTemporary = Record.readStmt();
   if (Record.readInt())
     D->Value = new (D->getASTContext()) APValue(Record.readAPValue());
   D->ManglingNumber = Record.readInt();
+  mergeMergeable(D);
 }
 
 std::pair<uint64_t, uint64_t>
 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
   uint64_t LexicalOffset = ReadLocalOffset();
   uint64_t VisibleOffset = ReadLocalOffset();
   return std::make_pair(LexicalOffset, VisibleOffset);
 }
static bool allowODRLikeMergeInC(NamedDecl *ND) {
   if (!ND)
     return false;
   // TODO: implement merge for other necessary decls.
   if (isa<EnumConstantDecl>(ND))
     return true;
   return false;
 }
 
+/// Attempts to merge LifetimeExtendedTemporaryDecl with
+/// identical class definitions from two different modules.
+template<>
+void ASTDeclReader::mergeMergeable(
+    Mergeable<LifetimeExtendedTemporaryDecl> *D) {
+  // If modules are not available, there is no reason to perform this merge.
+  if (!Reader.getContext().getLangOpts().Modules)
+    return;
+
+  LifetimeExtendedTemporaryDecl *LETDecl =
+      static_cast<LifetimeExtendedTemporaryDecl *>(D);
+
+  LifetimeExtendedTemporaryDecl *&LookupResult =
+      Reader.LETemporaryForMerging[std::make_pair(
+          LETDecl->getExtendingDecl(), LETDecl->getManglingNumber())];
+  if (LookupResult)
+    Reader.getContext().setPrimaryMergedDecl(LETDecl,
+                                             LookupResult->getCanonicalDecl());
+  else
+    LookupResult = LETDecl;
+}
+
 /// 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 performed in C++ and in some cases (tag types) in C.
   // Note that C identically-named things in different translation units are
   // not redeclarations, but may still have compatible types, where ODR-like
   // semantics may apply.
   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());
 }
 
 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
   VisitDecl(D);
   unsigned NumVars = D->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i) {

clang/test/Modules/Inputs/merge-lifetime-extended-temporary/a.h

+
+constexpr const int& LETemp = 0;

clang/test/Modules/Inputs/merge-lifetime-extended-temporary/b.h

+
+#include "a.h"
+
+constexpr const int* PtrTemp1 = &LETemp;

clang/test/Modules/Inputs/merge-lifetime-extended-temporary/c.h

+
+#include "a.h"
+
+constexpr const int* PtrTemp2 = &LETemp;

clang/test/Modules/Inputs/merge-lifetime-extended-temporary/module.modulemap

+module "a" {
+  export *
+  header "a.h"
+}
+
+module "b" {
+  export *
+  header "b.h"
+}
+
+module "c" {
+  export *
+  header "c.h"
+}

clang/test/Modules/merge-lifetime-extended-temporary.cpp

+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-lifetime-extended-temporary -verify -std=c++11 %s -DORDER=1
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-lifetime-extended-temporary -verify -std=c++11 %s -DORDER=2
+
+// expected-no-diagnostics
+#if ORDER == 1
+#include "c.h"
+#include "b.h"
+#else
+#include "b.h"
+#include "c.h"
+#endif
+
+static_assert(PtrTemp1 == &LETemp, "");
+static_assert(PtrTemp1 == PtrTemp2, "");