Merge remote-tracking branch 'github/master' into HEAD

Author: ainu-bot

docs/DifferentiableProgramming.md

@@ -1,7 +1,7 @@
 # Differentiable Programming Manifesto
 
 *   Authors: [Richard Wei], [Dan Zheng], [Marc Rasi], [Bart Chrzaszcz]
-*   Status: Partially implemented
+*   Status: Partially implemented on master, feature gated under `import _Differentiation`
 
 ## Table of contents
 

include/swift/AST/ASTMangler.h

@@ -101,7 +101,8 @@ class ASTMangler : public Mangler {
                            SymbolKind SKind = SymbolKind::Default);
 
   std::string mangleDestructorEntity(const DestructorDecl *decl,
-                                     bool isDeallocating, SymbolKind SKind);
+                                     bool isDeallocating,
+                                     SymbolKind SKind = SymbolKind::Default);
 
   std::string mangleConstructorEntity(const ConstructorDecl *ctor,
                                       bool isAllocating,
@@ -120,11 +121,11 @@ class ASTMangler : public Mangler {
 
   std::string mangleDefaultArgumentEntity(const DeclContext *func,
                                           unsigned index,
-                                          SymbolKind SKind);
+                                          SymbolKind SKind = SymbolKind::Default);
 
   std::string mangleInitializerEntity(const VarDecl *var, SymbolKind SKind);
   std::string mangleBackingInitializerEntity(const VarDecl *var,
-                                             SymbolKind SKind);
+                                             SymbolKind SKind = SymbolKind::Default);
 
   std::string mangleNominalType(const NominalTypeDecl *decl);
 

include/swift/AST/Decl.h

@@ -535,17 +535,14 @@ class alignas(1 << DeclAlignInBits) Decl {
     NumRequirementsInSignature : 16
   );
 
-  SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 1+1+2+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 1+1+2+1+1+1+1+1,
     /// Whether this class inherits its superclass's convenience initializers.
     InheritsSuperclassInits : 1,
     ComputedInheritsSuperclassInits : 1,
 
     /// \see ClassDecl::ForeignKind
     RawForeignKind : 2,
 
-    /// \see ClassDecl::getEmittedMembers()
-    HasForcedEmittedMembers : 1,
-
     HasMissingDesignatedInitializers : 1,
     ComputedHasMissingDesignatedInitializers : 1,
 
@@ -3870,14 +3867,6 @@ class ClassDecl final : public NominalTypeDecl {
     llvm::PointerIntPair<Type, 1, bool> SuperclassType;
   } LazySemanticInfo;
 
