Cleanup

Author: hlopko

include/swift/AST/ClangModuleLoader.h

@@ -176,15 +176,17 @@ class ClangModuleLoader : public ModuleLoader {
   lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) = 0;
-  /// Instantiate and import class template.
+
+  /// Instantiate and import class template using given arguments.
+  ///
+  /// This method will find the clang::ClassTemplateSpecialization decl if
+  /// it already exists, or it will create one. Then it will import this
+  /// decl the same way as we import typedeffed class templates - using
+  /// the hidden struct prefixed with `__CxxTemplateInst`.
   virtual StructDecl *
   instantiateCXXClassTemplate(clang::ClassTemplateDecl *decl,
                       ArrayRef<clang::TemplateArgument> arguments) = 0;
 
-  /// Lookup identifier for an already imported decl.
-  virtual Identifier
-  lookupIdentifier(const clang::IdentifierInfo* declName) = 0;
-
   /// Try to parse the string as a Clang function type.
   ///
   /// Returns null if there was a parsing failure.

include/swift/AST/Decl.h

@@ -3392,17 +3392,21 @@ class EnumDecl final : public NominalTypeDecl {
 /// to get the declared type ("Complex" in the above example).
 class StructDecl final : public NominalTypeDecl {
   SourceLoc StructLoc;
-  Type TemplateInstantiationType;
+  // We import C++ class template instantiations as non-generic structs
+  // with a name prefixed with `__CxxTemplateInst`. However for proper
+  // serialization we need to have an access to the bound generic type
+  // that would have produced this instantiation. This field contains
+  // such type.
+  //
+  // The field is set during the typechecking at the time when we
+  // instantiate the C++ class template.
+  Type TemplateInstantiationType = Type();
 
 public:
   StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,
              ArrayRef<TypeLoc> Inherited,
              GenericParamList *GenericParams, DeclContext *DC);
 
-  StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,
-             ArrayRef<TypeLoc> Inherited,
-             GenericParamList *GenericParams, DeclContext *DC, Type templateInstantiationType);
-
   SourceLoc getStartLoc() const { return StructLoc; }
   SourceRange getSourceRange() const {
     return SourceRange(StructLoc, getBraces().End);

include/swift/ClangImporter/ClangImporter.h

@@ -244,9 +244,6 @@ class ClangImporter final : public ClangModuleLoader {
   instantiateCXXClassTemplate(clang::ClassTemplateDecl *decl,
                       ArrayRef<clang::TemplateArgument> arguments) override;
 
-  Identifier
-  lookupIdentifier(const clang::IdentifierInfo* declName) override;
-
   /// Just like Decl::getClangNode() except we look through to the 'Code'
   /// enum of an error wrapper struct.
   ClangNode getEffectiveClangNode(const Decl *decl) const;

lib/AST/Decl.cpp

@@ -3974,21 +3974,15 @@ void EnumDecl::setRawType(Type rawType) {
 
 StructDecl::StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,
                        ArrayRef<TypeLoc> Inherited,
-                       GenericParamList *GenericParams, DeclContext *Parent, Type TemplateInstantiationType)
+                       GenericParamList *GenericParams, DeclContext *Parent)
   : NominalTypeDecl(DeclKind::Struct, Parent, Name, NameLoc, Inherited,
                     GenericParams),
-    StructLoc(StructLoc), TemplateInstantiationType(TemplateInstantiationType)
+    StructLoc(StructLoc)
 {
   Bits.StructDecl.HasUnreferenceableStorage = false;
   Bits.StructDecl.IsCxxNonTrivial = false;
 }
 
-StructDecl::StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,
-                       ArrayRef<TypeLoc> Inherited,
-                       GenericParamList *GenericParams, DeclContext *Parent)
-  : StructDecl(StructLoc, Name, NameLoc, Inherited, GenericParams, Parent, Type())
-{}
-
 bool NominalTypeDecl::hasMemberwiseInitializer() const {
   // Currently only structs can have memberwise initializers.
   auto *sd = dyn_cast<StructDecl>(this);

lib/ClangImporter/ClangImporter.cpp

@@ -4172,8 +4172,3 @@ ClangImporter::instantiateCXXClassTemplate(
   return dyn_cast_or_null<StructDecl>(
       Impl.importDecl(ctsd, Impl.CurrentVersion));
 }
-
-Identifier
-ClangImporter::lookupIdentifier(const clang::IdentifierInfo* declName) {
-  return Impl.importIdentifier(declName);
-}

lib/ClangImporter/Serializability.cpp

@@ -23,7 +23,6 @@
 
 #include "ImporterImpl.h"
 #include "swift/ClangImporter/SwiftAbstractBasicWriter.h"
-#include "clang/AST/DeclTemplate.h"
 
 using namespace swift;
 
@@ -73,12 +72,9 @@ class SerializationPathFinder {
       // easier to just avoid doing so and fall into the external-path code.
       if (!isa<TypeAliasDecl>(swiftDecl)) {
         // Only accept this declaration if it round-trips.
-        if (auto swiftClangDecl = swiftDecl->getClangDecl()) {
-          if (!isa<clang::ClassTemplateSpecializationDecl>(swiftClangDecl)) {
+        if (auto swiftClangDecl = swiftDecl->getClangDecl())
             if (isSameDecl(decl, swiftClangDecl))
               return swiftDecl;
-          }
-        }
       }
     }
 
@@ -106,7 +102,7 @@ class SerializationPathFinder {
   bool findExternalPath(const clang::TagDecl *decl, ExternalPath &path) {
     // We can't handle class template specializations right now.
     if (isa<clang::ClassTemplateSpecializationDecl>(decl))
-      decl->dump();
+      return false;
 
     // Named tags are straightforward.
     if (auto name = decl->getIdentifier()) {

lib/Serialization/DeclTypeRecordNodes.def

@@ -151,6 +151,7 @@ PATTERN(VAR)
 OTHER(PARAMETERLIST, 210)
 // 211 is unused
 OTHER(FOREIGN_ERROR_CONVENTION, 212)
+// 213 is unused
 OTHER(XREF_TYPE_PATH_PIECE, 214)
 OTHER(XREF_VALUE_PATH_PIECE, 215)
 OTHER(XREF_EXTENSION_PATH_PIECE, 216)
@@ -194,7 +195,6 @@ OTHER(XREF_OPAQUE_RETURN_TYPE_PATH_PIECE, 252)
 OTHER(CLANG_TYPE, 253)
 
 OTHER(DERIVATIVE_FUNCTION_CONFIGURATION, 254)
-OTHER(XREF_CLANG_TEMPLATE_INSTANTIATION, 255)
 
 
 #undef RECORD

lib/Serialization/Deserialization.cpp

@@ -1391,39 +1391,6 @@ ModuleFile::resolveCrossReference(ModuleID MID, uint32_t pathLen) {
   case XREF_INITIALIZER_PATH_PIECE:
     llvm_unreachable("only in a nominal or function");
 
-  case XREF_CLANG_TEMPLATE_INSTANTIATION: {
-    auto &astContext = getContext();
-    auto clangModuleLoader = astContext.getClangModuleLoader();
-    auto clangImporter = static_cast<ClangImporter *>(clangModuleLoader);
-    auto &clangASTContext = clangModuleLoader->getClangASTContext();
-
-    ClangTypeID clangTypeId;
-    XRefClangTemplateInstantiationLayout::readRecord(scratch, clangTypeId);
-
-    const clang::Type *clangInstantiationType = nullptr;
-    auto loadedClangType = getClangType(clangTypeId);
-    if (!loadedClangType) {
-      return loadedClangType.takeError();
-      clangInstantiationType = loadedClangType.get();
-    }
-
-    auto decl = clangInstantiationType->getAsCXXRecordDecl();
-    decl->dump();
-
-    llvm_unreachable("only in a nominal or function");
-    return nullptr;
-
-    // clangInstantiationType
-    // clangModuleLoader->lookup(clangInstantiationType);
-
-    // auto *classTemplateDecl = const_cast<clang::ClassTemplateDecl *>(
-    //     dyn_cast<clang::ClassTemplateDecl>(templateDecl->getClangDecl()));
-    // assert(classTemplateDecl);
-
-    // auto *instantiation = clangModuleLoader->instantiateCXXClassTemplate(
-    //     classTemplateDecl, templateArguments);
-    // return instantiation;
-  }
   default:
     // Unknown xref kind.
     pathTrace.addUnknown(recordID);

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 591; // XRefClangTemplateInstantiation added
+const uint16_t SWIFTMODULE_VERSION_MINOR = 590; // differentiable_function_extract explicit extractee type
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1714,11 +1714,6 @@ namespace decls_block {
     BCVBR<5>  // index
   >;
 
-  using XRefClangTemplateInstantiationLayout = BCRecordLayout<
-    XREF_CLANG_TEMPLATE_INSTANTIATION,
-    ClangTypeIDField
-  >;
-
   using SILGenNameDeclAttrLayout = BCRecordLayout<
     SILGenName_DECL_ATTR,
     BCFixed<1>, // implicit flag

lib/Serialization/Serialization.cpp

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "Serialization.h"
-#include "ModuleFormat.h"
 #include "SILFormat.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
@@ -76,20 +75,6 @@ using swift::version::Version;
 using llvm::BCBlockRAII;
 
 
-static Type getResultInterfaceTypeForSerialization(Type t) {
-  if (!t)
-    return t;
-  if (auto nominalDecl = t->getAnyNominal()) {
-    if (auto structDecl = dyn_cast<StructDecl>(nominalDecl)) {
-      if (auto templateInstantiationType =
-              structDecl->getTemplateInstantiationType()) {
-        return templateInstantiationType;
-      }
-    }
-  }
-  return t;
-}
-
 ASTContext &SerializerBase::getASTContext() {
   return M->getASTContext();
 }
@@ -643,14 +628,25 @@ DeclID Serializer::addDeclRef(const Decl *D, bool allowTypeAliasXRef) {
 }
 
 serialization::TypeID Serializer::addTypeRef(Type ty) {
-  auto tyToSerialize = getResultInterfaceTypeForSerialization(ty);
+  Type typeToSerialize = ty;
+  if (ty) {
+    if (auto nominalDecl = ty->getAnyNominal()) {
+      if (auto structDecl = dyn_cast<StructDecl>(nominalDecl)) {
+        if (auto templateInstantiationType =
+                structDecl->getTemplateInstantiationType()) {
+          typeToSerialize = templateInstantiationType;
+        }
+      }
+    }
+  }
+
 #ifndef NDEBUG
-  PrettyStackTraceType trace(M->getASTContext(), "serializing", tyToSerialize);
+  PrettyStackTraceType trace(M->getASTContext(), "serializing", typeToSerialize);
   assert(M->getASTContext().LangOpts.AllowModuleWithCompilerErrors ||
-         !tyToSerialize || !ty->hasError() && "serializing type with an error");
+         !typeToSerialize || !typeToSerialize->hasError() && "serializing type with an error");
 #endif
 
-  return TypesToSerialize.addRef(tyToSerialize);
+  return TypesToSerialize.addRef(typeToSerialize);
 }
 
 serialization::ClangTypeID Serializer::addClangTypeRef(const clang::Type *ty) {