Merge pull request swiftlang#270 from swiftwasm/master

[pull] swiftwasm from master

Author: pull[bot]

docs/CppInteroperabilityManifesto.md

@@ -665,9 +665,10 @@ class alignas(1 << DeclAlignInBits) Decl {
     SourceLoc Loc;
     SourceLoc StartLoc;
     SourceLoc EndLoc;
+    SmallVector<CharSourceRange, 4> DocRanges;
   };
-  mutable CachedExternalSourceLocs const *CachedLocs = nullptr;
-  const CachedExternalSourceLocs *calculateSerializedLocs() const;
+  mutable CachedExternalSourceLocs const *CachedSerializedLocs = nullptr;
+  const CachedExternalSourceLocs *getSerializedLocs() const;
 protected:
 
   Decl(DeclKind kind, llvm::PointerUnion<DeclContext *, ASTContext *> context)
@@ -828,7 +829,7 @@ class alignas(1 << DeclAlignInBits) Decl {
   }
 
   /// \returns the unparsed comment attached to this declaration.
-  RawComment getRawComment() const;
+  RawComment getRawComment(bool SerializedOK = false) const;
 
   Optional<StringRef> getGroupName() const;
 

include/swift/AST/Decl.h

@@ -3285,14 +3285,16 @@ ERROR(partial_application_of_function_invalid,none,
       "partial application of %select{"
         "'mutating' method|"
         "'super.init' initializer chain|"
-        "'self.init' initializer delegation"
+        "'self.init' initializer delegation|"
+        "'super' instance method with metatype base"
       "}0 is not allowed",
       (unsigned))
 WARNING(partial_application_of_function_invalid_swift4,none,
       "partial application of %select{"
         "'mutating' method|"
         "'super.init' initializer chain|"
-        "'self.init' initializer delegation"
+        "'self.init' initializer delegation|"
+        "'super' instance method with metatype base"
       "}0 is not allowed; calling the function has undefined behavior and will "
       "be an error in future Swift versions",
       (unsigned))

include/swift/AST/DiagnosticsSema.def

@@ -284,10 +284,10 @@ class alignas(8) Expr {
     Discriminator : 16
   );
 
