Merge main 2020-11-11

.github/workflows/main.yml

@@ -129,6 +129,8 @@ jobs:
           sudo xcode-select --switch /Applications/Xcode_12.2.app/Contents/Developer/
           xcodebuild -version
           ./utils/webassembly/ci.sh
+        env:
+          SKIP_XCODE_VERSION_CHECK: 1 # Skip upstream update the compatible Xcode version
       - name: Upload macOS installable archive
         uses: actions/upload-artifact@v1
         with:

benchmark/CMakeLists.txt

@@ -98,6 +98,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Hash
     single-source/Histogram
     single-source/HTTP2StateMachine
+    single-source/IndexPathTest
     single-source/InsertCharacter
     single-source/IntegerParsing
     single-source/Integrate

benchmark/single-source/IndexPathTest.swift

@@ -0,0 +1,134 @@
+//===--- IndexPathTest.swift ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+import TestsUtils
+
+let size = 200
+let increasingIndexPath = indexPath(size)
+let decreasingIndexPath = indexPath(size, reversed: true)
+let increasingMaxMiddleIndexPath = indexPath(size, middle: size + 1)
+let increasingMinMiddleIndexPath = indexPath(size, middle: -1)
+let tags: [BenchmarkCategory] = [.validation, .api, .IndexPath]
+
+public let IndexPathTest = [
+  BenchmarkInfo(
+    name: "IndexPath.Subscript.Mutation",
+    runFunction: run_IndexPathSubscriptMutation,
+    tags: tags,
+    setUpFunction: { blackHole(increasingIndexPath) }),
+  BenchmarkInfo(
+    name: "IndexPath.Subscript.Range.Mutation",
+    runFunction: run_IndexPathSubscriptRangeMutation,
+    tags: tags,
+    setUpFunction: { blackHole(increasingIndexPath) }),
+  BenchmarkInfo(
+    name: "IndexPath.Max",
+    runFunction: run_IndexPathMax,
+    tags: tags,
+    setUpFunction: {
+      blackHole(decreasingIndexPath)
+      blackHole(increasingMaxMiddleIndexPath)
+      blackHole(increasingIndexPath)
+    }),
+  BenchmarkInfo(
+    name: "IndexPath.Min",
+    runFunction: run_IndexPathMin,
+    tags: tags,
+    setUpFunction: {
+      blackHole(increasingIndexPath)
+      blackHole(increasingMinMiddleIndexPath)
+      blackHole(decreasingIndexPath)
+    }),
+]
+
+func indexPath(_ size: Int, reversed: Bool = false) -> IndexPath {
+  let indexes = Array(0..<size)
+  return IndexPath(indexes: reversed ? indexes.reversed() : indexes)
+}
+
+func indexPath(_ size: Int, middle: Int) -> IndexPath {
+  var indexes = Array(0..<size)
+  indexes.insert(middle, at: (indexes.count - 1) / 2)
+  return IndexPath(indexes: indexes)
+}
+
+// Subscript Mutations
+
+@inline(__always)
+func subscriptMutation(
+  n: Int,
+  mutations: Int,
+  indexPath: IndexPath,
+  mutate: (inout IndexPath, Int) -> Void
+) {
+  for _ in 0..<n {
+    for i in 0..<mutations {
+      var ip = indexPath
+      mutate(&ip, i)
+    }
+  }
+}
+
+@inline(never)
+public func run_IndexPathSubscriptMutation(_ n: Int) {
+  subscriptMutation(
+    n: n * 10, mutations: size, indexPath: increasingIndexPath,
+    mutate: { ip, i in
+      ip[i % 4] += 1
+    })
+}
+
+@inline(never)
+public func run_IndexPathSubscriptRangeMutation(_ n: Int) {
+  subscriptMutation(
+    n: n, mutations: size, indexPath: increasingIndexPath,
+    mutate: { ip, i in
+      ip[0..<i] += [i]
+    })
+}
+
+// Max
+
+@inline(never)
+public func run_IndexPathMax(_ n: Int) {
+  for _ in 0..<n * 10 {
+    var val: Int?
+    // Beginning max
+    val = decreasingIndexPath.max()
+    blackHole(val)
+    // Middle max
+    val = increasingMaxMiddleIndexPath.max()
+    blackHole(val)
+    // End max
+    val = increasingIndexPath.max()
+    blackHole(val)
+  }
+}
+
+// Min
+
+@inline(never)
+public func run_IndexPathMin(_ n: Int) {
+  for _ in 0..<n * 10 {
+    var val: Int?
+    // Beginning min
+    val = increasingIndexPath.min()
+    blackHole(val)
+    // Middle min
+    val = increasingMinMiddleIndexPath.min()
+    blackHole(val)
+    // End min
+    val = decreasingIndexPath.min()
+    blackHole(val)
+  }
+}

benchmark/utils/TestsUtils.swift

