Revert "Merge pull request swiftlang#41928 from hyp/i/ref-ptm"

This reverts commit e5bd9da, reversing
changes made to b07b700.

Author: hyp

lib/PrintAsClang/CMakeLists.txt

@@ -3,7 +3,6 @@ add_swift_host_library(swiftPrintAsClang STATIC
   CxxSynthesis.cpp
   DeclAndTypePrinter.cpp
   ModuleContentsWriter.cpp
-  PrimitiveTypeMapping.cpp
   PrintAsClang.cpp)
 target_link_libraries(swiftPrintAsClang PRIVATE
   swiftAST

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -12,7 +12,6 @@
 
 #include "DeclAndTypePrinter.h"
 #include "CxxSynthesis.h"
-#include "PrimitiveTypeMapping.h"
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
@@ -1443,7 +1442,7 @@ class DeclAndTypePrinter::Implementation
   /// Otherwise returns null.
   const ClassDecl *getObjCBridgedClass(const NominalTypeDecl *nominal) {
     // Print known types as their unbridged type.
-    if (owningPrinter.typeMapping.getKnownObjCTypeInfo(nominal))
+    if (getKnownTypeInfo(nominal))
       return nullptr;
 
     // Print imported bridgeable decls as their unbridged type.
@@ -1547,6 +1546,102 @@ class DeclAndTypePrinter::Implementation
     return false;
   }
 
+  /// If \p typeDecl is one of the standard library types used to map in Clang
+  /// primitives and basic types, return the info in \c specialNames containing
+  /// the Clang name and whether it can be nullable in C.
+  Optional<CTypeInfo> getKnownTypeInfo(const TypeDecl *typeDecl) {
+    auto &specialNames = owningPrinter.specialNames;
+    if (specialNames.empty()) {
+      ASTContext &ctx = getASTContext();
+#define MAP(SWIFT_NAME, CLANG_REPR, NEEDS_NULLABILITY)                       \
+      specialNames[{ctx.StdlibModuleName, ctx.getIdentifier(#SWIFT_NAME)}] = \
+        { CLANG_REPR, NEEDS_NULLABILITY }
+
+      MAP(CBool, "bool", false);
+
+      MAP(CChar, "char", false);
+      MAP(CWideChar, "wchar_t", false);
+      MAP(CChar16, "char16_t", false);
+      MAP(CChar32, "char32_t", false);
+
+      MAP(CSignedChar, "signed char", false);
+      MAP(CShort, "short", false);
+      MAP(CInt, "int", false);
+      MAP(CLong, "long", false);
+      MAP(CLongLong, "long long", false);
+
+      MAP(CUnsignedChar, "unsigned char", false);
+      MAP(CUnsignedShort, "unsigned short", false);
+      MAP(CUnsignedInt, "unsigned int", false);
+      MAP(CUnsignedLong, "unsigned long", false);
+      MAP(CUnsignedLongLong, "unsigned long long", false);
+
+      MAP(CFloat, "float", false);
+      MAP(CDouble, "double", false);
+
+      MAP(Int8, "int8_t", false);
+      MAP(Int16, "int16_t", false);
+      MAP(Int32, "int32_t", false);
+      MAP(Int64, "int64_t", false);
+      MAP(UInt8, "uint8_t", false);
+      MAP(UInt16, "uint16_t", false);
+      MAP(UInt32, "uint32_t", false);
+      MAP(UInt64, "uint64_t", false);
+
+      MAP(Float, "float", false);
+      MAP(Double, "double", false);
+      MAP(Float32, "float", false);
+      MAP(Float64, "double", false);
+
+      MAP(Int, "NSInteger", false);
+      MAP(UInt, "NSUInteger", false);
+      MAP(Bool, "BOOL", false);
+
+      MAP(OpaquePointer, "void *", true);
+      MAP(UnsafeRawPointer, "void const *", true);
+      MAP(UnsafeMutableRawPointer, "void *", true);
+
+      Identifier ID_ObjectiveC = ctx.Id_ObjectiveC;
+      specialNames[{ID_ObjectiveC, ctx.getIdentifier("ObjCBool")}]
+        = { "BOOL", false};
+      specialNames[{ID_ObjectiveC, ctx.getIdentifier("Selector")}]
+        = { "SEL", true };
+      specialNames[{ID_ObjectiveC,
+                    ctx.getIdentifier(
+                      ctx.getSwiftName(KnownFoundationEntity::NSZone))}]
+        = { "struct _NSZone *", true };
+
+      specialNames[{ctx.Id_Darwin, ctx.getIdentifier("DarwinBoolean")}]
+        = { "Boolean", false};
+
+      specialNames[{ctx.Id_CoreGraphics, ctx.Id_CGFloat}]
+        = { "CGFloat", false };
+
+      specialNames[{ctx.Id_CoreFoundation, ctx.Id_CGFloat}]
+        = { "CGFloat", false };
+
+      // Use typedefs we set up for SIMD vector types.
+#define MAP_SIMD_TYPE(BASENAME, _, __) \
+      specialNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "2")}] \
+        = { "swift_" #BASENAME "2", false };                        \
+      specialNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "3")}] \
+        = { "swift_" #BASENAME "3", false };                        \
+      specialNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "4")}] \
+        = { "swift_" #BASENAME "4", false };
+#include "swift/ClangImporter/SIMDMappedTypes.def"
+      static_assert(SWIFT_MAX_IMPORTED_SIMD_ELEMENTS == 4,
+                    "must add or remove special name mappings if max number of "
+                    "SIMD elements is changed");
+    }
+
+    Identifier moduleName = typeDecl->getModuleContext()->getName();
+    Identifier name = typeDecl->getName();
+    auto iter = specialNames.find({moduleName, name});
+    if (iter == specialNames.end())
+      return None;
+    return iter->second;
+  }
+
   /// If \p typeDecl is one of the standard library types used to map in Clang
   /// primitives and basic types, print out the appropriate spelling and
   /// return true.
