---

yaml
---
r: 341743
b: refs/heads/rxwei-patch-1
c: 2c5d880
h: refs/heads/master
i:
  341741: 2dc4870
  341739: 899f26d
  341735: 5ba6c91
  341727: 01d02b2

Author: compnerd

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: a030e6190ab98b4076474353407a0ed01d4e884b
+refs/heads/rxwei-patch-1: 2c5d8804925a94f2ae064f8a0d87b66dc9aab865
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/include/swift/AST/SimpleRequest.h

@@ -113,9 +113,7 @@ namespace detail {
 
   /// Extract the first, nearest source location from a tuple.
   template<unsigned Index, typename ...Types,
-           typename = typename std::enable_if<sizeof...(Types) - Index
-                                                  ? true
-                                                  : false>::type>
+           typename = typename std::enable_if<(Index < sizeof...(Types))>::type>
   SourceLoc extractNearestSourceLocTuple(const std::tuple<Types...> &value) {
     SourceLoc loc = maybeExtractNearestSourceLoc(std::get<Index>(value));
     if (loc.isValid())

branches/rxwei-patch-1/include/swift/Driver/Action.h

@@ -52,9 +52,10 @@ class Action {
     GenerateDSYMJob,
     VerifyDebugInfoJob,
     GeneratePCHJob,
+    LoadModuleJob,
 
     JobFirst = CompileJob,
-    JobLast = GeneratePCHJob
+    JobLast = LoadModuleJob
   };
 
   static const char *getClassName(Kind AC);
@@ -338,6 +339,24 @@ class StaticLinkJobAction : public JobAction {
   }
 };
 
+/// An action that will attempt to load a specific module before any other
+/// actions.
+class LoadModuleJobAction : public JobAction {
+  virtual void anchor();
+  std::string moduleName;
+
+  public:
+  LoadModuleJobAction(StringRef moduleName)
+    : JobAction(Action::Kind::LoadModuleJob, {}, file_types::TY_Nothing),
+      moduleName(moduleName) {}
+
+  StringRef getModuleName() const { return moduleName; }
+
+  static bool classof(const Action *A) {
+    return A->getKind() == Action::Kind::LoadModuleJob;
+  }
+};
+
 } // end namespace driver
 } // end namespace swift
 

branches/rxwei-patch-1/include/swift/Driver/ToolChain.h

