Merge pull request swiftlang#30499 from slavapestov/remove-curried-declrefs

SIL: Remove curried SILDeclRefs

Author: slavapestov

docs/SIL.rst

@@ -80,7 +80,6 @@ class ASTMangler : public Mangler {
     DynamicThunk,
     SwiftAsObjCThunk,
     ObjCAsSwiftThunk,
-    DirectMethodReferenceThunk,
   };
 
   ASTMangler(bool DWARFMangling = false)
@@ -98,14 +97,14 @@ class ASTMangler : public Mangler {
   std::string mangleClosureEntity(const AbstractClosureExpr *closure,
                                   SymbolKind SKind);
 
-  std::string mangleEntity(const ValueDecl *decl, bool isCurried,
+  std::string mangleEntity(const ValueDecl *decl,
                            SymbolKind SKind = SymbolKind::Default);
 
   std::string mangleDestructorEntity(const DestructorDecl *decl,
                                      bool isDeallocating, SymbolKind SKind);
 
   std::string mangleConstructorEntity(const ConstructorDecl *ctor,
-                                      bool isAllocating, bool isCurried,
+                                      bool isAllocating,
                                       SymbolKind SKind = SymbolKind::Default);
 
   std::string mangleIVarInitDestroyEntity(const ClassDecl *decl,

include/swift/AST/ASTMangler.h

@@ -554,9 +554,7 @@ class LinkEntity {
   LinkEntity() = default;
 
   static bool isValidResilientMethodRef(SILDeclRef declRef) {
-    if (declRef.isForeign ||
-        declRef.isDirectReference ||
-        declRef.isCurried)
+    if (declRef.isForeign)
       return false;
 
     auto *decl = declRef.getDecl();

include/swift/IRGen/Linking.h

@@ -143,24 +143,16 @@ struct SILDeclRef {
   Loc loc;
   /// The Kind of this SILDeclRef.
   Kind kind : 4;
-  /// True if the SILDeclRef is a curry thunk.
-  unsigned isCurried : 1;
   /// True if this references a foreign entry point for the referenced decl.
   unsigned isForeign : 1;
-  /// True if this is a direct reference to a class's method implementation
-  /// that isn't dynamically dispatched.
-  unsigned isDirectReference : 1;
   /// The default argument index for a default argument getter.
   unsigned defaultArgIndex : 10;
 
   /// Produces a null SILDeclRef.
-  SILDeclRef() : loc(), kind(Kind::Func),
-                 isCurried(0), isForeign(0), isDirectReference(0),
-                 defaultArgIndex(0) {}
+  SILDeclRef() : loc(), kind(Kind::Func), isForeign(0), defaultArgIndex(0) {}
 
   /// Produces a SILDeclRef of the given kind for the given decl.
   explicit SILDeclRef(ValueDecl *decl, Kind kind,
-                      bool isCurried = false,
                       bool isForeign = false);
 
   /// Produces a SILDeclRef for the given ValueDecl or
@@ -174,13 +166,7 @@ struct SILDeclRef {
   ///   for the containing ClassDecl.
   /// - If 'loc' is a global VarDecl, this returns its GlobalAccessor
   ///   SILDeclRef.
-  ///
-  /// If 'isCurried' is true, the loc must be a method or enum element;
-  /// the SILDeclRef will then refer to a curry thunk with type
-  /// (Self) -> (Args...) -> Result, rather than a direct reference to
-  /// the actual method whose lowered type is (Args..., Self) -> Result.
   explicit SILDeclRef(Loc loc,
-                      bool isCurried = false,
                       bool isForeign = false);
 
   /// Produce a SIL constant for a default argument generator.
@@ -289,16 +275,13 @@ struct SILDeclRef {
   llvm::hash_code getHashCode() const {
     return llvm::hash_combine(loc.getOpaqueValue(),
                               static_cast<int>(kind),
-                              isCurried, isForeign, isDirectReference,
-                              defaultArgIndex);
+                              isForeign, defaultArgIndex);
   }
 
   bool operator==(SILDeclRef rhs) const {
     return loc.getOpaqueValue() == rhs.loc.getOpaqueValue()
       && kind == rhs.kind
-      && isCurried == rhs.isCurried
       && isForeign == rhs.isForeign
-      && isDirectReference == rhs.isDirectReference
       && defaultArgIndex == rhs.defaultArgIndex;
   }
   bool operator!=(SILDeclRef rhs) const {
@@ -309,32 +292,12 @@ struct SILDeclRef {
   void dump() const;
 
   unsigned getParameterListCount() const;
-  
-  // Returns the SILDeclRef for an entity at a shallower uncurry level.
-  SILDeclRef asCurried(bool curried = true) const {
-    assert(!isCurried && "can't safely go to deeper uncurry level");
-    // Curry thunks are never foreign.
-    bool willBeForeign = isForeign && !curried;
-    bool willBeDirect = isDirectReference;
-    return SILDeclRef(loc.getOpaqueValue(), kind,
-                      curried, willBeDirect, willBeForeign,
-                      defaultArgIndex);
-  }
-  
+
   /// Returns the foreign (or native) entry point corresponding to the same
   /// decl.
   SILDeclRef asForeign(bool foreign = true) const {
-    assert(!isCurried);
     return SILDeclRef(loc.getOpaqueValue(), kind,
-                      isCurried, isDirectReference, foreign, defaultArgIndex);
-  }
-  
-  SILDeclRef asDirectReference(bool direct = true) const {
-    SILDeclRef r = *this;
-    // The 'direct' distinction only makes sense for curry thunks.
-    if (r.isCurried)
-      r.isDirectReference = direct;
-    return r;
+                      foreign, defaultArgIndex);
   }
 
   /// True if the decl ref references a thunk from a natively foreign
@@ -408,15 +371,10 @@ struct SILDeclRef {
   /// Produces a SILDeclRef from an opaque value.
   explicit SILDeclRef(void *opaqueLoc,
                       Kind kind,
-                      bool isCurried,
-                      bool isDirectReference,
                       bool isForeign,
                       unsigned defaultArgIndex)
-    : loc(Loc::getFromOpaqueValue(opaqueLoc)),
-      kind(kind),
-      isCurried(isCurried),
-      isForeign(isForeign), isDirectReference(isDirectReference),
-      defaultArgIndex(defaultArgIndex)
+    : loc(Loc::getFromOpaqueValue(opaqueLoc)), kind(kind),
+      isForeign(isForeign), defaultArgIndex(defaultArgIndex)
   {}
 
 };
@@ -440,21 +398,20 @@ template<> struct DenseMapInfo<swift::SILDeclRef> {
 
   static SILDeclRef getEmptyKey() {
     return SILDeclRef(PointerInfo::getEmptyKey(), Kind::Func,
-                      false, false, false, 0);
+                      false, 0);
   }
   static SILDeclRef getTombstoneKey() {
     return SILDeclRef(PointerInfo::getTombstoneKey(), Kind::Func,
-                      false, false, false, 0);
+                      false, 0);
   }
   static unsigned getHashValue(swift::SILDeclRef Val) {
     unsigned h1 = PointerInfo::getHashValue(Val.loc.getOpaqueValue());
     unsigned h2 = UnsignedInfo::getHashValue(unsigned(Val.kind));
     unsigned h3 = (Val.kind == Kind::DefaultArgGenerator)
                     ? UnsignedInfo::getHashValue(Val.defaultArgIndex)
-                    : UnsignedInfo::getHashValue(Val.isCurried);
+                    : 0;
     unsigned h4 = UnsignedInfo::getHashValue(Val.isForeign);
-    unsigned h5 = UnsignedInfo::getHashValue(Val.isDirectReference);
-    return h1 ^ (h2 << 4) ^ (h3 << 9) ^ (h4 << 7) ^ (h5 << 11);
+    return h1 ^ (h2 << 4) ^ (h3 << 9) ^ (h4 << 7);
   }
   static bool isEqual(swift::SILDeclRef const &LHS,
                       swift::SILDeclRef const &RHS) {

include/swift/SIL/SILDeclRef.h

@@ -37,9 +37,9 @@ struct SortedFuncList {
     Mangle::ASTMangler mangler;
     std::string mangledName;
     if (auto *cd = dyn_cast<ConstructorDecl>(afd))
-      mangledName = mangler.mangleConstructorEntity(cd, 0, 0);
+      mangledName = mangler.mangleConstructorEntity(cd, 0);
     else
-      mangledName = mangler.mangleEntity(afd, 0);
+      mangledName = mangler.mangleEntity(afd);
 
     elts.push_back(std::make_pair(mangledName, afd));
   }

include/swift/SIL/SILVTableVisitor.h

@@ -78,12 +78,9 @@ std::string ASTMangler::mangleClosureEntity(const AbstractClosureExpr *closure,
   return finalize();
 }
 
-std::string ASTMangler::mangleEntity(const ValueDecl *decl, bool isCurried,
-                                     SymbolKind SKind) {
+std::string ASTMangler::mangleEntity(const ValueDecl *decl, SymbolKind SKind) {
   beginMangling();
   appendEntity(decl);
-  if (isCurried)
-    appendOperator("Tc");
   appendSymbolKind(SKind);
   return finalize();
 }
@@ -99,12 +96,9 @@ std::string ASTMangler::mangleDestructorEntity(const DestructorDecl *decl,
 
 std::string ASTMangler::mangleConstructorEntity(const ConstructorDecl *ctor,
                                                 bool isAllocating,
-                                                bool isCurried,
                                                 SymbolKind SKind) {
   beginMangling();
   appendConstructorEntity(ctor, isAllocating);
-  if (isCurried)
-    appendOperator("Tc");
   appendSymbolKind(SKind);
   return finalize();
 }
@@ -587,7 +581,6 @@ void ASTMangler::appendSymbolKind(SymbolKind SKind) {
     case SymbolKind::DynamicThunk: return appendOperator("TD");
     case SymbolKind::SwiftAsObjCThunk: return appendOperator("To");
     case SymbolKind::ObjCAsSwiftThunk: return appendOperator("TO");
-    case SymbolKind::DirectMethodReferenceThunk: return appendOperator("Td");
   }
 }
 

lib/AST/ASTMangler.cpp

@@ -1381,7 +1381,6 @@ void irgen::emitObjCIVarInitDestroyDescriptor(
   SILDeclRef declRef = SILDeclRef(cd, 
                                   isDestroyer? SILDeclRef::Kind::IVarDestroyer
                                              : SILDeclRef::Kind::IVarInitializer,
-                                  1, 
                                   /*foreign*/ true);
   Selector selector(declRef);
 

lib/IRGen/GenObjC.cpp

@@ -352,10 +352,9 @@ std::string LinkEntity::mangleAsString() const {
     assert(isa<AbstractFunctionDecl>(getDecl()));
     std::string Result;
     if (auto *Constructor = dyn_cast<ConstructorDecl>(getDecl())) {
-      Result = mangler.mangleConstructorEntity(Constructor, isAllocator(),
-                                               /*isCurried=*/false);
+      Result = mangler.mangleConstructorEntity(Constructor, isAllocator());
     } else  {
-      Result = mangler.mangleEntity(getDecl(), /*isCurried=*/false);
+      Result = mangler.mangleEntity(getDecl());
     }
     Result.append("TI");
     return Result;
@@ -379,10 +378,9 @@ std::string LinkEntity::mangleAsString() const {
     std::string Result;
     if (auto *Constructor = dyn_cast<ConstructorDecl>(getDecl())) {
       Result =
-          mangler.mangleConstructorEntity(Constructor, isAllocator(),
-                                          /*isCurried=*/false);
+          mangler.mangleConstructorEntity(Constructor, isAllocator());
     } else  {
-      Result = mangler.mangleEntity(getDecl(), /*isCurried=*/false);
+      Result = mangler.mangleEntity(getDecl());
     }
     Result.append("TX");
     return Result;
@@ -393,10 +391,9 @@ std::string LinkEntity::mangleAsString() const {
     std::string Result;
     if (auto *Constructor = dyn_cast<ConstructorDecl>(getDecl())) {
       Result =
-          mangler.mangleConstructorEntity(Constructor, isAllocator(),
-                                          /*isCurried=*/false);
+          mangler.mangleConstructorEntity(Constructor, isAllocator());
     } else  {
-      Result = mangler.mangleEntity(getDecl(), /*isCurried=*/false);
+      Result = mangler.mangleEntity(getDecl());
     }
     Result.append("Tx");
     return Result;

lib/IRGen/Linking.cpp

@@ -1340,9 +1340,7 @@ static Optional<AccessorKind> getAccessorKind(StringRef ident) {
 }
 
 ///  sil-decl-ref ::= '#' sil-identifier ('.' sil-identifier)* sil-decl-subref?
-///  sil-decl-subref ::= '!' sil-decl-subref-part ('.' sil-decl-uncurry-level)?
-///                      ('.' sil-decl-lang)?
-///  sil-decl-subref ::= '!' sil-decl-uncurry-level ('.' sil-decl-lang)?
+///  sil-decl-subref ::= '!' sil-decl-subref-part ('.' sil-decl-lang)?
 ///  sil-decl-subref ::= '!' sil-decl-lang
 ///  sil-decl-subref-part ::= 'getter'
 ///  sil-decl-subref-part ::= 'setter'
@@ -1351,33 +1349,28 @@ static Optional<AccessorKind> getAccessorKind(StringRef ident) {
 ///  sil-decl-subref-part ::= 'enumelt'
 ///  sil-decl-subref-part ::= 'destroyer'
 ///  sil-decl-subref-part ::= 'globalaccessor'
-///  sil-decl-uncurry-level ::= [0-9]+
 ///  sil-decl-lang ::= 'foreign'
 bool SILParser::parseSILDeclRef(SILDeclRef &Result,
                                 SmallVectorImpl<ValueDecl *> &values) {
   ValueDecl *VD;
   if (parseSILDottedPath(VD, values))
     return true;
 
-  // Initialize Kind, uncurryLevel and IsObjC.
+  // Initialize Kind and IsObjC.
   SILDeclRef::Kind Kind = SILDeclRef::Kind::Func;
-  unsigned uncurryLevel = 0;
   bool IsObjC = false;
 
   if (!P.consumeIf(tok::sil_exclamation)) {
     // Construct SILDeclRef.
-    Result = SILDeclRef(VD, Kind, /*isCurried=*/false, IsObjC);
-    if (uncurryLevel < Result.getParameterListCount() - 1)
-      Result = Result.asCurried();
+    Result = SILDeclRef(VD, Kind, IsObjC);
     return false;
   }
 
   // Handle sil-constant-kind-and-uncurry-level.
   // ParseState indicates the value we just handled.
-  // 1 means we just handled Kind, 2 means we just handled uncurryLevel.
-  // We accept func|getter|setter|...|foreign or an integer when ParseState is
-  // 0; accept foreign or an integer when ParseState is 1; accept foreign when
-  // ParseState is 2.
+  // 1 means we just handled Kind.
+  // We accept func|getter|setter|...|foreign when ParseState is 0;
+  // accept foreign when ParseState is 1.
   unsigned ParseState = 0;
   Identifier Id;
   do {
@@ -1448,19 +1441,13 @@ bool SILParser::parseSILDeclRef(SILDeclRef &Result,
         break;
       } else
         break;
-    } else if (ParseState < 2 && P.Tok.is(tok::integer_literal)) {
-      parseIntegerLiteral(P.Tok.getText(), 0, uncurryLevel);
-      P.consumeToken(tok::integer_literal);
-      ParseState = 2;
     } else
       break;
 
   } while (P.consumeIf(tok::period));
 
   // Construct SILDeclRef.
-  Result = SILDeclRef(VD, Kind, /*isCurried=*/false, IsObjC);
-  if (uncurryLevel < Result.getParameterListCount() - 1)
-    Result = Result.asCurried();
+  Result = SILDeclRef(VD, Kind, IsObjC);
   return false;
 }