Add support for injected class names and constructor initializers in C++

[a.sidorin]

Summary

The AST importer currently does not handle injected class names properly (it does not bind their types to the type of the parent as the parser would) and it doesn't handle constructor initializers at all.

This patch adds support for both of those, and also forwards the isImplicit() and isReferenced() flags for *all* declarations as is done for isUsed().

[a.sidorin]

I' d like to have some tests for this. CXXCtorInitializers can be tested with D14224-like stuff or with ASTMatchers (ASTImporterTest.cpp).
Some code samples may be found in CXX/Sema tests, you just need to port/simplify them.

lib/AST/ASTImporter.cpp

3034

In my latest patch, I have introduced a function named ImportContainerChecked(). I think it could make this code a bit more clean. What do you think?

3035

Space after '='

3041

If we move this condition (I suggest to use FromConstructor->getNumCtorIintializers() instead) upper to cover the importing loop, we may skip this loop as well.

3045

As I can see, LLVM code style avoids qualified casts.

6384

Trailing whitespace.

6389

The indentation for ?: here is a bit confusing.

6396

Training whitespace. It's pretty difficult to find them with Phabricator, could you check your patch for them?

6423

It seems like a case with indexed initializer is missed here. You can find my implementation on https://github.com/haoNoQ/clang/blob/summary-ipa-draft/lib/AST/ASTImporter.cpp#L2456-L2464.
A sample that requires it is auto parens4 = [p4(1)] {}; (test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p4.cpp)

[spyffe]

Thank you for your comments, I’m working on them now.

Sean

[spyffe]

I’m just going to use clang-format to resolve trailing whitespace/etc issues. It changes around some indentation in the class declaration for ASTImporter but that probably needs to be taken care of anyway…

Sean

[a.sidorin]

This revision seems to be already committed in rC269693, without Differential Revision set.

include/clang/AST/ASTImporter.h

 
 namespace clang {
   class ASTContext;
+  class CXXCtorInitializer;
   class Decl;
   class DeclContext;
   class DiagnosticsEngine;

     /// \returns the equivalent file ID in the source manager of the "to"
     /// context.
     FileID Import(FileID);
+
+    /// \brief Import the given C++ constructor initializer from the "from"
+    /// context into the "to" context.
+    ///
+    /// \returns the equivalent initializer in the "to" context.
+    CXXCtorInitializer *Import(const CXXCtorInitializer *FromInit);
     
     /// \brief Import the definition of the given declaration, including all of
     /// the declarations it contains.

lib/AST/ASTImporter.cpp

           return nullptr;
         D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(),
                                  CDecl);
+      } else if (DCXX->isInjectedClassName()) {
+        // We have to be careful to do a similar dance to the one in
+        // Sema::ActOnStartCXXMemberDeclarations
+        CXXRecordDecl * const PrevDecl = nullptr;
+        const bool DelayTypeCreation = true;
+        D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
+                                      D->getTagKind(),
+                                      DC, StartLoc, Loc,
+                                      Name.getAsIdentifierInfo(),
+                                      PrevDecl, DelayTypeCreation);
+        Importer.getToContext().getTypeDeclType(
+            D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC));
       } else {
         D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
                                       D->getTagKind(),

                                             D->isInlineSpecified(), 
                                             D->isImplicit(),
                                             D->isConstexpr());
+    SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
+    for (const CXXCtorInitializer *I : FromConstructor->inits()) {
+      CXXCtorInitializer *ToI =cast_or_null<CXXCtorInitializer>(
+          Importer.Import(I));
+      if (!ToI && I)
+        return nullptr;
+      CtorInitializers.push_back(ToI);
+    }
+    if (unsigned NumInitializers = CtorInitializers.size()) {
+      CXXCtorInitializer **Memory = new (Importer.getToContext())
+                                         CXXCtorInitializer*[NumInitializers];
+      std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
+      llvm::cast<CXXConstructorDecl>(ToFunction)->setCtorInitializers(Memory);
+      llvm::cast<CXXConstructorDecl>(ToFunction)->setNumCtorInitializers(
+          NumInitializers);
+    }
   } else if (isa<CXXDestructorDecl>(D)) {
     ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
                                            cast<CXXRecordDecl>(DC),

   return ToID;
 }
 
+CXXCtorInitializer *ASTImporter::Import(const CXXCtorInitializer *From) {
+  Expr *ToExpr = Import(From->getInit());
+  if (!ToExpr && From->getInit())
+    return nullptr;
+
+  if (From->isBaseInitializer()) {
+    TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
+    if (!ToTInfo && From->getTypeSourceInfo())
+      return nullptr;
+    
+    return new (ToContext)
+      CXXCtorInitializer(ToContext, ToTInfo, From->isBaseVirtual(),
+                         Import(From->getLParenLoc()), ToExpr, 
+                         Import(From->getRParenLoc()),
+                         From->isPackExpansion() ?
+                         Import(From->getEllipsisLoc()) : SourceLocation());
+  } else if (From->isMemberInitializer()) {
+    FieldDecl *ToField = llvm::cast_or_null<FieldDecl>(Import(
+        From->getMember()));
+    if (!ToField && From->getMember())
+      return nullptr;
+    
+    return new (ToContext)
+        CXXCtorInitializer(ToContext, ToField,
+                           Import(From->getMemberLocation()),
+                           Import(From->getLParenLoc()), ToExpr, 
+                           Import(From->getRParenLoc()));
+  } else if (From->isIndirectMemberInitializer()) {
+    IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>(Import(
+        From->getIndirectMember()));
+    if (!ToIField && From->getIndirectMember())
+      return nullptr;
+
+    return new (ToContext)
+        CXXCtorInitializer(ToContext, ToIField,
+                           Import(From->getMemberLocation()),
+                           Import(From->getLParenLoc()), ToExpr, 
+                           Import(From->getRParenLoc()));
+  } else if (From->isDelegatingInitializer()) {
+    TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
+    if (!ToTInfo && From->getTypeSourceInfo())
+      return nullptr;
+
+    return new (ToContext)
+        CXXCtorInitializer(ToContext, ToTInfo,
+                           Import(From->getLParenLoc()), ToExpr,
+                           Import(From->getRParenLoc()));
+  } else {
+    return nullptr;
+  }
+}
+
 void ASTImporter::ImportDefinition(Decl *From) {
   Decl *To = Import(From);
   if (!To)

   if (From->isUsed()) {
     To->setIsUsed();
   }
+  if (From->isImplicit()) {
+    To->setImplicit();
+  }
+  if (From->isReferenced()) { 
+    To->setReferenced();
+  }
   ImportedDecls[From] = To;
   return To;
 }