---

yaml
---
r: 341727
b: refs/heads/rxwei-patch-1
c: 675141b
h: refs/heads/master
i:
  341725: 25e5ad8
  341723: c61910d
  341719: 5d98fd0
  341711: 5be83fe
  341695: 2266551

Author: slavapestov

[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: 5022d8be5dc0527429785c6d6543bd6555550d1c
+refs/heads/rxwei-patch-1: 675141b5530c339f66f2ac7a6196047e23c24a39
 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/Basic/SourceManager.h

@@ -231,9 +231,14 @@ class SourceManager {
   void verifyAllBuffers() const;
 
   /// Translate line and column pair to the offset.
+  /// If the column number is the maximum unsinged int, return the offset of the end of the line.
   llvm::Optional<unsigned> resolveFromLineCol(unsigned BufferId, unsigned Line,
                                               unsigned Col) const;
 
+  /// Translate the end position of the given line to the offset.
+  llvm::Optional<unsigned> resolveOffsetForEndOfLine(unsigned BufferId,
+                                                     unsigned Line) const;
+
   SourceLoc getLocForLineCol(unsigned BufferId, unsigned Line, unsigned Col) const {
     auto Offset = resolveFromLineCol(BufferId, Line, Col);
     return Offset.hasValue() ? getLocForOffset(BufferId, Offset.getValue()) :

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/Basic/SourceLoc.cpp

@@ -310,12 +310,19 @@ void CharSourceRange::dump(const SourceManager &SM) const {
   print(llvm::errs(), SM);
 }
 
+llvm::Optional<unsigned>
+SourceManager::resolveOffsetForEndOfLine(unsigned BufferId,
+                                         unsigned Line) const {
+  return resolveFromLineCol(BufferId, Line, ~0u);
+}
+
 llvm::Optional<unsigned> SourceManager::resolveFromLineCol(unsigned BufferId,
                                                            unsigned Line,
                                                            unsigned Col) const {
   if (Line == 0 || Col == 0) {
     return None;
   }
+  const bool LineEnd = Col == ~0u;
   auto InputBuf = getLLVMSourceMgr().getMemoryBuffer(BufferId);
   const char *Ptr = InputBuf->getBufferStart();
   const char *End = InputBuf->getBufferEnd();
@@ -331,14 +338,18 @@ llvm::Optional<unsigned> SourceManager::resolveFromLineCol(unsigned BufferId,
     return None;
   }
   Ptr = LineStart;
-
   // The <= here is to allow for non-inclusive range end positions at EOF
-  for (; Ptr <= End; ++Ptr) {
+  for (; ; ++Ptr) {
     --Col;
     if (Col == 0)
       return Ptr - InputBuf->getBufferStart();
-    if (*Ptr == '\n')
-      break;
+    if (*Ptr == '\n' || Ptr == End) {
+      if (LineEnd) {
+        return Ptr - InputBuf->getBufferStart();
+      } else {
+        break;
+      }
+    }
   }
   return None;
 }

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,