Merge pull request #29239 from varungandhi-apple/vg-clang-types-in-sil

Propagate Clang types through SIL

Author: varungandhi-apple

include/swift/AST/ASTContext.h

@@ -582,6 +582,10 @@ class ASTContext final {
   Type getBridgedToObjC(const DeclContext *dc, Type type,
                         Type *bridgedValueType = nullptr) const;
 
+private:
+  void initializeClangTypeConverter();
+
+public:
   /// Get the Clang type corresponding to a Swift function type.
   ///
   /// \param params The function parameters.
@@ -595,6 +599,15 @@ class ASTContext final {
                        const FunctionType::ExtInfo incompleteExtInfo,
                        FunctionTypeRepresentation trueRep);
 
+  /// Get the canonical Clang type corresponding to a SIL function type.
+  ///
+  /// SIL analog of \c ASTContext::getClangFunctionType .
+  const clang::Type *
+  getCanonicalClangFunctionType(
+    ArrayRef<SILParameterInfo> params, Optional<SILResultInfo> result,
+    const SILFunctionType::ExtInfo incompleteExtInfo,
+    SILFunctionType::Representation trueRep);
+
   /// Determine whether the given Swift type is representable in a
   /// given foreign language.
   ForeignRepresentationInfo

include/swift/AST/PrintOptions.h

@@ -564,7 +564,7 @@ struct PrintOptions {
   static PrintOptions printDocInterface();
 
   /// Retrieve the set of options suitable for printing SIL functions.
-  static PrintOptions printSIL() {
+  static PrintOptions printSIL(bool printFullConvention = false) {
     PrintOptions result;
     result.PrintLongAttrsOnSeparateLines = true;
     result.PrintStorageRepresentationAttrs = true;
@@ -575,6 +575,9 @@ struct PrintOptions {
     result.PrintIfConfig = false;
     result.OpaqueReturnTypePrinting =
         OpaqueReturnTypePrintingMode::StableReference;
+    if (printFullConvention)
+      result.PrintFunctionRepresentationAttrs =
+        PrintOptions::FunctionRepresentationMode::Full;
     return result;
   }
 

include/swift/AST/SILOptions.h

@@ -78,6 +78,9 @@ class SILOptions {
   /// variables by name when we print it out. This eases diffing of SIL files.
   bool EmitSortedSIL = false;
 
+  /// See \ref FrontendOptions.PrintFullConvention
+  bool PrintFullConvention = false;
+
   /// Whether to stop the optimization pipeline after serializing SIL.
   bool StopOptimizationAfterSerialization = false;
 

include/swift/AST/Types.h

@@ -44,7 +44,6 @@
 
 namespace clang {
 class Type;
-class FunctionType;
 } // namespace clang
 
 namespace llvm {
@@ -2947,6 +2946,7 @@ class AnyFunctionType : public TypeBase {
       friend ExtInfo;
       friend class AnyFunctionType;
       friend class FunctionType;
+      friend class SILUncommonInfo;
       // We preserve a full clang::Type *, not a clang::FunctionType * as:
       // 1. We need to keep sugar in case we need to present an error to the user.
       // 2. The actual type being stored is [ignoring sugar] either a
@@ -2969,7 +2969,7 @@ class AnyFunctionType : public TypeBase {
     static void assertIsFunctionType(const clang::Type *);
 
     ExtInfo(unsigned Bits, Uncommon Other) : Bits(Bits), Other(Other) {
-      // TODO: [store-sil-clang-function-type] Once we start serializing
+      // TODO: [clang-function-type-serialization] Once we start serializing
       // the Clang type, we should also assert that the pointer is non-null.
       auto Rep = Representation(Bits & RepresentationMask);
       if ((Rep == Representation::CFunctionPointer) && Other.ClangFunctionType)
@@ -3917,6 +3917,24 @@ namespace Lowering {
   class TypeConverter;
 };
 
+class SILUncommonInfo {
+  friend class SILFunctionType;
+
+  // Invariant: The FunctionType is canonical.
+  // We store a clang::FunctionType * instead of a clang::CanQualType to
+  // avoid depending on the Clang AST in this header.
+  const clang::Type *ClangFunctionType;
+
+  bool empty() const { return !ClangFunctionType; }
+  SILUncommonInfo(const clang::Type *type) : ClangFunctionType(type) {}
+  SILUncommonInfo(AnyFunctionType::ExtInfo::Uncommon uncommon);
+
+public:
+  /// Analog of AnyFunctionType::ExtInfo::Uncommon::printClangFunctionType.
+  void printClangFunctionType(ClangModuleLoader *cml,
+                              llvm::raw_ostream &os) const;
+};
+
 /// SILFunctionType - The lowered type of a function value, suitable
 /// for use by SIL.
 ///
@@ -3925,7 +3943,8 @@ namespace Lowering {
 /// function parameter and result types.
 class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     private llvm::TrailingObjects<SILFunctionType, SILParameterInfo,
-                                  SILResultInfo, SILYieldInfo, CanType> {
+                                  SILResultInfo, SILYieldInfo, CanType,
+                                  SILUncommonInfo> {
   friend TrailingObjects;
 
   size_t numTrailingObjects(OverloadToken<SILParameterInfo>) const {
@@ -3944,6 +3963,10 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     return hasResultCache() ? 2 : 0;
   }
 
+  size_t numTrailingObjects(OverloadToken<SILUncommonInfo>) const {
+    return Bits.SILFunctionType.HasUncommonInfo ? 1 : 0;
+  }
+
 public:
   using Language = SILFunctionLanguage;
   using Representation = SILFunctionTypeRepresentation;
@@ -3968,27 +3991,31 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
 
     unsigned Bits; // Naturally sized for speed.
 
-    class Uncommon {
-      friend ExtInfo;
-      friend class SILFunctionType;
-
-      // Invariant: The FunctionType is canonical.
-      // We store a clang::FunctionType * instead of a clang::CanQualType to
-      // avoid depending on the Clang AST in this header.
-      const clang::FunctionType *ClangFunctionType;
+    // For symmetry with AnyFunctionType::Uncommon
+    using Uncommon = SILUncommonInfo;
 
-      bool empty() const { return !ClangFunctionType; }
-      Uncommon(const clang::FunctionType *type) : ClangFunctionType(type) {}
+    Uncommon Other;
 
-    public:
-      /// Analog of AnyFunctionType::ExtInfo::Uncommon::printClangFunctionType.
-      void printClangFunctionType(ClangModuleLoader *cml,
-                                  llvm::raw_ostream &os) const;
-    };
+    static void assertIsFunctionType(const clang::Type *);
 
-    Uncommon Other;
+    ExtInfo(unsigned Bits, Uncommon Other) : Bits(Bits), Other(Other) {
+      auto Rep = Representation(Bits & RepresentationMask);
+      // TODO: [clang-function-type-serialization] Once we start serializing
+      // the Clang type, we should also assert that the pointer is non-null.
+      if ((Rep == Representation::CFunctionPointer) && Other.ClangFunctionType)
+        assertIsFunctionType(Other.ClangFunctionType);
+    }
 
-    ExtInfo(unsigned Bits, Uncommon Other) : Bits(Bits), Other(Other) {}
+    static constexpr unsigned makeBits(Representation rep,
+                                       bool isPseudogeneric,
+                                       bool isNoEscape,
+                                       DifferentiabilityKind diffKind) {
+      return ((unsigned) rep)
+              | (isPseudogeneric ? PseudogenericMask : 0)
+              | (isNoEscape ? NoEscapeMask : 0)
+              | (((unsigned)diffKind << DifferentiabilityMaskOffset)
+                 & DifferentiabilityMask);
+    }
 
     friend class SILFunctionType;
   public:
@@ -3998,15 +4025,21 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     // Constructor for polymorphic type.
     ExtInfo(Representation rep, bool isPseudogeneric, bool isNoEscape,
             DifferentiabilityKind diffKind,
-            const clang::FunctionType *type)
-      : ExtInfo(((unsigned) rep)
-                  | (isPseudogeneric ? PseudogenericMask : 0)
-                  | (isNoEscape ? NoEscapeMask : 0)
-                  | (((unsigned)diffKind << DifferentiabilityMaskOffset)
-                     & DifferentiabilityMask),
+            const clang::Type *type)
+      : ExtInfo(makeBits(rep, isPseudogeneric, isNoEscape, diffKind),
                 Uncommon(type)) {
     }
 
+    ExtInfo(AnyFunctionType::ExtInfo info, bool isPseudogeneric)
+      : ExtInfo(makeBits(info.getSILRepresentation(),
+                         isPseudogeneric,
+                         info.isNoEscape(),
+                         info.getDifferentiabilityKind()),
+                info.getUncommonInfo().hasValue()
+                ? Uncommon(info.getUncommonInfo().getValue())
+                : Uncommon(nullptr)) {
+    }
+
     static ExtInfo getThin() {
       return ExtInfo(Representation::Thin, false, false,
                      DifferentiabilityKind::NonDifferentiable, nullptr);
@@ -4093,6 +4126,9 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
       return ExtInfo(NoEscape ? (Bits | NoEscapeMask) : (Bits & ~NoEscapeMask),
                      Other);
     }
+    ExtInfo withClangFunctionType(const clang::Type *type) const {
+      return ExtInfo(Bits, Uncommon(type));
+    }
 
     std::pair<unsigned, const void *> getFuncAttrKey() const {
       return std::make_pair(Bits, Other.ClangFunctionType);
@@ -4388,7 +4424,7 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     return WitnessMethodConformance;
   }
 
-  const clang::FunctionType *getClangFunctionType() const;
+  const clang::Type *getClangFunctionType() const;
 
   ExtInfo getExtInfo() const {
     return ExtInfo(Bits.SILFunctionType.ExtInfoBits, getClangFunctionType());

include/swift/Frontend/FrontendOptions.h

@@ -253,6 +253,9 @@ class FrontendOptions {
   /// See the \ref SILOptions.EmitSortedSIL flag.
   bool EmitSortedSIL = false;
 
+  /// Should we emit the cType when printing @convention(c) or no?
+  bool PrintFullConvention = false;
+
   /// Indicates whether the dependency tracker should track system
   /// dependencies as well.
   bool TrackSystemDeps = false;

include/swift/Frontend/ModuleInterfaceSupport.h

@@ -31,8 +31,8 @@ struct ModuleInterfaceOptions {
   /// interface, or should we fully-qualify them?
   bool PreserveTypesAsWritten = false;
 
-  /// Should we emit the cType when printing @convention(c) or no?
-  /// FIXME: [clang-function-type-serialization] This check should go away.
+  /// See \ref FrontendOptions.PrintFullConvention.
+  /// FIXME: [clang-function-type-serialization] This flag should go away.
   bool PrintFullConvention = false;
 
   /// Copy of all the command-line flags passed at .swiftinterface

include/swift/Option/FrontendOptions.td

@@ -608,10 +608,12 @@ def module_interface_preserve_types_as_written :
   HelpText<"When emitting a module interface, preserve types as they were "
            "written in the source">;
 
+// FIXME: [clang-function-type-serialization] Make this a SIL-only option once we
+// start unconditionally emitting non-canonical Clang types in swiftinterfaces.
 def experimental_print_full_convention :
  Flag<["-"], "experimental-print-full-convention">,
- HelpText<"When emitting a module interface, emit additional @convention "
-          "arguments, regardless of whether they were written in the source">;
+ HelpText<"When emitting a module interface or SIL, emit additional @convention"
+          " arguments, regardless of whether they were written in the source">;
 
 def prebuilt_module_cache_path :
   Separate<["-"], "prebuilt-module-cache-path">,

include/swift/SIL/SILModule.h

@@ -647,10 +647,11 @@ class SILModule {
   /// \param ShouldSort If set to true sorts functions, vtables, sil global
   ///        variables, and witness tables by name to ease diffing.
   /// \param PrintASTDecls If set to true print AST decls.
-  void print(raw_ostream &OS, bool Verbose = false,
-             ModuleDecl *M = nullptr, bool ShouldSort = false,
+  void print(raw_ostream &OS,
+             ModuleDecl *M = nullptr,
+             const SILOptions &Opts = SILOptions(),
              bool PrintASTDecls = true) const {
-    SILPrintContext PrintCtx(OS, Verbose, ShouldSort);
+    SILPrintContext PrintCtx(OS, Opts);
     print(PrintCtx, M, PrintASTDecls);
   }
 

include/swift/SIL/SILPrintContext.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SIL_PRINTCONTEXT_H
 #define SWIFT_SIL_PRINTCONTEXT_H
 
+#include "swift/AST/SILOptions.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILValue.h"
 #include "llvm/ADT/DenseMap.h"
@@ -65,13 +66,21 @@ class SILPrintContext {
   /// Print debug locations and scopes.
   bool DebugInfo;
 
+  /// See \ref FrontendOptions.PrintFullConvention.
+  bool PrintFullConvention;
+
 public:
   /// Constructor with default values for options.
   ///
   /// DebugInfo will be set according to the -sil-print-debuginfo option.
   SILPrintContext(llvm::raw_ostream &OS, bool Verbose = false,
                   bool SortedSIL = false);
 
+  /// Constructor based on SILOptions.
+  ///
+  /// DebugInfo will be set according to the -sil-print-debuginfo option.
+  SILPrintContext(llvm::raw_ostream &OS, const SILOptions &Opts);
+
   SILPrintContext(llvm::raw_ostream &OS, bool Verbose,
                   bool SortedSIL, bool DebugInfo);
 
@@ -94,6 +103,9 @@ class SILPrintContext {
   /// Returns true if debug locations and scopes should be printed.
   bool printDebugInfo() const { return DebugInfo; }
 
+  /// Returns true if the entire @convention(c, cType: ..) should be printed.
+  bool printFullConvention() const { return PrintFullConvention; }
+
   SILPrintContext::ID getID(const SILBasicBlock *Block);
 
   SILPrintContext::ID getID(const SILNode *node);

include/swift/SIL/SILType.h

@@ -581,7 +581,8 @@ class SILType {
 
   std::string getAsString() const;
   void dump() const;
-  void print(raw_ostream &OS) const;
+  void print(raw_ostream &OS,
+             const PrintOptions &PO = PrintOptions::printSIL()) const;
 };
 
 // Statically prevent SILTypes from being directly cast to a type