Revert "Clang function types v2: Electric Boogaloo (parsing + printing)"

Author: compnerd

include/swift/AST/ASTPrinter.h

@@ -14,7 +14,6 @@
 #define SWIFT_AST_ASTPRINTER_H
 
 #include "swift/Basic/LLVM.h"
-#include "swift/Basic/QuotedString.h"
 #include "swift/Basic/UUID.h"
 #include "swift/AST/Identifier.h"
 #include "llvm/ADT/StringRef.h"
@@ -186,8 +185,6 @@ class ASTPrinter {
     return *this;
   }
 
-  ASTPrinter &operator<<(QuotedString s);
-
   ASTPrinter &operator<<(unsigned long long N);
   ASTPrinter &operator<<(UUID UU);
 

include/swift/AST/ClangModuleLoader.h

@@ -21,7 +21,6 @@ class CompilerInstance;
 class Preprocessor;
 class Sema;
 class TargetInfo;
-class Type;
 } // namespace clang
 
 namespace swift {
@@ -101,16 +100,6 @@ class ClangModuleLoader : public ModuleLoader {
   lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) = 0;
-
-  /// Try to parse the string as a Clang function type.
-  ///
-  /// Returns null if there was a parsing failure.
-  virtual const clang::Type *parseClangFunctionType(StringRef type,
-                                                    SourceLoc loc) const = 0;
-
-  /// Print the Clang type.
-  virtual void printClangType(const clang::Type *type,
-                              llvm::raw_ostream &os) const = 0;
 };
 
 } // namespace swift

include/swift/AST/DiagnosticsSema.def

@@ -3924,13 +3924,6 @@ ERROR(unsupported_convention,none,
       "convention '%0' not supported", (StringRef))
 ERROR(unreferenced_generic_parameter,none,
       "generic parameter '%0' is not used in function signature", (StringRef))