@@ -1555,8 +1650,7 @@ class DeclAndTypePrinter::Implementation
   /// for interfacing with C and Objective-C.
   bool printIfKnownSimpleType(const TypeDecl *typeDecl,
                               Optional<OptionalTypeKind> optionalKind) {
-    auto knownTypeInfo =
-        owningPrinter.typeMapping.getKnownObjCTypeInfo(typeDecl);
+    Optional<CTypeInfo> knownTypeInfo = getKnownTypeInfo(typeDecl);
     if (!knownTypeInfo)
       return false;
     os << knownTypeInfo->name;

lib/PrintAsClang/DeclAndTypePrinter.h

@@ -25,8 +25,6 @@ namespace clang {
 
 namespace swift {
 
-class PrimitiveTypeMapping;
-
 /// Responsible for printing a Swift Decl or Type in Objective-C, to be
 /// included in a Swift module's ObjC compatibility header.
 class DeclAndTypePrinter {
@@ -41,10 +39,22 @@ class DeclAndTypePrinter {
   raw_ostream &os;
   raw_ostream &prologueOS;
   const DelayedMemberSet &delayedMembers;
-  PrimitiveTypeMapping &typeMapping;
   AccessLevel minRequiredAccess;
   OutputLanguageMode outputLang;
 
+  struct CTypeInfo {
+    StringRef name;
+    bool canBeNullable;
+  };
+
+  /// A map from {Module, TypeName} pairs to {C name, C nullability} pairs.
+  ///
+  /// This is populated on first use with a list of known Swift types that are
+  /// translated directly by the ObjC printer instead of structurally, allowing
+  /// it to do things like map 'Int' to 'NSInteger' and 'Float' to 'float'.
+  /// In some sense it's the reverse of the ClangImporter's MappedTypes.def.
+  llvm::DenseMap<std::pair<Identifier, Identifier>, CTypeInfo> specialNames;
+
   /// The name 'CFTypeRef'.
   ///
   /// Cached for convenience.
@@ -54,12 +64,10 @@ class DeclAndTypePrinter {
 
 public:
   DeclAndTypePrinter(ModuleDecl &mod, raw_ostream &out, raw_ostream &prologueOS,
-                     DelayedMemberSet &delayed,
-                     PrimitiveTypeMapping &typeMapping, AccessLevel access,
+                     DelayedMemberSet &delayed, AccessLevel access,
                      OutputLanguageMode outputLang)
       : M(mod), os(out), prologueOS(prologueOS), delayedMembers(delayed),
-        typeMapping(typeMapping), minRequiredAccess(access),
-        outputLang(outputLang) {}
+        minRequiredAccess(access), outputLang(outputLang) {}
 
   /// Returns true if \p VD should be included in a compatibility header for
   /// the options the printer was constructed with.

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -15,7 +15,6 @@
 #include "CxxSynthesis.h"
 #include "DeclAndTypePrinter.h"
 #include "OutputLanguageMode.h"
-#include "PrimitiveTypeMapping.h"
 
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Module.h"
@@ -124,7 +123,6 @@ class ModuleWriter {
   llvm::DenseMap<const TypeDecl *, std::pair<EmissionState, bool>> seenTypes;
   std::vector<const Decl *> declsToWrite;
   DelayedMemberSet delayedMembers;
-  PrimitiveTypeMapping typeMapping;
   DeclAndTypePrinter printer;
   OutputLanguageMode outputLangMode;
 
@@ -133,8 +131,7 @@ class ModuleWriter {
                llvm::SmallPtrSetImpl<ImportModuleTy> &imports, ModuleDecl &mod,
                AccessLevel access, OutputLanguageMode outputLang)
       : os(os), imports(imports), M(mod),
-        printer(M, os, prologueOS, delayedMembers, typeMapping, access,
-                outputLang),
+        printer(M, os, prologueOS, delayedMembers, access, outputLang),
         outputLangMode(outputLang) {}
 
   /// Returns true if we added the decl's module to the import set, false if