Resolve conflicts with master

include/swift/AST/DiagnosticsFrontend.def

@@ -39,10 +39,6 @@ ERROR(error_unsupported_target_arch, none,
 ERROR(error_unsupported_opt_for_target, none,
       "unsupported option '%0' for target '%1'", (StringRef, StringRef))
 
-WARNING(warning_inferred_simulator_target,none,
-      "inferring simulator environment for target '%0'; "
-      "use '-target %1' instead", (StringRef, StringRef))
-
 ERROR(error_argument_not_allowed_with, none,
       "argument '%0' is not allowed with '%1'", (StringRef, StringRef))
 

include/swift/Basic/Platform.h

@@ -43,12 +43,12 @@ namespace swift {
   /// Returns true if the given triple represents watchOS running in a simulator.
   bool tripleIsWatchSimulator(const llvm::Triple &triple);
 
+  /// Return true if the given triple represents any simulator.
+  bool tripleIsAnySimulator(const llvm::Triple &triple);
+
   /// Returns true if the given triple represents a macCatalyst environment.
   bool tripleIsMacCatalystEnvironment(const llvm::Triple &triple);
 
-  /// Determine whether the triple infers the "simulator" environment.
-  bool tripleInfersSimulatorEnvironment(const llvm::Triple &triple);
-
   /// Returns true if the given -target triple and -target-variant triple
   /// can be zippered.
   bool triplesAreValidForZippering(const llvm::Triple &target,

include/swift/Frontend/Frontend.h

@@ -386,9 +386,25 @@ class CompilerInvocation {
 
   std::string getLdAddCFileOutputPathForWholeModule() const;
 
+public:
+  /// Given the current configuration of this frontend invocation, a set of
+  /// supplementary output paths, and a module, compute the appropriate set of
+  /// serialization options.
+  ///
+  /// FIXME: The \p module parameter supports the
+  /// \c SerializeOptionsForDebugging hack.
   SerializationOptions
   computeSerializationOptions(const SupplementaryOutputPaths &outs,
-                              bool moduleIsPublic) const;
+                              const ModuleDecl *module) const;
+
+  /// Returns an approximation of whether the given module could be
+  /// redistributed and consumed by external clients.
+  ///
+  /// FIXME: The scope of this computation should be limited entirely to
+  /// PrintAsObjC. Unfortunately, it has been co-opted to support the
+  /// \c SerializeOptionsForDebugging hack. Once this information can be
+  /// transferred from module files to the dSYMs, remove this.
+  bool isModuleExternallyConsumed(const ModuleDecl *mod) const;
 };
 
 /// A class which manages the state and execution of the compiler.
@@ -555,9 +571,7 @@ class CompilerInstance {
   /// Returns true if there was an error during setup.
   bool setup(const CompilerInvocation &Invocation);
 
-  const CompilerInvocation &getInvocation() {
-    return Invocation;
-  }
+  const CompilerInvocation &getInvocation() const { return Invocation; }
 
   /// If a code completion buffer has been set, returns the corresponding source
   /// file.

include/swift/Option/Options.td

@@ -528,6 +528,10 @@ def warnings_as_errors : Flag<["-"], "warnings-as-errors">,
   Flags<[FrontendOption]>,
   HelpText<"Treat warnings as errors">;
 
+def no_warnings_as_errors : Flag<["-"], "no-warnings-as-errors">,
+  Flags<[FrontendOption]>,
+  HelpText<"Don't treat warnings as errors">;
+
 def continue_building_after_errors : Flag<["-"], "continue-building-after-errors">,
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
   HelpText<"Continue building, even after errors are encountered">;

lib/Basic/LangOptions.cpp

@@ -361,7 +361,7 @@ std::pair<bool, bool> LangOptions::setTarget(llvm::Triple triple) {
   // Set the "targetEnvironment" platform condition if targeting a simulator
   // environment. Otherwise _no_ value is present for targetEnvironment; it's
   // an optional disambiguating refinement of the triple.
-  if (Target.isSimulatorEnvironment())
+  if (swift::tripleIsAnySimulator(Target))
     addPlatformConditionValue(PlatformConditionKind::TargetEnvironment,
                               "simulator");
 

lib/Basic/Platform.cpp

@@ -19,39 +19,47 @@
 using namespace swift;
 
 bool swift::tripleIsiOSSimulator(const llvm::Triple &triple) {
+  llvm::Triple::ArchType arch = triple.getArch();
   return (triple.isiOS() &&
           !tripleIsMacCatalystEnvironment(triple) &&
-          triple.isSimulatorEnvironment());
+          // FIXME: transitional, this should eventually stop testing arch, and
+          // switch to only checking the -environment field.
+          (triple.isSimulatorEnvironment() ||
+           arch == llvm::Triple::x86 || arch == llvm::Triple::x86_64));
 }
 
 bool swift::tripleIsAppleTVSimulator(const llvm::Triple &triple) {
-  return (triple.isTvOS() && triple.isSimulatorEnvironment());
+  llvm::Triple::ArchType arch = triple.getArch();
+  return (triple.isTvOS() &&
+          // FIXME: transitional, this should eventually stop testing arch, and
+          // switch to only checking the -environment field.
+          (triple.isSimulatorEnvironment() ||
+           arch == llvm::Triple::x86 || arch == llvm::Triple::x86_64));
 }
 
 bool swift::tripleIsWatchSimulator(const llvm::Triple &triple) {
-  return (triple.isWatchOS() && triple.isSimulatorEnvironment());
+  llvm::Triple::ArchType arch = triple.getArch();
+  return (triple.isWatchOS() &&
+          // FIXME: transitional, this should eventually stop testing arch, and
+          // switch to only checking the -environment field.
+          (triple.isSimulatorEnvironment() ||
+           arch == llvm::Triple::x86 || arch == llvm::Triple::x86_64));
+}
+
+bool swift::tripleIsAnySimulator(const llvm::Triple &triple) {
+  // FIXME: transitional, this should eventually just use the -environment
+  // field.
+  return triple.isSimulatorEnvironment() ||
+    tripleIsiOSSimulator(triple) ||
+    tripleIsWatchSimulator(triple) ||
+    tripleIsAppleTVSimulator(triple);
 }
 
 bool swift::tripleIsMacCatalystEnvironment(const llvm::Triple &triple) {
   return triple.isiOS() && !triple.isTvOS() &&
       triple.getEnvironment() == llvm::Triple::MacABI;
 }
 
-bool swift::tripleInfersSimulatorEnvironment(const llvm::Triple &triple) {
-  switch (triple.getOS()) {
-  case llvm::Triple::IOS:
-  case llvm::Triple::TvOS:
-  case llvm::Triple::WatchOS:
-    return !triple.hasEnvironment() &&
-        (triple.getArch() == llvm::Triple::x86 ||
-         triple.getArch() == llvm::Triple::x86_64) &&
-        !tripleIsMacCatalystEnvironment(triple);
-
-  default:
-    return false;
-  }
-}
-
 bool swift::triplesAreValidForZippering(const llvm::Triple &target,
                                         const llvm::Triple &targetVariant) {
   // The arch and vendor must match.
@@ -319,6 +327,14 @@ getOSForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
 static Optional<StringRef>
 getEnvironmentForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
   auto tripleEnvironment = triple.getEnvironmentName();
+
+  // If the environment is empty, infer a "simulator" environment based on the
+  // OS and architecture combination. This feature is deprecated and exists for
+  // backwards compatibility only; build systems should pass the "simulator"
+  // environment explicitly if they know they're building for a simulator.
+  if (tripleEnvironment == "" && swift::tripleIsAnySimulator(triple))
+    return StringRef("simulator");
+
   return llvm::StringSwitch<Optional<StringRef>>(tripleEnvironment)
               .Cases("unknown", "", None)
   // These values are also supported, but are handled by the default case below:

lib/Driver/DarwinToolChains.cpp

@@ -479,7 +479,7 @@ toolchains::Darwin::addProfileGenerationArgs(ArgStringList &Arguments,
     }
 
     StringRef Sim;
-    if (Triple.isSimulatorEnvironment()) {
+    if (tripleIsAnySimulator(Triple)) {
       Sim = "sim";
     }
 

lib/Driver/Driver.cpp

@@ -140,7 +140,8 @@ static void validateBridgingHeaderArgs(DiagnosticEngine &diags,
 static void validateWarningControlArgs(DiagnosticEngine &diags,
                                        const ArgList &args) {
   if (args.hasArg(options::OPT_suppress_warnings) &&
-      args.hasArg(options::OPT_warnings_as_errors)) {
+      args.hasFlag(options::OPT_warnings_as_errors,
+                   options::OPT_no_warnings_as_errors, false)) {
     diags.diagnose(SourceLoc(), diag::error_conflicting_options,
                    "-warnings-as-errors", "-suppress-warnings");
   }
@@ -264,31 +265,17 @@ static void validateArgs(DiagnosticEngine &diags, const ArgList &args,
 std::unique_ptr<ToolChain>
 Driver::buildToolChain(const llvm::opt::InputArgList &ArgList) {
 
-  if (const Arg *A = ArgList.getLastArg(options::OPT_target)) {
+  if (const Arg *A = ArgList.getLastArg(options::OPT_target))
     DefaultTargetTriple = llvm::Triple::normalize(A->getValue());
-  }
-
-  llvm::Triple target(DefaultTargetTriple);
 
-  // Backward compatibility hack: infer "simulator" environment for x86
-  // iOS/tvOS/watchOS.
-  if (tripleInfersSimulatorEnvironment(target)) {
-    // Set the simulator environment.
-    target.setEnvironment(llvm::Triple::EnvironmentType::Simulator);
-
-    auto newTargetTriple = target.normalize();
-    Diags.diagnose(SourceLoc(), diag::warning_inferred_simulator_target,
-                   DefaultTargetTriple, newTargetTriple);
-
-    DefaultTargetTriple = newTargetTriple;
-  }
+  const llvm::Triple target(DefaultTargetTriple);
 
   switch (target.getOS()) {
+  case llvm::Triple::Darwin:
+  case llvm::Triple::MacOSX:
   case llvm::Triple::IOS:
   case llvm::Triple::TvOS:
-  case llvm::Triple::WatchOS:
-  case llvm::Triple::Darwin:
-  case llvm::Triple::MacOSX: {
+  case llvm::Triple::WatchOS: {
     Optional<llvm::Triple> targetVariant;
     if (const Arg *A = ArgList.getLastArg(options::OPT_target_variant))
       targetVariant = llvm::Triple(llvm::Triple::normalize(A->getValue()));

lib/Driver/ToolChains.cpp

@@ -216,7 +216,8 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
   inputArgs.AddLastArg(arguments, options::OPT_profile_generate);
   inputArgs.AddLastArg(arguments, options::OPT_profile_use);
   inputArgs.AddLastArg(arguments, options::OPT_profile_coverage_mapping);
-  inputArgs.AddLastArg(arguments, options::OPT_warnings_as_errors);
+  inputArgs.AddAllArgs(arguments, options::OPT_warnings_as_errors,
+                       options::OPT_no_warnings_as_errors);
   inputArgs.AddLastArg(arguments, options::OPT_sanitize_EQ);
   inputArgs.AddLastArg(arguments, options::OPT_sanitize_recover_EQ);
   inputArgs.AddLastArg(arguments, options::OPT_sanitize_coverage_EQ);

lib/Frontend/CompilerInvocation.cpp

@@ -553,22 +553,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   llvm::Triple Target = Opts.Target;
   StringRef TargetArg;
-  std::string TargetArgScratch;
-
   if (const Arg *A = Args.getLastArg(OPT_target)) {
     Target = llvm::Triple(A->getValue());
     TargetArg = A->getValue();
-
-    // Backward compatibility hack: infer "simulator" environment for x86
-    // iOS/tvOS/watchOS. The driver takes care of this for the frontend
-    // most of the time, but loading of old .swiftinterface files goes
-    // directly to the frontend.
-    if (tripleInfersSimulatorEnvironment(Target)) {
-      // Set the simulator environment.
-      Target.setEnvironment(llvm::Triple::EnvironmentType::Simulator);
-      TargetArgScratch = Target.str();
-      TargetArg = TargetArgScratch;
-    }
   }
 
   if (const Arg *A = Args.getLastArg(OPT_target_variant)) {
@@ -773,7 +760,8 @@ static bool ParseClangImporterArgs(ClangImporterOptions &Opts,
     Opts.PCHDisableValidation |= Args.hasArg(OPT_pch_disable_validation);
   }
 
-  if (Args.hasArg(OPT_warnings_as_errors))
+  if (Args.hasFlag(options::OPT_warnings_as_errors,
+                   options::OPT_no_warnings_as_errors, false))
     Opts.ExtraArgs.push_back("-Werror");
 
   Opts.DebuggerSupport |= Args.hasArg(OPT_debugger_support);
@@ -858,7 +846,9 @@ static bool ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
                    /*Default=*/llvm::sys::Process::StandardErrHasColors());
   Opts.FixitCodeForAllDiagnostics |= Args.hasArg(OPT_fixit_all);
   Opts.SuppressWarnings |= Args.hasArg(OPT_suppress_warnings);
-  Opts.WarningsAsErrors |= Args.hasArg(OPT_warnings_as_errors);
+  Opts.WarningsAsErrors = Args.hasFlag(options::OPT_warnings_as_errors,
+                                       options::OPT_no_warnings_as_errors,
+                                       false);
   Opts.PrintDiagnosticNames |= Args.hasArg(OPT_debug_diagnostic_names);
   Opts.PrintEducationalNotes |= Args.hasArg(OPT_print_educational_notes);
   Opts.EnableExperimentalFormatting |=
@@ -1714,3 +1704,30 @@ CompilerInvocation::setUpInputForSILTool(
   }
   return fileBufOrErr;
 }
+
+bool CompilerInvocation::isModuleExternallyConsumed(
+    const ModuleDecl *mod) const {
+  // Modules for executables aren't expected to be consumed by other modules.
+  // This picks up all kinds of entrypoints, including script mode,
+  // @UIApplicationMain and @NSApplicationMain.
+  if (mod->hasEntryPoint()) {
+    return false;
+  }
+
+  // If an implicit Objective-C header was needed to construct this module, it
+  // must be the product of a library target.
+  if (!getFrontendOptions().ImplicitObjCHeaderPath.empty()) {
+    return false;
+  }
+
+  // App extensions are special beasts because they build without entrypoints
+  // like library targets, but they behave like executable targets because
+  // their associated modules are not suitable for distribution.
+  if (mod->getASTContext().LangOpts.EnableAppExtensionRestrictions) {
+    return false;
+  }
+
+  // FIXME: This is still a lousy approximation of whether the module file will
+  // be externally consumed.
+  return true;
+}

lib/Frontend/Frontend.cpp

@@ -152,7 +152,7 @@ CompilerInvocation::getPrivateModuleInterfaceOutputPathForWholeModule() const {
 }
 
 SerializationOptions CompilerInvocation::computeSerializationOptions(
-    const SupplementaryOutputPaths &outs, bool moduleIsPublic) const {
+    const SupplementaryOutputPaths &outs, const ModuleDecl *module) const {
   const FrontendOptions &opts = getFrontendOptions();
 
   SerializationOptions serializationOpts;
@@ -171,7 +171,8 @@ SerializationOptions CompilerInvocation::computeSerializationOptions(
   // so only serialize them if the module isn't going to be shipped to
   // the public.
   serializationOpts.SerializeOptionsForDebugging =
-      opts.SerializeOptionsForDebugging.getValueOr(!moduleIsPublic);
+      opts.SerializeOptionsForDebugging.getValueOr(
+          !isModuleExternallyConsumed(module));
 
   return serializationOpts;
 }