@@ -23,7 +23,7 @@ public enum BenchmarkCategory : String {
   // we know is important to measure.
   case validation
   // subsystems to validate and their subcategories.
-  case api, Array, String, Dictionary, Codable, Set, Data
+  case api, Array, String, Dictionary, Codable, Set, Data, IndexPath
   case sdk
   case runtime, refcount, metadata
   // Other general areas of compiled code validation.

benchmark/utils/main.swift

@@ -86,6 +86,7 @@ import Hanoi
 import Hash
 import Histogram
 import HTTP2StateMachine
+import IndexPathTest
 import InsertCharacter
 import IntegerParsing
 import Integrate
@@ -274,6 +275,7 @@ registerBenchmark(Hanoi)
 registerBenchmark(HashTest)
 registerBenchmark(Histogram)
 registerBenchmark(HTTP2StateMachine)
+registerBenchmark(IndexPathTest)
 registerBenchmark(InsertCharacter)
 registerBenchmark(IntegerParsing)
 registerBenchmark(IntegrateTest)

include/swift/AST/DiagnosticsSema.def

@@ -2758,12 +2758,8 @@ ERROR(conformance_from_implementation_only_module,none,
       "the conformance is declared as SPI in %3|"
       "the conformance is declared as SPI}4",
       (Type, Identifier, unsigned, Identifier, unsigned))
-ERROR(assoc_conformance_from_implementation_only_module,none,
-      "cannot use conformance of %0 to %1 in associated type %3 (inferred as "
-      "%4); %select{%2 has been imported as implementation-only|"
-      "the conformance is declared as SPI in %2|"
-      "the conformance is declared as SPI}5",
-      (Type, Identifier, Identifier, Type, Type, unsigned))
+NOTE(assoc_conformance_from_implementation_only_module,none,
+     "in associated type %0 (inferred as %1)", (Type, Type))
 ERROR(unexportable_clang_function_type,none,
       "cannot export the underlying C type of the function type %0; "
       "it may use anonymous types or types defined outside of a module",

include/swift/AST/PlatformKinds.def

@@ -33,5 +33,6 @@ AVAILABILITY_PLATFORM(macOSApplicationExtension, "application extensions for mac
 AVAILABILITY_PLATFORM(macCatalyst, "Mac Catalyst")
 AVAILABILITY_PLATFORM(macCatalystApplicationExtension, "application extensions for Mac Catalyst")
 AVAILABILITY_PLATFORM(OpenBSD, "OpenBSD")
+AVAILABILITY_PLATFORM(Windows, "Windows")
 
 #undef AVAILABILITY_PLATFORM

include/swift/Basic/LangOptions.h

@@ -367,6 +367,10 @@ namespace swift {
     /// TODO: remove this when @_implementationOnly modules are robust enough.
     bool AllowDeserializingImplementationOnly = false;
 
+    // Allow errors during module generation. See corresponding option in
+    // FrontendOptions.
+    bool AllowModuleWithCompilerErrors = false;
+
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

include/swift/Frontend/Frontend.h

@@ -416,6 +416,10 @@ class CompilerInstance {
   std::unique_ptr<Lowering::TypeConverter> TheSILTypes;
   std::unique_ptr<DiagnosticVerifier> DiagVerifier;
 
+  /// A cache describing the set of inter-module dependencies that have been queried.
+  /// Null if not present.
+  std::unique_ptr<ModuleDependenciesCache> ModDepCache;
+
   /// Null if no tracker.
   std::unique_ptr<DependencyTracker> DepTracker;
   /// If there is no stats output directory by the time the
@@ -487,6 +491,8 @@ class CompilerInstance {
   DependencyTracker *getDependencyTracker() { return DepTracker.get(); }
   const DependencyTracker *getDependencyTracker() const { return DepTracker.get(); }
 
+  ModuleDependenciesCache *getModuleDependencyCache() { return ModDepCache.get(); }
+
   UnifiedStatsReporter *getStatsReporter() const { return Stats.get(); }
 
   /// Retrieve the main module containing the files being compiled.
@@ -552,6 +558,7 @@ class CompilerInstance {
   bool setUpVirtualFileSystemOverlays();
   void setUpLLVMArguments();
   void setUpDiagnosticOptions();
+  void setUpModuleDependencyCacheIfNeeded();
   bool setUpModuleLoaders();
   bool setUpInputs();
   bool setUpASTContextIfNeeded();

include/swift/Frontend/FrontendOptions.h

@@ -292,6 +292,12 @@ class FrontendOptions {
   /// any merge-modules jobs.
   bool EnableExperimentalCrossModuleIncrementalBuild = false;
 
+  /// Best effort to output a .swiftmodule regardless of any compilation
+  /// errors. SIL generation and serialization is skipped entirely when there
+  /// are errors. The resulting serialized AST may include errors types and
+  /// skip nodes entirely, depending on the errors involved.
+  bool AllowModuleWithCompilerErrors = false;
+
   /// The different modes for validating TBD against the LLVM IR.
   enum class TBDValidationMode {
     Default,        ///< Do the default validation for the current platform.

include/swift/Option/FrontendOptions.td

@@ -779,4 +779,9 @@ def experimental_skip_all_function_bodies:
   Flag<["-"], "experimental-skip-all-function-bodies">,
   HelpText<"Skip type-checking function bodies and all SIL generation">;
 
+def experimental_allow_module_with_compiler_errors:
+  Flag<["-"], "experimental-allow-module-with-compiler-errors">,
+  Flags<[HelpHidden]>,
+  HelpText<"Attempt to output .swiftmodule, regardless of compilation errors">;
+
 } // end let Flags = [FrontendOption, NoDriverOption, HelpHidden]