Merge branch 'master' of github.com:apple/swift into default-derivative

Author: rxwei

docs/DifferentiableProgramming.md

@@ -1699,48 +1699,49 @@ public protocol ElementaryFunctions {
     ...
 }
 
-public extension ElementaryFunctions where Self: Differentiable, Self == Self.TangentVector {
+public extension ElementaryFunctions
+where Self: Differentiable & FloatingPoint, Self == Self.TangentVector {
     @inlinable
     @derivative(of: sqrt)
-    func _(_ x: Self) -> (value: Self, differential: @differential(linear) (Self) -> Self) {
+    static func _(_ x: Self) -> (value: Self, differential: @differentiable(linear) (Self) -> Self) {
         (sqrt(x), { dx in (1 / 2) * (1 / sqrt(x)) * dx })
     }
 
     @inlinable
     @derivative(of: cos)
-    func _(_ x: Self) -> (value: Self, differential: @differential(linear) (Self) -> Self) {
+    static func _(_ x: Self) -> (value: Self, differential: @differentiable(linear) (Self) -> Self) {
         (cos(x), { dx in -sin(x) * dx })
     }
 
     @inlinable
     @derivative(of: asinh)
-    func _(_ x: Self) -> (value: Self, differential: @differential(linear) (Self) -> Self) {
+    static func _(_ x: Self) -> (value: Self, differential: @differentiable(linear) (Self) -> Self) {
         (asinh(x), { dx in 1 / (1 + x * x) * dx })
     }
 
     @inlinable
     @derivative(of: exp)
-    func _(_ x: Self) -> (value: Self, differential: @differential(linear) (Self) -> Self) {
+    static func _(_ x: Self) -> (value: Self, differential: @differentiable(linear) (Self) -> Self) {
         let ret = exp(x)
         return (ret, { dx in ret * dx })
     }
 
     @inlinable
     @derivative(of: exp10)
-    func _(_ x: Self) -> (value: Self, differential: @differential(linear) (Self) -> Self) {
+    static func _(_ x: Self) -> (value: Self, differential: @differentiable(linear) (Self) -> Self) {
         let ret = exp10(x)
         return (ret, { dx in exp(10) * ret * dx })
     }
 
     @inlinable
     @derivative(of: log)
-    func _(_ x: Self) -> (value: Self, differential: @differential(linear) (Self) -> Self) {
+    static func _(_ x: Self) -> (value: Self, differential: @differential(linear) (Self) -> Self) {
         (log(x), { dx in 1 / x * dx })
     }
 
     @inlinable
     @derivative(of: pow)
-    func _(_ x: Self, _ y: Self) -> (value: Self, differential: @differential(linear) (Self, Self) -> Self) {
+    static func _(_ x: Self, _ y: Self) -> (value: Self, differential: @differentiable(linear) (Self, Self) -> Self) {
         (pow(x, y), { (dx, dy) in
             let l = y * pow(x, y-1) * dx
             let r = pow(x, y) * log(x) * dy
@@ -2086,10 +2087,11 @@ differentiating either one will provide derivatives with respect to parameters
 `T` and `U`. Here are some examples of first-order function types and their
 corresponding curried function types:
 
-| First-order function type                 | Curried function type                           |
-| @differentiable (T, U) -> V               | @differentiable (T) -> @differentiable (U) -> V |
-| @differentiable (T, @noDerivative U) -> V | @differentiable (T) -> (U) -> V                 |
-| @differentiable (@noDerivative T, U) -> V | (T) -> @differentiable (U) -> V                 |
+| First-order function type                   | Curried function type                             |
+|---------------------------------------------|---------------------------------------------------|
+| `@differentiable (T, U) -> V`               | `@differentiable (T) -> @differentiable (U) -> V` |
+| `@differentiable (T, @noDerivative U) -> V` | `@differentiable (T) -> (U) -> V`                 |
+| `@differentiable (@noDerivative T, U) -> V` | `(T) -> @differentiable (U) -> V`                 |
 
 A curried differentiable function can be formed like any curried
 non-differentiable function in Swift.
@@ -2610,9 +2612,7 @@ func valueWithDifferential<T: FloatingPoint, U: Differentiable>(
 
 To differentiate `valueWithDifferential`, we need to be able to differentiate
 its return value, a tuple of the original value and the differential, with
-respect to its `x` argument. Since the return type contains a function,
-[differentiation of higher-order functions](#differentiation-of-higher-order-functions)
-is required for differentiating this differential operator.
+respect to its `x` argument.
 
 A kneejerk solution is to differentiate derivative functions generated by the
 differentiation transform at compile-time, but this leads to problems. For

docs/WindowsBuild.md

@@ -32,7 +32,8 @@ git clone https://github.com/apple/swift-corelibs-libdispatch toolchain/swift-co
 git clone https://github.com/apple/swift-corelibs-foundation toolchain/swift-corelibs-foundation
 git clone https://github.com/apple/swift-corelibs-xctest toolchain/swift-corelibs-xctest
 git clone https://github.com/apple/swift-llbuild toolchain/llbuild
-git clone -c core.autocrlf=input https://github.com/apple/swift-package-manager toolchain/swift-package-manager
+git clone https://github.com/apple/swift-tools-support-core toolchain/swift-tools-support-core
+git clone -c core.autocrlf=input https://github.com/apple/swift-package-manager toolchain/swiftpm
 git clone https://github.com/compnerd/windows-swift windows-swift
 ```
 
@@ -155,17 +156,15 @@ path S:\b\llbuild\bin;%PATH%
 ## Build swift-tools-core-support
 
 ```cmd
-md S:\b\tsc
 cmake -B S:\b\tsc -G Ninja -S S:\toolchain\swift-tools-support-core -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_C_COMPILER=cl -DCMAKE_Swift_COMPILER=S:/b/toolchain/bin/swiftc.exe -DFoundation_DIR=S:/b/foundation/cmake/modules -Ddispatch_DIR=S:/b/libdispatch/cmake/modules
 ninja -C S:\b\tsc
 ```
 
 ## Build swift-package-manager
 
 ```cmd
-md S:\b\spm
-cd S:\b\spm
-C:\Python27\python.exe S:\swift-package-manager\Utilities\bootstrap --foundation S:\b\foundation --libdispatch-build-dir S:\b\libdispatch --libdispatch-source-dir S:\swift-corelibs-libdispatch --llbuild-build-dir S:\b\llbuild --llbuild-source-dir S:\llbuild --sqlite-build-dir S:\b\sqlite --sqlite-source-dir S:\sqlite-amalgamation-3270200
+cmake -B S:\b\spm -G Ninja -S S:\toolchain\swiftpm -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_C_COMPILER=S:/b/toolchain/bin/clang-cl.exe -DCMAKE_CXX_COMPILER=S:/b/toolchain/bin/clang-cl.exe -DCMAKE_Swift_COMPILER=S:/b/toolchain/bin/swiftc.exe -DUSE_VENDORED_TSC=YES -DFoundation_DIR=S:/b/foundation/cmake/modules -Ddispatch_DIR=S:/b/libdispatch/cmake/modules -DLLBuild_DIR=S:/b/llbuild/cmake/modules
+ninja -C S:\b\spm
 ```
 
 ## Install the Swift toolchain on Windows

include/swift/Driver/Compilation.h

@@ -257,6 +257,21 @@ class Compilation {
   /// limit filelists will be used.
   size_t FilelistThreshold;
 
+  /// Because each frontend job outputs the same info in its .d file, only do it
+  /// on the first job that actually runs. Write out dummies for the rest of the
+  /// jobs. This hack saves a lot of time in the build system when incrementally
+  /// building a project with many files. Record if a scheduled job has already
+  /// added -emit-dependency-path.
+  bool HaveAlreadyAddedDependencyPath = false;
+
+  /// When set, only the first scheduled frontend job gets the argument needed
+  /// to produce a make-style dependency file. The other jobs create dummy files
+  /// in the driver. This hack speeds up incremental compilation by reducing the
+  /// time for the build system to read each dependency file, which are all
+  /// identical. This optimization can be disabled by passing
+  /// -disable-only-one-dependency-file on the command line.
+  const bool OnlyOneDependencyFile;
+
   /// Scaffolding to permit experimentation with finer-grained dependencies and
   /// faster rebuilds.
   const bool EnableFineGrainedDependencies;
@@ -309,6 +324,7 @@ class Compilation {
               bool SaveTemps = false,
               bool ShowDriverTimeCompilation = false,
               std::unique_ptr<UnifiedStatsReporter> Stats = nullptr,
+              bool OnlyOneDependencyFile = false,
               bool EnableFineGrainedDependencies = false,
               bool VerifyFineGrainedDependencyGraphAfterEveryImport = false,
               bool EmitFineGrainedDependencyDotFileAfterEveryImport = false,
@@ -427,6 +443,14 @@ class Compilation {
     return FilelistThreshold;
   }
 
+  /// Called to decide whether to add a dependency path argument, or whether to
+  /// create a dummy file. Responds by invoking one of the two passed-in
+  /// functions.
+  void addDependencyPathOrCreateDummy(
+      const CommandOutput &Output,
+      function_ref<void(StringRef)> addDependencyPath,
+      function_ref<void(StringRef)> createDummy);
+
   UnifiedStatsReporter *getStatsReporter() const {
     return Stats.get();
   }

include/swift/Option/Options.td

@@ -139,6 +139,11 @@ def enable_fine_grained_dependencies :
 Flag<["-"], "enable-fine-grained-dependencies">, Flags<[FrontendOption, HelpHidden]>,
 HelpText<"Experimental work-in-progress to be more selective about incremental recompilation">;
 
+
+def disable_only_one_dependency_file :
+Flag<["-"], "disable-only-one-dependency-file">, Flags<[DoesNotAffectIncrementalBuild]>,
+ HelpText<"Disables incremental build optimization that only produces one dependencies file">;
+
 def enable_source_range_dependencies :
 Flag<["-"], "enable-source-range-dependencies">, Flags<[]>,
 HelpText<"Try using source range information">;

include/swift/SIL/OwnershipUtils.h

@@ -187,6 +187,14 @@ class LinearLifetimeChecker {
   bool validateLifetime(SILValue value,
                         ArrayRef<SILInstruction *> consumingUses,
                         ArrayRef<SILInstruction *> nonConsumingUses) {
+    assert(llvm::all_of(
+               consumingUses,
+               [](SILInstruction *i) { return !isa<CondBranchInst>(i); }) &&
+           "Passed cond branch to a non-BranchPropagatedUser API");
+    assert(llvm::all_of(
+               nonConsumingUses,
+               [](SILInstruction *i) { return !isa<CondBranchInst>(i); }) &&
+           "Passed cond branch to a non-BranchPropagatedUser API");
     auto *consumingUsesCast =
         reinterpret_cast<const BranchPropagatedUser *>(consumingUses.data());
     auto *nonConsumingUsesCast =
@@ -420,11 +428,11 @@ struct BorrowScopeIntroducingValue {
   ///
   /// NOTE: Scratch space is used internally to this method to store the end
   /// borrow scopes if needed.
-  bool areInstructionsWithinScope(
-      ArrayRef<BranchPropagatedUser> instructions,
-      SmallVectorImpl<BranchPropagatedUser> &scratchSpace,
-      SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
-      DeadEndBlocks &deadEndBlocks) const;
+  bool
+  areInstructionsWithinScope(ArrayRef<SILInstruction *> instructions,
+                             SmallVectorImpl<SILInstruction *> &scratchSpace,
+                             SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
+                             DeadEndBlocks &deadEndBlocks) const;
 
 private:
   /// Internal constructor for failable static constructor. Please do not expand

include/swift/SILOptimizer/PassManager/Passes.def

@@ -311,6 +311,8 @@ PASS(SimplifyUnreachableContainingBlocks, "simplify-unreachable-containing-block
      "Utility pass. Removes all non-term insts from blocks with unreachable terms")
 PASS(SerializeSILPass, "serialize-sil",
      "Utility pass. Serializes the current SILModule")
+PASS(CMOSerializeSILPass, "cmo-serialize-sil",
+     "Utility pass. Serializes the current SILModule for cross-module-optimization")
 PASS(NonInlinableFunctionSkippingChecker, "check-non-inlinable-function-skipping",
      "Utility pass to ensure -experimental-skip-non-inlinable-function-bodies "
      "skips everything it should")

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -161,12 +161,21 @@ bool tryCheckedCastBrJumpThreading(
 /// A structure containing callbacks that are called when an instruction is
 /// removed or added.
 struct InstModCallbacks {
-  using CallbackTy = std::function<void(SILInstruction *)>;
-  CallbackTy deleteInst = [](SILInstruction *inst) { inst->eraseFromParent(); };
-  CallbackTy createdNewInst = [](SILInstruction *) {};
-
-  InstModCallbacks(CallbackTy deleteInst, CallbackTy createdNewInst)
-      : deleteInst(deleteInst), createdNewInst(createdNewInst) {}
+  std::function<void(SILInstruction *)> deleteInst = [](SILInstruction *inst) {
+    inst->eraseFromParent();
+  };
+  std::function<void(SILInstruction *)> createdNewInst = [](SILInstruction *) {
+  };
+  std::function<void(SILValue, SILValue)> replaceValueUsesWith =
+      [](SILValue oldValue, SILValue newValue) {
+        oldValue->replaceAllUsesWith(newValue);
+      };
+
+  InstModCallbacks(decltype(deleteInst) deleteInst,
+                   decltype(createdNewInst) createdNewInst,
+                   decltype(replaceValueUsesWith) replaceValueUsesWith)
+      : deleteInst(deleteInst), createdNewInst(createdNewInst),
+        replaceValueUsesWith(replaceValueUsesWith) {}
   InstModCallbacks() = default;
   ~InstModCallbacks() = default;
   InstModCallbacks(const InstModCallbacks &) = default;
@@ -391,6 +400,10 @@ findLocalApplySites(FunctionRefBaseInst *fri);
 /// Gets the base implementation of a method.
 AbstractFunctionDecl *getBaseMethod(AbstractFunctionDecl *FD);
 
+SILInstruction *
+tryOptimizeApplyOfPartialApply(PartialApplyInst *pai, SILBuilder &builder,
+                               InstModCallbacks callbacks = InstModCallbacks());
+
 } // end namespace swift
 
 #endif

lib/ClangImporter/ClangImporter.cpp

@@ -2962,12 +2962,36 @@ void ClangImporter::loadExtensions(NominalTypeDecl *nominal,
   // For an Objective-C class, import all of the visible categories.
   if (auto objcClass = dyn_cast_or_null<clang::ObjCInterfaceDecl>(
                          effectiveClangContext.getAsDeclContext())) {
+    SmallVector<clang::NamedDecl *, 4> DelayedCategories;
+
     // Simply importing the categories adds them to the list of extensions.
     for (auto I = objcClass->visible_categories_begin(),
            E = objcClass->visible_categories_end();
          I != E; ++I) {
+      // Delay installing categories that don't have an owning module.
+      if (!I->hasOwningModule()) {
+        DelayedCategories.push_back(*I);
+        continue;
+      }
+
       Impl.importDeclReal(*I, Impl.CurrentVersion);
     }
+
+    // Install all the delayed categories.
+    //
+    // The very notion of a delayed category is a result of an emergent behavior
+    // of the visible categories list and the order we import modules. The list
+    // appears in deserialization order rather than some "source order", so it's
+    // possible for, say, a bridging header to import a module that defines an
+    // interface and some categories, but for the categories in the bridging
+    // header to appear *before* the categories in the module - the imported
+    // module will be deserialized on demand. We take it on faith that if there
+    // is no owning module for a given category, that it was created in such a
+    // way, and thus we install it last to try to emulate what we want
+    // "source order" to mean.
+    for (const auto *DelayedCat : DelayedCategories) {
+      Impl.importDeclReal(DelayedCat, Impl.CurrentVersion);
+    }
   }
 
   // Dig through each of the Swift lookup tables, creating extensions
@@ -3690,6 +3714,24 @@ void ClangImporter::Implementation::lookupAllObjCMembers(
   }
 }
 
+// Force the named member of the entire inheritance hierarchy to be loaded and
+// deserialized before loading the named member of this class. This allows the
+// decl members table to be warmed up and enables the correct identification of
+// overrides.
+static void loadNamedMemberOfSuperclassesIfNeeded(const ClassDecl *CD,
+                                                  DeclBaseName name) {
+  if (!CD)
+    return;
+
+  while ((CD = CD->getSuperclassDecl())) {
+    if (CD->hasClangNode()) {
+      auto ci = CD->getASTContext().getOrCreateLazyIterableContextData(
+          CD, /*lazyLoader=*/nullptr);
+      ci->loader->loadNamedMembers(CD, name, ci->memberData);
+    }
+  }
+}
+
 Optional<TinyPtrVector<ValueDecl *>>
 ClangImporter::Implementation::loadNamedMembers(
     const IterableDeclContext *IDC, DeclBaseName N, uint64_t contextData) {
@@ -3751,6 +3793,8 @@ ClangImporter::Implementation::loadNamedMembers(
 
   assert(isa<clang::ObjCContainerDecl>(CD) || isa<clang::NamespaceDecl>(CD));
 
+  loadNamedMemberOfSuperclassesIfNeeded(dyn_cast<ClassDecl>(D), N);
+
   TinyPtrVector<ValueDecl *> Members;
   for (auto entry : table->lookup(SerializedSwiftName(N),
                                   effectiveClangContext)) {