-  SWIFT_INLINE_BITFIELD(AutoClosureExpr, AbstractClosureExpr, 1,
-    /// True if this autoclosure was built for a function conversion, and
-    /// not an actual @autoclosure parameter.
-    IsThunk : 1
+  SWIFT_INLINE_BITFIELD(AutoClosureExpr, AbstractClosureExpr, 2,
+    /// If the autoclosure was built for a curry thunk, the thunk kind is
+    /// stored here.
+    Kind : 2
   );
 
   SWIFT_INLINE_BITFIELD(ClosureExpr, AbstractClosureExpr, 1,
@@ -3790,22 +3790,36 @@ class AutoClosureExpr : public AbstractClosureExpr {
   BraceStmt *Body;
 
 public:
+  enum class Kind : uint8_t {
+    // An autoclosure with type () -> Result. Formed from type checking an
+    // @autoclosure argument in a function call.
+    None = 0,
+
+    // An autoclosure with type (Args...) -> Result. Formed from type checking a
+    // partial application.
+    SingleCurryThunk = 1,
+
+    // An autoclosure with type (Self) -> (Args...) -> Result. Formed from type
+    // checking a partial application.
+    DoubleCurryThunk = 2
+  };
+
   AutoClosureExpr(Expr *Body, Type ResultTy, unsigned Discriminator,
                   DeclContext *Parent)
       : AbstractClosureExpr(ExprKind::AutoClosure, ResultTy, /*Implicit=*/true,
                             Discriminator, Parent) {
     if (Body != nullptr)
       setBody(Body);
 
-    Bits.AutoClosureExpr.IsThunk = false;
+    Bits.AutoClosureExpr.Kind = 0;
   }
 
-  bool isThunk() const {
-    return Bits.AutoClosureExpr.IsThunk;
+  Kind getThunkKind() const {
+    return Kind(Bits.AutoClosureExpr.Kind);
   }
 
-  void setIsThunk(bool isThunk) {
-    Bits.AutoClosureExpr.IsThunk = isThunk;
+  void setThunkKind(Kind K) {
+    Bits.AutoClosureExpr.Kind = uint8_t(K);
   }
 
   SourceRange getSourceRange() const;
@@ -3824,6 +3838,16 @@ class AutoClosureExpr : public AbstractClosureExpr {
   /// The body of an autoclosure always consists of a single expression.
   Expr *getSingleExpressionBody() const;
 
+  /// Unwraps a curry thunk. Basically, this gives you what the old AST looked
+  /// like, before Sema started building curry thunks. This is really only
+  /// meant for legacy usages.
+  ///
+  /// The behavior is as follows, based on the kind:
+  /// - for double curry thunks, returns the original DeclRefExpr.
+  /// - for single curry thunks, returns the ApplyExpr for the self call.
+  /// - otherwise, returns nullptr for convenience.
+  Expr *getUnwrappedCurryThunkExpr() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::AutoClosure;

include/swift/AST/Expr.h

@@ -86,6 +86,7 @@ struct LineColumn {
 
 struct BasicDeclLocs {
   StringRef SourceFilePath;
+  SmallVector<std::pair<LineColumn, uint32_t>, 4> DocRanges;
   LineColumn Loc;
   LineColumn StartLoc;
   LineColumn EndLoc;

include/swift/AST/RawComment.h

@@ -50,45 +50,46 @@ class OptionSet {
 
 public:
   /// Create an empty option set.
-  OptionSet() : Storage() { }
+  constexpr OptionSet() : Storage() {}
 
   /// Create an empty option set.
-  OptionSet(llvm::NoneType) : Storage() { }
+  constexpr OptionSet(llvm::NoneType) : Storage() {}
 
   /// Create an option set with only the given option set.
-  OptionSet(Flags flag) : Storage(static_cast<StorageType>(flag)) { }
+  constexpr OptionSet(Flags flag) : Storage(static_cast<StorageType>(flag)) {}
 
   /// Create an option set from raw storage.
-  explicit OptionSet(StorageType storage) : Storage(storage) { }
+  explicit constexpr OptionSet(StorageType storage) : Storage(storage) {}
 
   /// Check whether an option set is non-empty.
-  explicit operator bool() const { return Storage != 0; }
+  explicit constexpr operator bool() const { return Storage != 0; }
 
   /// Explicitly convert an option set to its underlying storage.
-  explicit operator StorageType() const { return Storage; }
+  explicit constexpr operator StorageType() const { return Storage; }
 
   /// Explicitly convert an option set to intptr_t, for use in
   /// llvm::PointerIntPair.
   ///
   /// This member is not present if the underlying type is bigger than
   /// a pointer.
   template <typename T = std::intptr_t>
-  explicit operator typename std::enable_if<sizeof(StorageType) <= sizeof(T),
-      std::intptr_t>::type () const {
+  explicit constexpr
+  operator typename std::enable_if<sizeof(StorageType) <= sizeof(T),
+                                   std::intptr_t>::type() const {
     return static_cast<intptr_t>(Storage);
   }
 
   /// Retrieve the "raw" representation of this option set.
   StorageType toRaw() const { return Storage; }
-  
+
   /// Determine whether this option set contains all of the options in the
   /// given set.
-  bool contains(OptionSet set) const {
+  constexpr bool contains(OptionSet set) const {
     return !static_cast<bool>(set - *this);
   }
 
   /// Check if this option set contains the exact same options as the given set.
-  bool containsOnly(OptionSet set) const {
+  constexpr bool containsOnly(OptionSet set) const {
     return Storage == set.Storage;
   }
 
@@ -97,34 +98,34 @@ class OptionSet {
   // want '==' behavior, use 'containsOnly'.
 
   /// Produce the union of two option sets.
-  friend OptionSet operator|(OptionSet lhs, OptionSet rhs) {
+  friend constexpr OptionSet operator|(OptionSet lhs, OptionSet rhs) {
     return OptionSet(lhs.Storage | rhs.Storage);
   }
 
   /// Produce the union of two option sets.
-  friend OptionSet &operator|=(OptionSet &lhs, OptionSet rhs) {
+  friend constexpr OptionSet &operator|=(OptionSet &lhs, OptionSet rhs) {
     lhs.Storage |= rhs.Storage;
     return lhs;
- }
+  }
 
   /// Produce the intersection of two option sets.
-  friend OptionSet operator&(OptionSet lhs, OptionSet rhs) {
+  friend constexpr OptionSet operator&(OptionSet lhs, OptionSet rhs) {
     return OptionSet(lhs.Storage & rhs.Storage);
   }
 
   /// Produce the intersection of two option sets.
-  friend OptionSet &operator&=(OptionSet &lhs, OptionSet rhs) {
+  friend constexpr OptionSet &operator&=(OptionSet &lhs, OptionSet rhs) {
     lhs.Storage &= rhs.Storage;
     return lhs;
   }
 
   /// Produce the difference of two option sets.
-  friend OptionSet operator-(OptionSet lhs, OptionSet rhs) {
+  friend constexpr OptionSet operator-(OptionSet lhs, OptionSet rhs) {
     return OptionSet(lhs.Storage & ~rhs.Storage);
   }
 
   /// Produce the difference of two option sets.
-  friend OptionSet &operator-=(OptionSet &lhs, OptionSet rhs) {
+  friend constexpr OptionSet &operator-=(OptionSet &lhs, OptionSet rhs) {
     lhs.Storage &= ~rhs.Storage;
     return lhs;
   }

include/swift/Basic/OptionSet.h

@@ -80,10 +80,16 @@ class SILFunctionBuilder {
       SubclassScope subclassScope = SubclassScope::NotApplicable);
 
   /// Return the declaration of a function, or create it if it doesn't exist.
-  SILFunction *
-  getOrCreateFunction(SILLocation loc, SILDeclRef constant,
-                      ForDefinition_t forDefinition,
-                      ProfileCounter entryCount = ProfileCounter());
+  /// Creating a function that references another function (a dynamic
+  /// replacement) requires getting/creating a SIL function for this reference.
+  /// In this case the function will call the \p getOrCreateDeclaration
+  /// callback.
+  SILFunction *getOrCreateFunction(
+      SILLocation loc, SILDeclRef constant, ForDefinition_t forDefinition,
+      llvm::function_ref<SILFunction *(SILLocation loc, SILDeclRef constant)>
+          getOrCreateDeclaration = [](SILLocation loc, SILDeclRef constant)
+          -> SILFunction * { return nullptr; },
+      ProfileCounter entryCount = ProfileCounter());
 
   /// Create a function declaration.
   ///
@@ -104,8 +110,11 @@ class SILFunctionBuilder {
                  SILFunction *InsertBefore = nullptr,
                  const SILDebugScope *DebugScope = nullptr);
 
-  void addFunctionAttributes(SILFunction *F, DeclAttributes &Attrs,
-                             SILModule &M, SILDeclRef constant = SILDeclRef());
+  void addFunctionAttributes(
+      SILFunction *F, DeclAttributes &Attrs, SILModule &M,
+      llvm::function_ref<SILFunction *(SILLocation loc, SILDeclRef constant)>
+          getOrCreateDeclaration,
+      SILDeclRef constant = SILDeclRef());
 
   /// We do not expose this to everyone, instead we allow for our users to opt
   /// into this if they need to. Please do not do this in general! We only want

include/swift/SIL/SILFunctionBuilder.h

@@ -79,6 +79,14 @@ void AbstractSourceFileDepGraphFactory::addAUsedDecl(
     const DependencyKey &defKey, const DependencyKey &useKey) {
   auto *defNode =
       g.findExistingNodeOrCreateIfNew(defKey, None, false /* = !isProvides */);
+  // If the depended-upon node is defined in this file, then don't
+  // create an arc to the user, when the user is the whole file.
+  // Otherwise, if the defNode's type-body fingerprint changes,
+  // the whole file will be marked as dirty, losing the benefit of the
+  // fingerprint.
+  if (defNode->getIsProvides() &&
+      useKey.getKind() == NodeKind::sourceFileProvide)
+    return;
   auto nullableUse = g.findExistingNode(useKey);
   assert(nullableUse.isNonNull() && "Use must be an already-added provides");
   auto *useNode = nullableUse.get();

lib/AST/AbstractSourceFileDepGraphFactory.cpp

@@ -569,7 +569,10 @@ case DeclKind::ID: return cast<ID##Decl>(this)->getLocFromSource();
   llvm_unreachable("Unknown decl kind");
 }
 
-const Decl::CachedExternalSourceLocs *Decl::calculateSerializedLocs() const {
+const Decl::CachedExternalSourceLocs *Decl::getSerializedLocs() const {
+  if (CachedSerializedLocs) {
+    return CachedSerializedLocs;
+  }
   auto *File = cast<FileUnit>(getDeclContext()->getModuleScopeContext());
   auto Locs = File->getBasicLocsForDecl(this);
   if (!Locs.hasValue()) {
@@ -585,6 +588,14 @@ Result->X = SM.getLocFromExternalSource(Locs->SourceFilePath, Locs->X.Line,   \
   CASE(StartLoc)
   CASE(EndLoc)
 #undef CASE
+
+  for (const auto &LineColumnAndLength : Locs->DocRanges) {
+    auto Start = SM.getLocFromExternalSource(Locs->SourceFilePath,
+      LineColumnAndLength.first.Line,
+      LineColumnAndLength.first.Column);
+    Result->DocRanges.push_back({ Start, LineColumnAndLength.second });
+  }
+
   return Result;
 }
 
@@ -625,10 +636,7 @@ static_assert(sizeof(checkSourceLocType(&ID##Decl::getLoc)) == 2, \
   case FileUnitKind::SerializedAST: {
     if (!SerializedOK)
       return SourceLoc();
-    if (!CachedLocs) {
-      CachedLocs = calculateSerializedLocs();
-    }
-    return CachedLocs->Loc;
+    return getSerializedLocs()->Loc;
   }
   case FileUnitKind::Builtin:
   case FileUnitKind::ClangModule:

lib/AST/Decl.cpp

@@ -19,6 +19,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Comment.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/FileUnit.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/RawComment.h"
@@ -502,14 +503,23 @@ StringRef Decl::getBriefComment() const {
   if (!this->canHaveComment())
     return StringRef();
 
-  // Ensure the serialized doc is populated to ASTContext.
-  auto RC = getRawComment();
-
   // Check the cache in ASTContext.
   auto &Context = getASTContext();
   if (Optional<StringRef> Comment = Context.getBriefComment(this))
     return Comment.getValue();
 
+  // Check if the serialized module may have the brief comment available.
+  if (auto *Unit =
+          dyn_cast<FileUnit>(this->getDeclContext()->getModuleScopeContext())) {
+    if (Optional<CommentInfo> C = Unit->getCommentForDecl(this)) {
+      Context.setBriefComment(this, C->Brief);
+      return C->Brief;
+    }
+  }
+
+  // Otherwise, parse the brief from the raw comment itself.
+  auto RC = getRawComment();
+
   StringRef Result;
   if (RC.isEmpty())
     if (auto *docD = getDocCommentProvidingDecl(this))

lib/AST/DocComment.cpp

@@ -1843,6 +1843,46 @@ Expr *AutoClosureExpr::getSingleExpressionBody() const {
   return cast<ReturnStmt>(Body->getFirstElement().get<Stmt *>())->getResult();
 }
 
+Expr *AutoClosureExpr::getUnwrappedCurryThunkExpr() const {
+  switch (getThunkKind()) {
+  case AutoClosureExpr::Kind::None:
+    break;
+
+  case AutoClosureExpr::Kind::SingleCurryThunk: {
+    auto *body = getSingleExpressionBody();
+    body = body->getSemanticsProvidingExpr();
+    if (auto *outerCall = dyn_cast<ApplyExpr>(body)) {
+      return outerCall->getFn();
+    }
+
+    assert(false && "Malformed curry thunk?");
+    break;
+  }
+
+  case AutoClosureExpr::Kind::DoubleCurryThunk: {
+    auto *body = getSingleExpressionBody();
+    if (auto *innerClosure = dyn_cast<AutoClosureExpr>(body)) {
+      assert(innerClosure->getThunkKind() ==
+               AutoClosureExpr::Kind::SingleCurryThunk);
+      auto *innerBody = innerClosure->getSingleExpressionBody();
+      innerBody = innerBody->getSemanticsProvidingExpr();
+      if (auto *outerCall = dyn_cast<ApplyExpr>(innerBody)) {
+        if (auto *innerCall = dyn_cast<ApplyExpr>(outerCall->getFn())) {
+          if (auto *declRef = dyn_cast<DeclRefExpr>(innerCall->getFn())) {
+            return declRef;
+          }
+        }
+      }
+    }
+
+    assert(false && "Malformed curry thunk?");
+    break;
+  }
+  }
+
+  return nullptr;
+}
+
 FORWARD_SOURCE_LOCS_TO(UnresolvedPatternExpr, subPattern)
 
 TypeExpr::TypeExpr(TypeLoc TyLoc)