Merge pull request #1105 from swiftwasm/master

[pull] swiftwasm from master

Author: pull[bot]

include/swift/AST/SILGenRequests.h

@@ -40,38 +40,39 @@ template<typename Request>
 void reportEvaluatedRequest(UnifiedStatsReporter &stats,
                             const Request &request);
 
-struct SILGenDescriptor {
+/// Describes a file or module to be lowered to SIL.
+struct ASTLoweringDescriptor {
   llvm::PointerUnion<FileUnit *, ModuleDecl *> context;
   Lowering::TypeConverter &conv;
   const SILOptions &opts;
 
-  friend llvm::hash_code hash_value(const SILGenDescriptor &owner) {
+  friend llvm::hash_code hash_value(const ASTLoweringDescriptor &owner) {
     return llvm::hash_combine(owner.context, (void *)&owner.conv,
                               (void *)&owner.opts);
   }
 
-  friend bool operator==(const SILGenDescriptor &lhs,
-                         const SILGenDescriptor &rhs) {
+  friend bool operator==(const ASTLoweringDescriptor &lhs,
+                         const ASTLoweringDescriptor &rhs) {
     return lhs.context == rhs.context &&
            &lhs.conv == &rhs.conv &&
            &lhs.opts == &rhs.opts;
   }
 
-  friend bool operator!=(const SILGenDescriptor &lhs,
-                         const SILGenDescriptor &rhs) {
+  friend bool operator!=(const ASTLoweringDescriptor &lhs,
+                         const ASTLoweringDescriptor &rhs) {
     return !(lhs == rhs);
   }
 
 public:
-  static SILGenDescriptor forFile(FileUnit &sf, Lowering::TypeConverter &conv,
-                                  const SILOptions &opts) {
-    return SILGenDescriptor{&sf, conv, opts};
+  static ASTLoweringDescriptor
+  forFile(FileUnit &sf, Lowering::TypeConverter &conv, const SILOptions &opts) {
+    return ASTLoweringDescriptor{&sf, conv, opts};
   }
 
-  static SILGenDescriptor forWholeModule(ModuleDecl *mod,
-                                         Lowering::TypeConverter &conv,
-                                         const SILOptions &opts) {
-    return SILGenDescriptor{mod, conv, opts};
+  static ASTLoweringDescriptor forWholeModule(ModuleDecl *mod,
+                                              Lowering::TypeConverter &conv,
+                                              const SILOptions &opts) {
+    return ASTLoweringDescriptor{mod, conv, opts};
   }
 
   /// For a single file input, returns a single element array containing that
@@ -83,13 +84,17 @@ struct SILGenDescriptor {
   SourceFile *getSourceFileToParse() const;
 };
 
-void simple_display(llvm::raw_ostream &out, const SILGenDescriptor &d);
+void simple_display(llvm::raw_ostream &out, const ASTLoweringDescriptor &d);
 
-SourceLoc extractNearestSourceLoc(const SILGenDescriptor &desc);
+SourceLoc extractNearestSourceLoc(const ASTLoweringDescriptor &desc);
 
-class SILGenerationRequest
+/// Lowers a file or module to SIL. In most cases this involves transforming
+/// a file's AST into SIL, through SILGen. However it can also handle files
+/// containing SIL in textual or binary form, which will be parsed or
+/// deserialized as needed.
+class ASTLoweringRequest
     : public SimpleRequest<
-          SILGenerationRequest, std::unique_ptr<SILModule>(SILGenDescriptor),
+          ASTLoweringRequest, std::unique_ptr<SILModule>(ASTLoweringDescriptor),
           RequestFlags::Uncached | RequestFlags::DependencySource> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -98,8 +103,8 @@ class SILGenerationRequest
   friend SimpleRequest;
 
   // Evaluation.
-  std::unique_ptr<SILModule>
-  evaluate(Evaluator &evaluator, SILGenDescriptor desc) const;
+  std::unique_ptr<SILModule> evaluate(Evaluator &evaluator,
+                                      ASTLoweringDescriptor desc) const;
 
 public:
   // Incremental dependencies.
@@ -110,7 +115,7 @@ class SILGenerationRequest
 /// Parses a .sil file into a SILModule.
 class ParseSILModuleRequest
     : public SimpleRequest<ParseSILModuleRequest,
-                           std::unique_ptr<SILModule>(SILGenDescriptor),
+                           std::unique_ptr<SILModule>(ASTLoweringDescriptor),
                            RequestFlags::Uncached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -119,8 +124,8 @@ class ParseSILModuleRequest
   friend SimpleRequest;
 
   // Evaluation.
-  std::unique_ptr<SILModule>
-  evaluate(Evaluator &evaluator, SILGenDescriptor desc) const;
+  std::unique_ptr<SILModule> evaluate(Evaluator &evaluator,
+                                      ASTLoweringDescriptor desc) const;
 };
 
 /// The zone number for SILGen.

include/swift/AST/SILGenTypeIDZone.def

@@ -14,9 +14,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-SWIFT_REQUEST(SILGen, SILGenerationRequest,
-              std::unique_ptr<SILModule>(SILGenDescriptor),
+SWIFT_REQUEST(SILGen, ASTLoweringRequest,
+              std::unique_ptr<SILModule>(ASTLoweringDescriptor),
               Uncached, NoLocationInfo)
 SWIFT_REQUEST(SILGen, ParseSILModuleRequest,
-              std::unique_ptr<SILModule>(SILGenDescriptor),
+              std::unique_ptr<SILModule>(ASTLoweringDescriptor),
               Uncached, NoLocationInfo)

include/swift/Basic/DiagnosticOptions.h

@@ -32,6 +32,8 @@ class DiagnosticOptions {
     VerifyAndApplyFixes
   } VerifyMode = NoVerify;
 
+  enum FormattingStyle { LLVM, Swift };
+
   /// Indicates whether to allow diagnostics for \c <unknown> locations if
   /// \c VerifyMode is not \c NoVerify.
   bool VerifyIgnoreUnknown = false;
@@ -61,7 +63,7 @@ class DiagnosticOptions {
 
   // If set to true, use the more descriptive experimental formatting style for
   // diagnostics.
-  bool EnableExperimentalFormatting = false;
+  FormattingStyle PrintedFormattingStyle = FormattingStyle::LLVM;
 
   std::string DiagnosticDocumentationPath = "";
 

include/swift/Frontend/PrintingDiagnosticConsumer.h

@@ -18,8 +18,9 @@
 #ifndef SWIFT_PRINTINGDIAGNOSTICCONSUMER_H
 #define SWIFT_PRINTINGDIAGNOSTICCONSUMER_H
 
-#include "swift/Basic/LLVM.h"
 #include "swift/AST/DiagnosticConsumer.h"
+#include "swift/Basic/DiagnosticOptions.h"
+#include "swift/Basic/LLVM.h"
 
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/Process.h"
@@ -33,7 +34,8 @@ class PrintingDiagnosticConsumer : public DiagnosticConsumer {
   bool ForceColors = false;
   bool PrintEducationalNotes = false;
   bool DidErrorOccur = false;
-  bool ExperimentalFormattingEnabled = false;
+  DiagnosticOptions::FormattingStyle FormattingStyle =
+      DiagnosticOptions::FormattingStyle::LLVM;
   // The current snippet used to display an error/warning/remark and the notes
   // implicitly associated with it. Uses `std::unique_ptr` so that
   // `AnnotatedSourceSnippet` can be forward declared.
@@ -65,7 +67,9 @@ class PrintingDiagnosticConsumer : public DiagnosticConsumer {
     PrintEducationalNotes = ShouldPrint;
   }
 
-  void enableExperimentalFormatting() { ExperimentalFormattingEnabled = true; }
+  void setFormattingStyle(DiagnosticOptions::FormattingStyle style) {
+    FormattingStyle = style;
+  }
 
   bool didErrorOccur() {
     return DidErrorOccur;

include/swift/Option/FrontendOptions.td

@@ -131,10 +131,6 @@ def enable_cross_import_overlays : Flag<["-"], "enable-cross-import-overlays">,
 def disable_cross_import_overlays : Flag<["-"], "disable-cross-import-overlays">,
   HelpText<"Do not automatically import declared cross-import overlays.">;
 
-def enable_experimental_diagnostic_formatting :
-  Flag<["-"], "enable-experimental-diagnostic-formatting">,
-  HelpText<"Enable experimental diagnostic formatting features.">;
-  
 def diagnostic_documentation_path
   : Separate<["-"], "diagnostic-documentation-path">, MetaVarName<"<path>">,
   HelpText<"Path to diagnostic documentation resources">;

include/swift/Option/Options.td

@@ -370,6 +370,13 @@ def debug_diagnostic_names : Flag<["-"], "debug-diagnostic-names">,
 def print_educational_notes : Flag<["-"], "print-educational-notes">,
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
   HelpText<"Include educational notes in printed diagnostic output, if available">;
+def diagnostic_style : Separate<["-"], "diagnostic-style">,
+  Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
+  MetaVarName<"<style>">,
+  HelpText<"The formatting style used when printing diagnostics ('swift' or 'llvm')">;
+def diagnostic_style_EQ : Joined<["-"], "diagnostic-style=">,
+  Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
+  MetaVarName<"<style>">, Alias<diagnostic_style>;
 
 def module_cache_path : Separate<["-"], "module-cache-path">,
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild, ArgumentIsPath]>,

include/swift/Subsystems.h

@@ -172,13 +172,13 @@ namespace swift {
   /// The module must contain source files. The optimizer will assume that the
   /// SIL of all files in the module is present in the SILModule.
   std::unique_ptr<SILModule>
-  performSILGeneration(ModuleDecl *M, Lowering::TypeConverter &TC,
-                       const SILOptions &options);
+  performASTLowering(ModuleDecl *M, Lowering::TypeConverter &TC,
+                     const SILOptions &options);
 
   /// Turn a source file into SIL IR.
   std::unique_ptr<SILModule>
-  performSILGeneration(FileUnit &SF, Lowering::TypeConverter &TC,
-                       const SILOptions &options);
+  performASTLowering(FileUnit &SF, Lowering::TypeConverter &TC,
+                     const SILOptions &options);
 
   using ModuleOrSourceFile = PointerUnion<ModuleDecl *, SourceFile *>;
 

lib/Driver/ToolChains.cpp

@@ -244,6 +244,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
   inputArgs.AddLastArg(arguments, options::OPT_serialize_diagnostics_path);
   inputArgs.AddLastArg(arguments, options::OPT_debug_diagnostic_names);
   inputArgs.AddLastArg(arguments, options::OPT_print_educational_notes);
+  inputArgs.AddLastArg(arguments, options::OPT_diagnostic_style);
   inputArgs.AddLastArg(arguments, options::OPT_enable_astscope_lookup);
   inputArgs.AddLastArg(arguments, options::OPT_disable_astscope_lookup);
   inputArgs.AddLastArg(arguments, options::OPT_disable_parser_lookup);

lib/Frontend/CompilerInvocation.cpp

@@ -874,19 +874,33 @@ static bool ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
   Opts.SkipDiagnosticPasses |= Args.hasArg(OPT_disable_diagnostic_passes);
   Opts.ShowDiagnosticsAfterFatalError |=
     Args.hasArg(OPT_show_diagnostics_after_fatal);
+
   Opts.UseColor |=
       Args.hasFlag(OPT_color_diagnostics,
                    OPT_no_color_diagnostics,
                    /*Default=*/llvm::sys::Process::StandardErrHasColors());
+  // If no style options are specified, default to LLVM style.
+  Opts.PrintedFormattingStyle = DiagnosticOptions::FormattingStyle::LLVM;
+  if (const Arg *arg = Args.getLastArg(OPT_diagnostic_style)) {
+    StringRef contents = arg->getValue();
+    if (contents == "llvm") {
+      Opts.PrintedFormattingStyle = DiagnosticOptions::FormattingStyle::LLVM;
+    } else if (contents == "swift") {
+      Opts.PrintedFormattingStyle = DiagnosticOptions::FormattingStyle::Swift;
+    } else {
+      Diags.diagnose(SourceLoc(), diag::error_unsupported_option_argument,
+                     arg->getOption().getPrefixedName(), arg->getValue());
+      return true;
+    }
+  }
+
   Opts.FixitCodeForAllDiagnostics |= Args.hasArg(OPT_fixit_all);
   Opts.SuppressWarnings |= Args.hasArg(OPT_suppress_warnings);
   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 |=
-      Args.hasArg(OPT_enable_experimental_diagnostic_formatting);
   if (Arg *A = Args.getLastArg(OPT_diagnostic_documentation_path)) {
     Opts.DiagnosticDocumentationPath = A->getValue();
   }

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -209,7 +209,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     SILOptions &SILOpts = subInvocation.getSILOptions();
     auto Mod = SubInstance.getMainModule();
     auto &TC = SubInstance.getSILTypes();
-    auto SILMod = performSILGeneration(Mod, TC, SILOpts);
+    auto SILMod = performASTLowering(Mod, TC, SILOpts);
     if (!SILMod) {
       LLVM_DEBUG(llvm::dbgs() << "SILGen did not produce a module\n");
       return true;