Serialization: Don't serialize RequirementReprs

RequirementReprs stored serialized references to archetypes,
which do not have enough information to reconstruct same-type
requirements.

For this reason, we would serialize the 'as written' requirement
string as well as the actual types, which is a horrible hack.

Now that the ASTPrinter and SourceKit use GenericSignatures,
none of this is needed anymore.

Author: slavapestov

include/swift/AST/Decl.h

@@ -1025,20 +1025,6 @@ class RequirementRepr {
     return SeparatorLoc;
   }
 
-  /// Set during deserialization; used to print out the requirements accurately
-  /// for the generated interface.
-  StringRef getAsWrittenString() const {
-    return AsWrittenString;
-  }
-  void setAsWrittenString(StringRef Str) {
-    AsWrittenString = Str;
-  }
-
-  /// Further analyze the written string, if it's not empty, to collect the first
-  /// type, the second type and the requirement kind.
-  Optional<std::tuple<StringRef, StringRef, RequirementReprKind>>
-  getAsAnalyzedWrittenString() const;
-
   SourceRange getSourceRange() const {
     return SourceRange(Types[0].getSourceRange().Start,
                        Types[1].getSourceRange().End);
@@ -1048,7 +1034,6 @@ class RequirementRepr {
       void dump() const LLVM_ATTRIBUTE_USED,
       "only for use within the debugger");
   void print(raw_ostream &OS) const;
-  void printAsWritten(raw_ostream &OS) const;
 };
 
 /// GenericParamList - A list of generic parameters that is part of a generic

include/swift/Serialization/DeclTypeRecordNodes.def

@@ -168,7 +168,6 @@ OTHER(TOP_LEVEL_CODE_DECL_CONTEXT, 239)
 OTHER(GENERIC_PARAM_LIST, 240)
 TRAILING_INFO(GENERIC_PARAM)
 TRAILING_INFO(GENERIC_REQUIREMENT)