@@ -164,6 +164,9 @@ class ToolChain {
   virtual InvocationInfo constructInvocation(const StaticLinkJobAction &job,
                                              const JobContext &context) const;
 
+  virtual InvocationInfo constructInvocation(const LoadModuleJobAction &job,
+                                             const JobContext &context) const;
+
   /// Searches for the given executable in appropriate paths relative to the
   /// Swift binary.
   ///

branches/rxwei-patch-1/lib/Driver/Action.cpp

@@ -33,6 +33,7 @@ const char *Action::getClassName(Kind AC) {
   case Kind::GenerateDSYMJob:  return "generate-dSYM";
   case Kind::VerifyDebugInfoJob:  return "verify-debug-info";
   case Kind::GeneratePCHJob:  return "generate-pch";
+  case Kind::LoadModuleJob:  return "load-module";
   }
 
   llvm_unreachable("invalid class");
@@ -65,3 +66,5 @@ void GenerateDSYMJobAction::anchor() {}
 void VerifyDebugInfoJobAction::anchor() {}
 
 void GeneratePCHJobAction::anchor() {}
+
+void LoadModuleJobAction::anchor() {}

branches/rxwei-patch-1/lib/Driver/Driver.cpp

@@ -1731,6 +1731,25 @@ Driver::computeCompilerMode(const DerivedArgList &Args,
   return OutputInfo::Mode::SingleCompile;
 }
 
+/// Determines whether the given set of inputs has multiple .swift, .sil, or
+/// .sib inputs, which will require loading the standard library.
+static bool hasMultipleSourceFileInputs(ArrayRef<InputPair> inputs) {
+  bool hasFoundOneSourceFileAlready = false;
+  for (const InputPair &input : inputs) {
+    switch (input.first) {
+    case file_types::TY_Swift:
+    case file_types::TY_SIL:
+    case file_types::TY_SIB:
+      if (hasFoundOneSourceFileAlready)
+        return true;
+      hasFoundOneSourceFileAlready = true;
+      break;
+    default: break;
+    }
+  }
+  return false;
+}
+
 void Driver::buildActions(SmallVectorImpl<const Action *> &TopLevelActions,
                           const ToolChain &TC, const OutputInfo &OI,
                           const InputInfoMap *OutOfDateMap,
@@ -1749,6 +1768,18 @@ void Driver::buildActions(SmallVectorImpl<const Action *> &TopLevelActions,
   switch (OI.CompilerMode) {
   case OutputInfo::Mode::StandardCompile: {
 
+    // If we're not compiling the standard library, and we're going to schedule
+    // multiple parallel compile jobs, add an action before any others that
+    // will quickly load the standard library module.
+    // This will ensure that, if we need to build the standard library from
+    // a module interface, it happens once, rather than once per parallel
+    // invocation.
+    LoadModuleJobAction *preLoadStdlib = nullptr;
+    if (!Args.hasArg(options::OPT_parse_stdlib) &&
+        hasMultipleSourceFileInputs(Inputs)) {
+      preLoadStdlib = C.createAction<LoadModuleJobAction>(STDLIB_NAME);
+    }
+
     // If the user is importing a textual (.h) bridging header and we're in
     // standard-compile (non-WMO) mode, we take the opportunity to precompile
     // the header into a temporary PCH, and replace the import argument with the
@@ -1772,6 +1803,15 @@ void Driver::buildActions(SmallVectorImpl<const Action *> &TopLevelActions,
       }
     }
 
+    // Adds the implicit dependencies for this job action, either generating
+    // a PCH, or pre-loading the standard library, or both.
+    auto addImplicitDeps = [&](Action *action) {
+      if (PCH)
+        cast<JobAction>(action)->addInput(PCH);
+      if (preLoadStdlib)
+        cast<JobAction>(action)->addInput(preLoadStdlib);
+    };
+
     for (const InputPair &Input : Inputs) {
       file_types::ID InputType = Input.first;
       const Arg *InputArg = Input.second;
@@ -1793,17 +1833,15 @@ void Driver::buildActions(SmallVectorImpl<const Action *> &TopLevelActions,
         if (Args.hasArg(options::OPT_embed_bitcode)) {
           Current = C.createAction<CompileJobAction>(
               Current, file_types::TY_LLVM_BC, previousBuildState);
-          if (PCH)
-            cast<JobAction>(Current)->addInput(PCH);
+          addImplicitDeps(Current);
           AllModuleInputs.push_back(Current);
           Current = C.createAction<BackendJobAction>(Current,
                                                      OI.CompilerOutputType, 0);
         } else {
           Current = C.createAction<CompileJobAction>(Current,
                                                      OI.CompilerOutputType,
                                                      previousBuildState);
-          if (PCH)
-            cast<JobAction>(Current)->addInput(PCH);
+          addImplicitDeps(Current);
           AllModuleInputs.push_back(Current);
         }
         AllLinkerInputs.push_back(Current);

branches/rxwei-patch-1/lib/Driver/Job.cpp

@@ -383,9 +383,14 @@ void Job::printSummary(raw_ostream &os) const {
     if (const auto *IA = dyn_cast<InputAction>(A))
       Inputs.push_back(IA->getInputArg().getValue());
 
-  for (const Job *J : getInputs())
+  for (const Job *J : getInputs()) {
+    // Some jobs might produce no output, so don't include them in the
+    // list of inputs.
+    if (J->getOutput().getPrimaryOutputType() == file_types::TY_Nothing)
+      continue;
     for (StringRef f : J->getOutput().getPrimaryOutputFilenames())
       Inputs.push_back(f);
+  }
 
   size_t limit = 3;
   size_t actual_in = Inputs.size();

branches/rxwei-patch-1/lib/Driver/ParseableOutput.cpp

@@ -146,13 +146,27 @@ class DetailedCommandBasedMessage : public CommandBasedMessage {
     });
   }
 
+  /// Subclasses can override this to determine if they should print empty
+  /// arrays for `inputs` and `output`, or if they can omit them.
+  virtual bool requireInputsAndOutputs() {
+    return false;
+  }
+
   void provideMapping(swift::json::Output &out) override {
     Message::provideMapping(out);
     out.mapRequired("command", CommandLine); // Deprecated, do not document
     out.mapRequired("command_executable", Executable);
     out.mapRequired("command_arguments", Arguments);
-    out.mapOptional("inputs", Inputs);
-    out.mapOptional("outputs", Outputs);
+
+    // Some commands can choose to print empty arrays if their inputs and
+    // outputs are empty.
+    if (requireInputsAndOutputs()) {
+      out.mapRequired("inputs", Inputs);
+      out.mapRequired("outputs", Outputs);
+    } else {
+      out.mapOptional("inputs", Inputs);
+      out.mapOptional("outputs", Outputs);
+    }
   }
 };
 
@@ -177,6 +191,12 @@ class BeganMessage : public DetailedCommandBasedMessage {
       : DetailedCommandBasedMessage("began", Cmd), Pid(Pid),
         ProcInfo(ProcInfo) {}
 
+  bool requireInputsAndOutputs() override {
+    /// `began` messages should always print inputs and outputs, even if they
+    /// are empty.
+    return true;
+  }
+
   void provideMapping(swift::json::Output &out) override {
     DetailedCommandBasedMessage::provideMapping(out);
     out.mapRequired("pid", Pid);

branches/rxwei-patch-1/lib/Driver/ToolChain.cpp

@@ -106,6 +106,7 @@ std::unique_ptr<Job> ToolChain::constructJob(
       CASE(GeneratePCHJob)
       CASE(AutolinkExtractJob)
       CASE(REPLJob)
+      CASE(LoadModuleJob)
 #undef CASE
     case Action::Kind::Input:
       llvm_unreachable("not a JobAction");

branches/rxwei-patch-1/lib/Driver/ToolChains.cpp

@@ -1113,6 +1113,40 @@ ToolChain::constructInvocation(const StaticLinkJobAction &job,
    llvm_unreachable("archiving not implemented for this toolchain");
 }
 
+ToolChain::InvocationInfo
+ToolChain::constructInvocation(const LoadModuleJobAction &job,
+                               const JobContext &context) const {
+
+  // Invoke the frontend, passing `-import-module ModuleName` for whatever
+  // module the job is supposed to load.
+
+  InvocationInfo II{SWIFT_EXECUTABLE_NAME};
+  ArgStringList &Arguments = II.Arguments;
+  II.allowsResponseFiles = true;
+
+  for (auto &s : getDriver().getSwiftProgramArgs())
+    Arguments.push_back(s.c_str());
+
+  Arguments.push_back("-frontend");
+  Arguments.push_back("-typecheck");
+
+  // Force importing the module that this job specifies.
+
+  Arguments.push_back("-import-module");
+  Arguments.push_back(context.Args.MakeArgString(job.getModuleName()));
+
+  // Pass along the relevant arguments to the frontend invocation.
+
+  addCommonFrontendArgs(*this, context.OI, context.Output, context.Args,
+                        Arguments);
+
+  // Create an empty temporary file to typecheck.
+  auto tempFile = context.getTemporaryFilePath("tmp", "swift");
+  Arguments.push_back(context.Args.MakeArgString(tempFile));
+
+  return II;
+}
+
 void ToolChain::addPathEnvironmentVariableIfNeeded(
     Job::EnvironmentVector &env, const char *name, const char *separator,
     options::ID optionID, const ArgList &args,

branches/rxwei-patch-1/lib/Frontend/ParseableInterfaceModuleLoader.cpp

@@ -504,7 +504,7 @@ class swift::ParseableInterfaceBuilder {
       // Note that we don't assume cachePath is the same as the Clang
       // module cache path at this point.
       if (!moduleCachePath.empty())
-        (void)llvm::sys::fs::create_directories(moduleCachePath);
+        (void)llvm::sys::fs::create_directory(moduleCachePath);
 
       configureSubInvocationInputsAndOutputs(OutPath);
 
@@ -1267,10 +1267,6 @@ class ParseableInterfaceModuleLoaderImpl {
       depsAdjustedToMTime.push_back(adjustedDep);
     }
 
-    // Create the module cache if we haven't created it yet.
-    StringRef parentDir = path::parent_path(outputPath);
-    (void)llvm::sys::fs::create_directories(parentDir);
-
     auto hadError = withOutputFile(diags, outputPath,
       [&](llvm::raw_pwrite_stream &out) {
         llvm::yaml::Output yamlWriter(out);

branches/rxwei-patch-1/lib/SIL/DynamicCasts.cpp

@@ -292,16 +292,10 @@ CanType swift::getNSBridgedClassOfCFClass(ModuleDecl *M, CanType type) {
 
 static bool isCFBridgingConversion(ModuleDecl *M, SILType sourceType,
                                    SILType targetType) {
-  if (auto bridgedTarget =
-        getNSBridgedClassOfCFClass(M, targetType.getASTType())) {
-    return bridgedTarget->isExactSuperclassOf(sourceType.getASTType());
-  }
-  if (auto bridgedSource =
-        getNSBridgedClassOfCFClass(M, sourceType.getASTType())) {
-    return targetType.getASTType()->isExactSuperclassOf(bridgedSource);
-  }
-  
-  return false;
+  return (sourceType.getASTType() ==
+            getNSBridgedClassOfCFClass(M, targetType.getASTType()) ||
+          targetType.getASTType() ==
+            getNSBridgedClassOfCFClass(M, sourceType.getASTType()));
 }
 
 /// Try to classify the dynamic-cast relationship between two types.
@@ -874,7 +868,7 @@ namespace {
         value = getOwnedScalar(source, srcTL);
       }
       auto targetTy = target.LoweredType;
-      if (isCFBridgingConversion(SwiftModule, value->getType(), targetTy)) {
+      if (isCFBridgingConversion(SwiftModule, targetTy, value->getType())) {
         value = B.createUncheckedRefCast(Loc, value, targetTy.getObjectType());
       } else {
         value = B.createUpcast(Loc, value, targetTy.getObjectType());

branches/rxwei-patch-1/stdlib/public/SwiftShims/RefCount.h

@@ -1496,7 +1496,6 @@ _Static_assert(_Alignof(InlineRefCounts) == _Alignof(__swift_uintptr_t),
 #endif
 
 #if defined(_WIN32) && defined(_M_ARM64)
-#if defined(__cplusplus)
 namespace std {
 template <>
 inline void _Atomic_storage<swift::SideTableRefCountBits, 16>::_Unlock() const noexcept {
@@ -1506,6 +1505,5 @@ inline void _Atomic_storage<swift::SideTableRefCountBits, 16>::_Unlock() const n
 }
 }
 #endif
-#endif
 
 #endif

branches/rxwei-patch-1/stdlib/public/core/Assert.swift

@@ -236,7 +236,7 @@ public func _overflowChecked<T>(
   let (result, error) = args
   if _isDebugAssertConfiguration() {
     if _slowPath(error) {
-      _fatalErrorMessage("Fatal error", "Overflow/underflow",
+      _fatalErrorMessage("Fatal error", "Overflow/underflow", 
         file: file, line: line, flags: _fatalErrorFlags())
     }
   } else {
@@ -297,22 +297,6 @@ internal func _internalInvariant(
 #endif
 }
 
-// Only perform the invariant check on Swift 5.1 and later
-@_alwaysEmitIntoClient // Swift 5.1
-@_transparent
-internal func _internalInvariant_5_1(
-  _ condition: @autoclosure () -> Bool, _ message: StaticString = StaticString(),
-  file: StaticString = #file, line: UInt = #line
-) {
-#if INTERNAL_CHECKS_ENABLED
-  // FIXME: The below won't run the assert on 5.1 stdlib if testing on older
-  // OSes, which means that testing may not test the assertion. We need a real
-  // solution to this.
-  guard #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) else { return }
-  _internalInvariant(condition(), message, file: file, line: line)
-#endif
-}
-
 @usableFromInline @_transparent
 internal func _internalInvariantFailure(
   _ message: StaticString = StaticString(),

branches/rxwei-patch-1/stdlib/public/core/ContiguousArrayBuffer.swift

@@ -40,6 +40,11 @@ internal final class __EmptyArrayStorage
     return try body(UnsafeBufferPointer(start: nil, count: 0))
   }
 
+  @nonobjc
+  override internal func _getNonVerbatimBridgedCount() -> Int {
+    return 0
+  }
+
   override internal func _getNonVerbatimBridgingBuffer() -> _BridgingBuffer {
     return _BridgingBuffer(0)
   }
@@ -106,6 +111,17 @@ internal final class _ContiguousArrayStorage<
     }
   }
 
+  /// Returns the number of elements in the array.
+  ///
+  /// - Precondition: `Element` is bridged non-verbatim.
+  @nonobjc
+  override internal func _getNonVerbatimBridgedCount() -> Int {
+    _internalInvariant(
+      !_isBridgedVerbatimToObjectiveC(Element.self),
+      "Verbatim bridging should be handled separately")
+    return countAndCapacity.count
+  }
+
   /// Bridge array elements and return a new buffer that owns them.
   ///
   /// - Precondition: `Element` is bridged non-verbatim.