Teach the frontend how to parse TypeCheckerOptions

Author: CodaFi

include/swift/Frontend/Frontend.h

@@ -83,6 +83,7 @@ struct ModuleBuffers {
 /// which manages the actual compiler execution.
 class CompilerInvocation {
   LangOptions LangOpts;
+  TypeCheckerOptions TypeCheckerOpts;
   FrontendOptions FrontendOpts;
   ClangImporterOptions ClangImporterOpts;
   SearchPathOptions SearchPathOpts;
@@ -215,6 +216,11 @@ class CompilerInvocation {
     return LangOpts;
   }
 
+  TypeCheckerOptions &getTypeCheckerOptions() { return TypeCheckerOpts; }
+  const TypeCheckerOptions &getTypeCheckerOptions() const {
+    return TypeCheckerOpts;
+  }
+
   FrontendOptions &getFrontendOptions() { return FrontendOpts; }
   const FrontendOptions &getFrontendOptions() const { return FrontendOpts; }
 
@@ -648,14 +654,11 @@ class CompilerInstance {
   bool
   parsePartialModulesAndLibraryFiles(const ImplicitImports &implicitImports);
 
-  OptionSet<TypeCheckingFlags> computeTypeCheckingOptions();
-
   void forEachFileToTypeCheck(llvm::function_ref<void(SourceFile &)> fn);
 
-  void parseAndTypeCheckMainFileUpTo(SourceFile::ASTStage_t LimitStage,
-                                     OptionSet<TypeCheckingFlags> TypeCheckOptions);
+  void parseAndTypeCheckMainFileUpTo(SourceFile::ASTStage_t LimitStage);
 
-  void finishTypeChecking(OptionSet<TypeCheckingFlags> TypeCheckOptions);
+  void finishTypeChecking();
 
 public:
   const PrimarySpecificPaths &

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -90,15 +90,6 @@ bool ArgsToFrontendOptionsConverter::convert(
   computeDebugTimeOptions();
   computeTBDOptions();
 
-  setUnsignedIntegerArgument(OPT_warn_long_function_bodies, 10,
-                             Opts.WarnLongFunctionBodies);
-  setUnsignedIntegerArgument(OPT_warn_long_expression_type_checking, 10,
-                             Opts.WarnLongExpressionTypeChecking);
-  setUnsignedIntegerArgument(OPT_solver_expression_time_threshold_EQ, 10,
-                             Opts.SolverExpressionTimeThreshold);
-  setUnsignedIntegerArgument(OPT_switch_checking_invocation_threshold_EQ, 10,
-                             Opts.SwitchCheckingInvocationThreshold);
-
   Opts.CheckOnoneSupportCompleteness = Args.hasArg(OPT_check_onone_completeness);
 
   Opts.DebuggerTestingTransform = Args.hasArg(OPT_debugger_testing_transform);
@@ -163,7 +154,7 @@ bool ArgsToFrontendOptionsConverter::convert(
     return true;
 
   if (FrontendOptions::doesActionGenerateIR(Opts.RequestedAction)
-      && Opts.SkipNonInlinableFunctionBodies) {
+      && Args.hasArg(OPT_experimental_skip_non_inlinable_function_bodies)) {
     Diags.diagnose(SourceLoc(), diag::cannot_emit_ir_skipping_function_bodies);
     return true;
   }
@@ -222,17 +213,7 @@ void ArgsToFrontendOptionsConverter::computePrintStatsOptions() {
 
 void ArgsToFrontendOptionsConverter::computeDebugTimeOptions() {
   using namespace options;
-  Opts.DebugTimeFunctionBodies |= Args.hasArg(OPT_debug_time_function_bodies);
-  Opts.DebugTimeExpressionTypeChecking |=
-      Args.hasArg(OPT_debug_time_expression_type_checking);
   Opts.DebugTimeCompilation |= Args.hasArg(OPT_debug_time_compilation);
-  Opts.SkipNonInlinableFunctionBodies |=
-      Args.hasArg(OPT_experimental_skip_non_inlinable_function_bodies);
-
-  // If asked to perform InstallAPI, go ahead and enable non-inlinable function
-  // body skipping.
-  Opts.SkipNonInlinableFunctionBodies |=
-      Args.hasArg(OPT_tbd_is_installapi);
 
   if (const Arg *A = Args.getLastArg(OPT_stats_output_dir)) {
     Opts.StatsOutputDir = A->getValue();
@@ -266,19 +247,6 @@ void ArgsToFrontendOptionsConverter::computeTBDOptions() {
   }
 }
 
-void ArgsToFrontendOptionsConverter::setUnsignedIntegerArgument(
-    options::ID optionID, unsigned radix, unsigned &valueToSet) {
-  if (const Arg *A = Args.getLastArg(optionID)) {
-    unsigned attempt;
-    if (StringRef(A->getValue()).getAsInteger(radix, attempt)) {
-      Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
-                     A->getAsString(Args), A->getValue());
-    } else {
-      valueToSet = attempt;
-    }
-  }
-}
-
 void ArgsToFrontendOptionsConverter::computePlaygroundOptions() {
   using namespace options;
   Opts.PlaygroundTransform |= Args.hasArg(OPT_playground);

lib/Frontend/ArgsToFrontendOptionsConverter.h

@@ -47,9 +47,6 @@ class ArgsToFrontendOptionsConverter {
   void computePrintStatsOptions();
   void computeTBDOptions();
 
-  void setUnsignedIntegerArgument(options::ID optionID, unsigned radix,
-                                  unsigned &valueToSet);
-
   bool setUpInputKindAndImmediateArgs();
 
   bool checkUnusedSupplementaryOutputPaths() const;

lib/Frontend/CompilerInvocation.cpp

@@ -552,6 +552,46 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   return HadError || UnsupportedOS || UnsupportedArch;
 }
 
+static bool ParseTypeCheckerArgs(TypeCheckerOptions &Opts, ArgList &Args,
+                                 DiagnosticEngine &Diags,
+                                 const FrontendOptions &FrontendOpts) {
+  using namespace options;
+
+  auto setUnsignedIntegerArgument = [&Args, &Diags](
+      options::ID optionID, unsigned radix, unsigned &valueToSet) {
+    if (const Arg *A = Args.getLastArg(optionID)) {
+      unsigned attempt;
+      if (StringRef(A->getValue()).getAsInteger(radix, attempt)) {
+        Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
+                       A->getAsString(Args), A->getValue());
+      } else {
+        valueToSet = attempt;
+      }
+    }
+  };
+
+  setUnsignedIntegerArgument(OPT_warn_long_function_bodies, 10,
+                             Opts.WarnLongFunctionBodies);
+  setUnsignedIntegerArgument(OPT_warn_long_expression_type_checking, 10,
+                             Opts.WarnLongExpressionTypeChecking);
+  setUnsignedIntegerArgument(OPT_solver_expression_time_threshold_EQ, 10,
+                             Opts.ExpressionTimeoutThreshold);
+  setUnsignedIntegerArgument(OPT_switch_checking_invocation_threshold_EQ, 10,
+                             Opts.SwitchCheckingInvocationThreshold);
+
+  Opts.DebugTimeFunctionBodies |= Args.hasArg(OPT_debug_time_function_bodies);
+  Opts.DebugTimeExpressions |=
+      Args.hasArg(OPT_debug_time_expression_type_checking);
+  Opts.SkipNonInlinableFunctionBodies |=
+      Args.hasArg(OPT_experimental_skip_non_inlinable_function_bodies);
+
+  // If asked to perform InstallAPI, go ahead and enable non-inlinable function
+  // body skipping.
+  Opts.SkipNonInlinableFunctionBodies |= Args.hasArg(OPT_tbd_is_installapi);
+
+  return false;
+}
+
 static bool ParseClangImporterArgs(ClangImporterOptions &Opts,
                                    ArgList &Args,
                                    DiagnosticEngine &Diags,
@@ -1384,6 +1424,10 @@ bool CompilerInvocation::parseArgs(
     return true;
   }
 
+  if (ParseTypeCheckerArgs(TypeCheckerOpts, ParsedArgs, Diags, FrontendOpts)) {
+    return true;
+  }
+
   if (ParseClangImporterArgs(ClangImporterOpts, ParsedArgs, Diags,
                              workingDirectory)) {
     return true;