-  bool hasForcedEmittedMembers() const {
-    return Bits.ClassDecl.HasForcedEmittedMembers;
-  }
-
-  void setHasForcedEmittedMembers() {
-    Bits.ClassDecl.HasForcedEmittedMembers = true;
-  }
-
   Optional<bool> getCachedInheritsSuperclassInitializers() const {
     if (Bits.ClassDecl.ComputedInheritsSuperclassInits)
       return Bits.ClassDecl.InheritsSuperclassInits;
@@ -4103,7 +4092,7 @@ class ClassDecl final : public NominalTypeDecl {
 
   /// Get all the members of this class, synthesizing any implicit members
   /// that appear in the vtable if needed.
-  DeclRange getEmittedMembers() const;
+  ArrayRef<Decl *> getEmittedMembers() const;
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {

include/swift/AST/TypeCheckRequests.h

@@ -1064,23 +1064,20 @@ class SynthesizeAccessorRequest :
 
 class EmittedMembersRequest :
     public SimpleRequest<EmittedMembersRequest,
-                         DeclRange(ClassDecl *),
-                         RequestFlags::SeparatelyCached> {
+                         ArrayRef<Decl *>(ClassDecl *),
+                         RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   // Evaluation.
-  DeclRange
+  ArrayRef<Decl *>
   evaluate(Evaluator &evaluator, ClassDecl *classDecl) const;
 
 public:
-  // Separate caching.
   bool isCached() const { return true; }
-  Optional<DeclRange> getCachedResult() const;
-  void cacheResult(DeclRange value) const;
 };
 
 class IsImplicitlyUnwrappedOptionalRequest :

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -65,8 +65,8 @@ SWIFT_REQUEST(TypeChecker, TypeEraserHasViableInitRequest,
 SWIFT_REQUEST(TypeChecker, DynamicallyReplacedDeclRequest,
               ValueDecl *(ValueDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, EmittedMembersRequest, DeclRange(ClassDecl *),
-              SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, EmittedMembersRequest, ArrayRef<Decl *>(ClassDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, EnumRawValuesRequest,
               evaluator::SideEffect (EnumDecl *, TypeResolutionStage),
               SeparatelyCached, NoLocationInfo)

include/swift/Demangling/ManglingUtils.h

@@ -192,9 +192,8 @@ void mangleIdentifier(Mangler &M, StringRef ident) {
       // Mangle the sub-string up to the next word substitution (or to the end
       // of the identifier - that's why we added the dummy-word).
       // The first thing: we add the encoded sub-string length.
+      bool first = true;
       M.Buffer << (Repl.StringPos - Pos);
-      assert(!isDigit(ident[Pos]) &&
-             "first char of sub-string may not be a digit");
       do {
         // Update the start position of new added words, so that they refer to
         // the begin of the whole mangled Buffer.
@@ -203,9 +202,16 @@ void mangleIdentifier(Mangler &M, StringRef ident) {
           M.Words[WordsInBuffer].start = M.getBufferStr().size();
           WordsInBuffer++;
         }
+        // Error recovery. We sometimes need to mangle identifiers coming
+        // from invalid code.
+        if (first && isDigit(ident[Pos]))
+          M.Buffer << 'X';
         // Add a literal character of the sub-string.
-        M.Buffer << ident[Pos];
+        else
+          M.Buffer << ident[Pos];
+
         Pos++;
+        first = false;
       } while (Pos < Repl.StringPos);
     }
     // Is it a "real" word substitution (and not the dummy-word)?

include/swift/SIL/SILVTableVisitor.h

@@ -18,55 +18,11 @@
 #ifndef SWIFT_SIL_SILVTABLEVISITOR_H
 #define SWIFT_SIL_SILVTABLEVISITOR_H
 
-#include <string>
-
 #include "swift/AST/Decl.h"
 #include "swift/AST/Types.h"
-#include "swift/AST/ASTMangler.h"
 
 namespace swift {
 
-// Utility class for deterministically ordering vtable entries for
-// synthesized methods.
-struct SortedFuncList {
-  using Entry = std::pair<std::string, AbstractFunctionDecl *>;
-  SmallVector<Entry, 2> elts;
-  bool sorted = false;
-
-  void add(AbstractFunctionDecl *afd) {
-    Mangle::ASTMangler mangler;
-    std::string mangledName;
-    if (auto *cd = dyn_cast<ConstructorDecl>(afd))
-      mangledName = mangler.mangleConstructorEntity(cd, 0);
-    else
-      mangledName = mangler.mangleEntity(afd);
-
-    elts.push_back(std::make_pair(mangledName, afd));
-  }
-
-  bool empty() { return elts.empty(); }
-
-  void sort() {
-    assert(!sorted);
-    sorted = true;
-    std::sort(elts.begin(),
-              elts.end(),
-              [](const Entry &lhs, const Entry &rhs) -> bool {
-                return lhs.first < rhs.first;
-              });
-  }
-
-  decltype(elts)::const_iterator begin() const {
-    assert(sorted);
-    return elts.begin();
-  }
-
-  decltype(elts)::const_iterator end() const {
-    assert(sorted);
-    return elts.end();
-  }
-};
-
 /// A CRTP class for visiting virtually-dispatched methods of a class.
 ///
 /// You must override these two methods in your subclass:
@@ -192,33 +148,8 @@ template <class T> class SILVTableVisitor {
     if (!theClass->hasKnownSwiftImplementation())
       return;
 
-    // Note that while vtable order is not ABI, we still want it to be
-    // consistent between translation units.
-    //
-    // So, sort synthesized members by their mangled name, since they
-    // are added lazily during type checking, with the remaining ones
-    // forced at the end.
-    SortedFuncList synthesizedMembers;
-
-    for (auto member : theClass->getEmittedMembers()) {
-      if (auto *afd = dyn_cast<AbstractFunctionDecl>(member)) {
-        if (afd->isSynthesized()) {
-          synthesizedMembers.add(afd);
-          continue;
-        }
-      }
-
+    for (auto member : theClass->getEmittedMembers())
       maybeAddMember(member);
-    }
-
-    if (synthesizedMembers.empty())
-      return;
-
-    synthesizedMembers.sort();
-
-    for (const auto &pair : synthesizedMembers) {
-      maybeAddMember(pair.second);
-    }
   }
 };
 

lib/AST/ASTMangler.cpp

@@ -2741,7 +2741,7 @@ void ASTMangler::appendConstructorEntity(const ConstructorDecl *ctor,
 }
 
 void ASTMangler::appendDestructorEntity(const DestructorDecl *dtor,
-                                     bool isDeallocating) {
+                                        bool isDeallocating) {
   appendContextOf(dtor);
   appendOperator(isDeallocating ? "fD" : "fd");
 }

lib/AST/Decl.cpp

@@ -4310,11 +4310,11 @@ DestructorDecl *ClassDecl::getDestructor() const {
                            nullptr);
 }
 
-DeclRange ClassDecl::getEmittedMembers() const {
+ArrayRef<Decl *> ClassDecl::getEmittedMembers() const {
   ASTContext &ctx = getASTContext();
   return evaluateOrDefault(ctx.evaluator,
                            EmittedMembersRequest{const_cast<ClassDecl *>(this)},
-                           getMembers());
+                           ArrayRef<Decl *>());
 }
 
 /// Synthesizer callback for an empty implicit function body.
@@ -4343,6 +4343,10 @@ GetDestructorRequest::evaluate(Evaluator &evaluator, ClassDecl *CD) const {
   if (ctx.LangOpts.EnableObjCInterop)
     CD->recordObjCMethod(DD, DD->getObjCSelector());
 
+  // Mark it as synthesized to make its location in getEmittedMembers()
+  // deterministic.
+  DD->setSynthesized(true);
+
   return DD;
 }
 

lib/AST/TypeCheckRequests.cpp

@@ -788,23 +788,6 @@ void SynthesizeAccessorRequest::cacheResult(AccessorDecl *accessor) const {
   storage->setSynthesizedAccessor(kind, accessor);
 }
 
-//----------------------------------------------------------------------------//
-// EmittedMembersRequest computation.
-//----------------------------------------------------------------------------//
-
-Optional<DeclRange>
-EmittedMembersRequest::getCachedResult() const {
-  auto *classDecl = std::get<0>(getStorage());
-  if (classDecl->hasForcedEmittedMembers())
-    return classDecl->getMembers();
-  return None;
-}
-
-void EmittedMembersRequest::cacheResult(DeclRange result) const {
-  auto *classDecl = std::get<0>(getStorage());
-  classDecl->setHasForcedEmittedMembers();
-}
-
 //----------------------------------------------------------------------------//
 // IsImplicitlyUnwrappedOptionalRequest computation.
 //----------------------------------------------------------------------------//