-TRAILING_INFO(LAST_GENERIC_REQUIREMENT)
 TRAILING_INFO(GENERIC_ENVIRONMENT)
 
 OTHER(LOCAL_DISCRIMINATOR, 248)

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// 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.
-const uint16_t VERSION_MINOR = 270; // Last change: parameter type flags
+const uint16_t VERSION_MINOR = 271; // Stop serializing RequirementReprs
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;
@@ -1117,19 +1117,7 @@ namespace decls_block {
     GENERIC_REQUIREMENT,
     GenericRequirementKindField, // requirement kind
     TypeIDField,                 // types involved (two for conformance,
-    TypeIDField,                 // same-type; one for value witness marker)
-    BCBlob                       // as written string
-  >;
-
-  /// Placeholder that marks the last generic requirement in the generic
-  /// parameters list.
-  ///
-  /// Used as a buffer between the generic parameter list's requirements and
-  /// the generic signature's requirements for nominal type declarations.
-  /// FIXME: Expected to go away once the latter is no longer serialized.
-  using LastGenericRequirementLayout = BCRecordLayout<
-    LAST_GENERIC_REQUIREMENT,
-    BCFixed<1>                 // dummy
+    TypeIDField                  // same-type; one for value witness marker)
   >;
 
   /// Specifies the private discriminator string for a private declaration. This

lib/AST/ASTDumper.cpp

@@ -90,20 +90,6 @@ void RequirementRepr::dump() const {
   llvm::errs() << "\n";
 }
 
-Optional<std::tuple<StringRef, StringRef, RequirementReprKind>>
-RequirementRepr::getAsAnalyzedWrittenString() const {
-  if (AsWrittenString.empty())
-    return None;
-  auto Pair = AsWrittenString.split("==");
-  auto Kind = RequirementReprKind::SameType;
-  if (Pair.second.empty()) {
-    Pair = AsWrittenString.split(":");
-    Kind =  RequirementReprKind::TypeConstraint;
-  }
-  assert(!Pair.second.empty() && "cannot get second type.");
-  return std::make_tuple(Pair.first.trim(), Pair.second.trim(), Kind);
-}
-
 void RequirementRepr::printImpl(raw_ostream &out, bool AsWritten) const {
   auto printTy = [&](const TypeLoc &TyLoc) {
     if (AsWritten && TyLoc.getTypeRepr()) {
@@ -132,14 +118,6 @@ void RequirementRepr::print(raw_ostream &out) const {
   printImpl(out, /*AsWritten=*/false);
 }
 
-void RequirementRepr::printAsWritten(raw_ostream &out) const {
-  if (!AsWrittenString.empty()) {
-    out << AsWrittenString;
-  } else {
-    printImpl(out, /*AsWritten=*/true);
-  }
-}
-
 void GenericParamList::print(llvm::raw_ostream &OS) {
   OS << '<';
   bool First = true;

lib/Serialization/Deserialization.cpp

@@ -705,57 +705,6 @@ GenericParamList *ModuleFile::maybeReadGenericParams(DeclContext *DC,
       params.push_back(genericParam);
       break;
     }
-    case GENERIC_REQUIREMENT: {
-      uint8_t rawKind;
-      uint64_t rawTypeIDs[2];
-      GenericRequirementLayout::readRecord(scratch, rawKind,
-                                           rawTypeIDs[0], rawTypeIDs[1]);
-
-      switch (rawKind) {
-      case GenericRequirementKind::Conformance: {
-        auto subject = TypeLoc::withoutLoc(getType(rawTypeIDs[0]));
-        auto constraint = TypeLoc::withoutLoc(getType(rawTypeIDs[1]));
-
-        requirements.push_back(RequirementRepr::getTypeConstraint(subject,
-                                                           SourceLoc(),
-                                                           constraint));
-        break;
-      }
-      case GenericRequirementKind::SameType: {
-        auto first = TypeLoc::withoutLoc(getType(rawTypeIDs[0]));
-        auto second = TypeLoc::withoutLoc(getType(rawTypeIDs[1]));
-
-        requirements.push_back(RequirementRepr::getSameType(first,
-                                                            SourceLoc(),
-                                                            second));
-        break;
-      }
-
-      case GenericRequirementKind::Superclass:
-      case WitnessMarker: {
-        // Shouldn't happen where we have requirement representations.
-        error();
-        break;
-      }
-
-      default:
-        // Unknown requirement kind. Drop the requirement and continue, but log
-        // an error so that we don't actually try to generate code.
-        error();
-      }
-
-      requirements.back().setAsWrittenString(blobData);
-
-      break;
-    }
-    case LAST_GENERIC_REQUIREMENT:
-      // Read the end-of-requirements record.
-      uint8_t dummy;
-      LastGenericRequirementLayout::readRecord(scratch, dummy);
-      lastRecordOffset.reset();
-      shouldContinue = false;
-      break;
-
     default:
       // This record is not part of the GenericParamList.
       shouldContinue = false;
@@ -767,7 +716,7 @@ GenericParamList *ModuleFile::maybeReadGenericParams(DeclContext *DC,
   }
 
   auto paramList = GenericParamList::create(getContext(), SourceLoc(),
-                                            params, SourceLoc(), requirements,
+                                            params, SourceLoc(), { },
                                             SourceLoc());
   paramList->setOuterParameters(outerParams ? outerParams :
                                 DC->getGenericParamsOfContext());

lib/Serialization/SILFormat.h

@@ -157,7 +157,6 @@ namespace sil_block {
     GENERIC_PARAM_LIST = decls_block::GENERIC_PARAM_LIST,
     GENERIC_PARAM = decls_block::GENERIC_PARAM,
     GENERIC_REQUIREMENT = decls_block::GENERIC_REQUIREMENT,
-    LAST_GENERIC_REQUIREMENT = decls_block::LAST_GENERIC_REQUIREMENT,
   };
 
   using SILInstNoOperandLayout = BCRecordLayout<

lib/Serialization/Serialization.cpp

@@ -527,8 +527,6 @@ void Serializer::writeBlockInfoBlock() {
                               decls_block::GENERIC_PARAM);
   BLOCK_RECORD_WITH_NAMESPACE(sil_block,
                               decls_block::GENERIC_REQUIREMENT);
-  BLOCK_RECORD_WITH_NAMESPACE(sil_block,
-                              decls_block::LAST_GENERIC_REQUIREMENT);
   BLOCK_RECORD_WITH_NAMESPACE(sil_block,
                               decls_block::GENERIC_ENVIRONMENT);
 
@@ -950,8 +948,7 @@ void Serializer::writeGenericRequirements(ArrayRef<Requirement> requirements) {
       Out, ScratchRecord, reqAbbrCode,
       getRawStableRequirementKind(req.getKind()),
       addTypeRef(req.getFirstType()),
-      addTypeRef(req.getSecondType()),
-      StringRef());
+      addTypeRef(req.getSecondType()));
   }
 }
 
@@ -971,35 +968,6 @@ bool Serializer::writeGenericParams(const GenericParamList *genericParams) {
                                    addDeclRef(next));
   }
 
-  abbrCode = DeclTypeAbbrCodes[GenericRequirementLayout::Code];
-  SmallString<64> ReqStr;
-  for (auto next : genericParams->getRequirements()) {
-    ReqStr.clear();
-    llvm::raw_svector_ostream ReqOS(ReqStr);
-    next.printAsWritten(ReqOS);
-    switch (next.getKind()) {
-    case RequirementReprKind::TypeConstraint:
-      GenericRequirementLayout::emitRecord(
-                                      Out, ScratchRecord, abbrCode,
-                                      GenericRequirementKind::Conformance,
-                                      addTypeRef(next.getSubject()),
-                                      addTypeRef(next.getConstraint()),
-                                      ReqOS.str());
-      break;
-    case RequirementReprKind::SameType:
-      GenericRequirementLayout::emitRecord(
-                                      Out, ScratchRecord, abbrCode,
-                                      GenericRequirementKind::SameType,
-                                      addTypeRef(next.getFirstType()),
-                                      addTypeRef(next.getSecondType()),
-                                      ReqOS.str());
-      break;
-    }
-  }
-
-  abbrCode = DeclTypeAbbrCodes[LastGenericRequirementLayout::Code];
-  uint8_t dummy = 0;
-  LastGenericRequirementLayout::emitRecord(Out, ScratchRecord, abbrCode, dummy);
   return true;
 }
 
@@ -3303,7 +3271,6 @@ void Serializer::writeAllDeclsAndTypes() {
   registerDeclTypeAbbr<GenericParamListLayout>();
   registerDeclTypeAbbr<GenericParamLayout>();
   registerDeclTypeAbbr<GenericRequirementLayout>();
-  registerDeclTypeAbbr<LastGenericRequirementLayout>();
   registerDeclTypeAbbr<GenericEnvironmentLayout>();
 
   registerDeclTypeAbbr<ForeignErrorConventionLayout>();