-ERROR(unexpected_ctype_for_non_c_convention,none,
-      "convention '%0' does not support the 'cType' argument label, did you "
-      "mean @convention(c, cType: \"%1\") or @convention(block, cType: \"%1\") "
-      "instead?", (StringRef, StringRef))
-ERROR(unable_to_parse_c_function_type,none,
-      "unable to parse '%0'; it should be a C function pointer type or a "
-      "block pointer type", (StringRef))
 
 // Opaque types
 ERROR(unsupported_opaque_type,none,

include/swift/AST/PrintOptions.h

@@ -306,21 +306,8 @@ struct PrintOptions {
   /// List of decls that should be printed even if they are implicit and \c SkipImplicit is set to true.
   std::vector<const Decl*> TreatAsExplicitDeclList;
 
-  enum class FunctionRepresentationMode : uint8_t {
-    /// Print the entire convention, including an arguments.
-    /// For example, this will print a cType argument label if applicable.
-    Full,
-    /// Print only the name of the convention, skipping extra argument labels.
-    NameOnly,
-    /// Skip printing the @convention(..) altogether.
-    None
-  };
-
   /// Whether to print function @convention attribute on function types.
-  // FIXME: [clang-function-type-serialization] Once we start serializing Clang
-  // types, we should also start printing the full type in the swiftinterface.
-  FunctionRepresentationMode PrintFunctionRepresentationAttrs =
-    FunctionRepresentationMode::NameOnly;
+  bool PrintFunctionRepresentationAttrs = true;
 
   /// Whether to print storage representation attributes on types, e.g.
   /// '@sil_weak', '@sil_unmanaged'.
@@ -515,8 +502,7 @@ struct PrintOptions {
   /// consistent and well-formed.
   ///
   /// \see swift::emitSwiftInterface
-  static PrintOptions printSwiftInterfaceFile(bool preferTypeRepr,
-                                              bool printFullConvention);
+  static PrintOptions printSwiftInterfaceFile(bool preferTypeRepr);
 
   /// Retrieve the set of options suitable for "Generated Interfaces", which
   /// are a prettified representation of the public API of a module, to be
@@ -599,8 +585,7 @@ struct PrintOptions {
     PO.SkipUnderscoredKeywords = true;
     PO.EnumRawValues = EnumRawValueMode::Print;
     PO.PrintImplicitAttrs = false;
-    PO.PrintFunctionRepresentationAttrs =
-      PrintOptions::FunctionRepresentationMode::None;
+    PO.PrintFunctionRepresentationAttrs = false;
     PO.PrintDocumentationComments = false;
     PO.ExcludeAttrList.push_back(DAK_Available);
     PO.SkipPrivateStdlibDecls = true;

include/swift/AST/Types.h

@@ -59,7 +59,6 @@ class AssociatedTypeDecl;
 class ASTContext;
 enum BufferPointerTypeKind : unsigned;
 class ClassDecl;
-class ClangModuleLoader;
 class DependentMemberType;
 class GenericTypeParamDecl;
 class GenericTypeParamType;
@@ -2951,11 +2950,6 @@ class AnyFunctionType : public TypeBase {
 
       bool empty() const { return !ClangFunctionType; }
       Uncommon(const clang::Type *type) : ClangFunctionType(type) {}
-
-    public:
-      /// Use the ClangModuleLoader to print the Clang type as a string.
-      void printClangFunctionType(ClangModuleLoader *cml,
-                                  llvm::raw_ostream &os);
     };
 
   private:
@@ -3900,11 +3894,6 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
 
       bool empty() const { return !ClangFunctionType; }
       Uncommon(const clang::FunctionType *type) : ClangFunctionType(type) {}
-
-    public:
-      /// Analog of AnyFunctionType::ExtInfo::Uncommon::printClangFunctionType.
-      void printClangFunctionType(ClangModuleLoader *cml,
-                                  llvm::raw_ostream &os) const;
     };
 
     Uncommon Other;
@@ -3958,11 +3947,6 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
       return getSILFunctionLanguage(getRepresentation());
     }
 
-    /// Return the underlying Uncommon value if it is not the default value.
-    Optional<Uncommon> getUncommonInfo() const {
-      return Other.empty() ? Optional<Uncommon>() : Other;
-    }
-
     bool hasSelfParam() const {
       switch (getRepresentation()) {
       case Representation::Thick:

include/swift/ClangImporter/ClangImporter.h

@@ -40,7 +40,6 @@ namespace clang {
   class NamedDecl;
   class Sema;
   class TargetInfo;
-  class Type;
   class VisibleDeclConsumer;
   class DeclarationName;
 }
@@ -417,11 +416,6 @@ class ClangImporter final : public ClangModuleLoader {
   /// with -import-objc-header option.
   getPCHFilename(const ClangImporterOptions &ImporterOptions,
                  StringRef SwiftPCHHash, bool &isExplicit);
-
-  const clang::Type *parseClangFunctionType(StringRef type,
-                                            SourceLoc loc) const override;
-  void printClangType(const clang::Type *type,
-                      llvm::raw_ostream &os) const override;
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,

include/swift/Frontend/ModuleInterfaceSupport.h

@@ -31,10 +31,6 @@ 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.
-  bool PrintFullConvention = false;
-
   /// Copy of all the command-line flags passed at .swiftinterface
   /// generation time, re-applied to CompilerInvocation when reading
   /// back .swiftinterface and reconstructing .swiftmodule.

include/swift/Option/FrontendOptions.td

@@ -602,11 +602,6 @@ def module_interface_preserve_types_as_written :
   HelpText<"When emitting a module interface, preserve types as they were "
            "written in the source">;
 
-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">;
-
 def prebuilt_module_cache_path :
   Separate<["-"], "prebuilt-module-cache-path">,
   HelpText<"Directory of prebuilt modules for loading module interfaces">;

lib/AST/ASTContext.cpp

@@ -3156,11 +3156,6 @@ ArrayRef<Requirement> GenericFunctionType::getRequirements() const {
   return Signature->getRequirements();
 }
 
-void SILFunctionType::ExtInfo::Uncommon::printClangFunctionType(
-    ClangModuleLoader *cml, llvm::raw_ostream &os) const {
-  cml->printClangType(ClangFunctionType, os);
-}
-
 void SILFunctionType::Profile(
     llvm::FoldingSetNodeID &id,
     GenericSignature genericParams,

lib/AST/ASTPrinter.cpp

@@ -19,7 +19,6 @@
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/Attr.h"
-#include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/Comment.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
@@ -99,8 +98,7 @@ static bool contributesToParentTypeStorage(const AbstractStorageDecl *ASD) {
   return !ND->isResilient() && ASD->hasStorage() && !ASD->isStatic();
 }
 
-PrintOptions PrintOptions::printSwiftInterfaceFile(bool preferTypeRepr,
-                                                   bool printFullConvention) {
+PrintOptions PrintOptions::printSwiftInterfaceFile(bool preferTypeRepr) {
   PrintOptions result;
   result.PrintLongAttrsOnSeparateLines = true;
   result.TypeDefinitions = true;
@@ -117,9 +115,6 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(bool preferTypeRepr,
   result.OpaqueReturnTypePrinting =
       OpaqueReturnTypePrintingMode::StableReference;
   result.PreferTypeRepr = preferTypeRepr;
-  if (printFullConvention)
-    result.PrintFunctionRepresentationAttrs =
-      PrintOptions::FunctionRepresentationMode::Full;
 
   // We should print __consuming, __owned, etc for the module interface file.
   result.SkipUnderscoredKeywords = false;
@@ -326,14 +321,6 @@ void ASTPrinter::callPrintDeclPre(const Decl *D,
     printDeclPre(D, Bracket);
 }
 
-ASTPrinter &ASTPrinter::operator<<(QuotedString s) {
-  llvm::SmallString<32> Str;
-  llvm::raw_svector_ostream OS(Str);
-  OS << s;
-  printTextImpl(OS.str());
-  return *this;
-}
-
 ASTPrinter &ASTPrinter::operator<<(unsigned long long N) {
   llvm::SmallString<32> Str;
   llvm::raw_svector_ostream OS(Str);
@@ -3491,15 +3478,6 @@ void Pattern::print(llvm::raw_ostream &OS, const PrintOptions &Options) const {
 //  Type Printing
 //===----------------------------------------------------------------------===//
 
-template <typename ExtInfo>
-void printCType(ASTContext &Ctx, ASTPrinter &Printer, ExtInfo &info) {
-  auto *cml = Ctx.getClangModuleLoader();
-  SmallString<64> buf;
-  llvm::raw_svector_ostream os(buf);
-  info.getUncommonInfo().getValue().printClangFunctionType(cml, os);
-  Printer << ", cType: " << QuotedString(os.str());
-}
-
 namespace {
 class TypePrinter : public TypeVisitor<TypePrinter> {
   using super = TypeVisitor;
@@ -3862,7 +3840,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     visit(staticSelfT);
   }
 
-  void printFunctionExtInfo(ASTContext &Ctx, AnyFunctionType::ExtInfo info) {
+  void printFunctionExtInfo(AnyFunctionType::ExtInfo info) {
     if (Options.SkipAttributes)
       return;
 
@@ -3875,18 +3853,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       }
     }
 
-    SmallString<64> buf;
-    switch (Options.PrintFunctionRepresentationAttrs) {
-    case PrintOptions::FunctionRepresentationMode::None:
-      return;
-    case PrintOptions::FunctionRepresentationMode::Full:
-    case PrintOptions::FunctionRepresentationMode::NameOnly:
-      if (Options.excludeAttrKind(TAK_convention) ||
-          info.getSILRepresentation() == SILFunctionType::Representation::Thick)
-        return;
-
-      bool printNameOnly = Options.PrintFunctionRepresentationAttrs ==
-                           PrintOptions::FunctionRepresentationMode::NameOnly;
+    if (Options.PrintFunctionRepresentationAttrs &&
+        !Options.excludeAttrKind(TAK_convention) &&
+        info.getSILRepresentation() != SILFunctionType::Representation::Thick) {
       Printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
       Printer.printAttrName("@convention");
       Printer << "(";
@@ -3902,11 +3871,6 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
         break;
       case SILFunctionType::Representation::CFunctionPointer:
         Printer << "c";
-        // FIXME: [clang-function-type-serialization] Once we start serializing
-        // Clang function types, we should be able to remove the second check.
-        if (printNameOnly || !info.getUncommonInfo().hasValue())
-          break;
-        printCType(Ctx, Printer, info);
         break;
       case SILFunctionType::Representation::Method:
         Printer << "method";
@@ -3927,8 +3891,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
-  void printFunctionExtInfo(ASTContext &Ctx,
-                            SILFunctionType::ExtInfo info,
+  void printFunctionExtInfo(SILFunctionType::ExtInfo info,
                             ProtocolConformanceRef witnessMethodConformance) {
     if (Options.SkipAttributes)
       return;
@@ -3942,19 +3905,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       }
     }
 
-
-    SmallString<64> buf;
-    switch (Options.PrintFunctionRepresentationAttrs) {
-    case PrintOptions::FunctionRepresentationMode::None:
-      break;
-    case PrintOptions::FunctionRepresentationMode::NameOnly:
-    case PrintOptions::FunctionRepresentationMode::Full:
-      if (Options.excludeAttrKind(TAK_convention) ||
-          info.getRepresentation() == SILFunctionType::Representation::Thick)
-        break;
-
-      bool printNameOnly = Options.PrintFunctionRepresentationAttrs ==
-                           PrintOptions::FunctionRepresentationMode::NameOnly;
+    if (Options.PrintFunctionRepresentationAttrs &&
+        !Options.excludeAttrKind(TAK_convention) &&
+        info.getRepresentation() != SILFunctionType::Representation::Thick) {
       Printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
       Printer.printAttrName("@convention");
       Printer << "(";
@@ -3969,11 +3922,6 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
         break;
       case SILFunctionType::Representation::CFunctionPointer:
         Printer << "c";
-        // FIXME: [clang-function-type-serialization] Once we start serializing
-        // Clang function types, we should be able to remove the second check.
-        if (printNameOnly || !info.getUncommonInfo().hasValue())
-          break;
-        printCType(Ctx, Printer, info);
         break;
       case SILFunctionType::Representation::Method:
         Printer << "method";
@@ -4043,7 +3991,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       Printer.printStructurePost(PrintStructureKind::FunctionType);
     };
 
-    printFunctionExtInfo(T->getASTContext(), T->getExtInfo());
+    printFunctionExtInfo(T->getExtInfo());
 
     // If we're stripping argument labels from types, do it when printing.
     visitAnyFunctionTypeParams(T->getParams(), /*printLabels*/false);
@@ -4080,7 +4028,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       Printer.printStructurePost(PrintStructureKind::FunctionType);
     };
 
-    printFunctionExtInfo(T->getASTContext(), T->getExtInfo());
+    printFunctionExtInfo(T->getExtInfo());
     printGenericSignature(T->getGenericSignature(),
                           PrintAST::PrintParams |
                           PrintAST::PrintRequirements);
@@ -4133,7 +4081,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
   void visitSILFunctionType(SILFunctionType *T) {
     printSILCoroutineKind(T->getCoroutineKind());
-    printFunctionExtInfo(T->getASTContext(), T->getExtInfo(),
+    printFunctionExtInfo(T->getExtInfo(),
                          T->getWitnessMethodConformanceOrInvalid());
     printCalleeConvention(T->getCalleeConvention());
 

lib/AST/Type.cpp

@@ -17,7 +17,6 @@
 #include "swift/AST/Types.h"
 #include "ForeignRepresentationInfo.h"
 #include "swift/AST/ASTContext.h"
-#include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/ReferenceCounting.h"
 #include "swift/AST/TypeCheckRequests.h"
@@ -3240,11 +3239,6 @@ Type ProtocolCompositionType::get(const ASTContext &C,
   return build(C, CanTypes, HasExplicitAnyObject);
 }
 
-void AnyFunctionType::ExtInfo::Uncommon::printClangFunctionType(
-    ClangModuleLoader *cml, llvm::raw_ostream &os) {
-  cml->printClangType(ClangFunctionType, os);
-}
-
 void
 AnyFunctionType::ExtInfo::assertIsFunctionType(const clang::Type *type) {
 #ifndef NDEBUG