[Playgrounds] Restore the performPlaygroundTransform() variant that takes a high-perf flag

Temporarily restore the old variant of the `performPlaygroundTransform()` that takes a boolean to determine whether to only apply high-performance playground transforms. This function is still used by LLDB and possibly other clients, and should continue to work. It can be removed once all clients have switched over to the more generic variant that takes a `PlaygroundOptionSet`.

Also added a comment to the old function indicating that new code should use the more general form.

Author: abertelrud

include/swift/Subsystems.h

@@ -132,9 +132,24 @@ namespace swift {
   void performDebuggerTestingTransform(SourceFile &SF);
 
   /// Once type checking is complete, this optionally transforms the ASTs to
-  /// insert calls to external logging functions. The specific transforms that
-  /// are performed are controlled by `LangOptions.PlaygroundOptions`.
-  void performPlaygroundTransform(SourceFile &SF);
+  /// insert calls to external logging functions.
+  ///
+  /// \param Opts The specific set of transforms that should be applied.
+  void performPlaygroundTransform(SourceFile &SF, PlaygroundOptionSet Opts);
+
+  /// Once type checking is complete, this optionally transforms the ASTs to
+  /// insert calls to external logging functions. This function is provided
+  /// for backward compatibility with existing code; for new code, the variant
+  /// that takes an `PlaygroundOptionSet` parameter should be used.
+  ///
+  /// \param HighPerformance True if the playground transform should omit
+  /// instrumentation that has a high runtime performance impact.
+  ///
+  /// This function is provided for backward compatibility with older code, and
+  /// is a convenience for calling `performPlaygroundTransform()` with the set
+  /// of options that are enabled in high-performance mode. New uses should call
+  /// the newer form of this function that takes a `PlaygroundOptionSet`.
+  void performPlaygroundTransform(SourceFile &SF, bool HighPerformance);
 
   /// Once type checking is complete this optionally walks the ASTs to add calls
   /// to externally provided functions that simulate "program counter"-like

lib/Sema/PlaygroundTransform.cpp

@@ -904,7 +904,7 @@ class Instrumenter : InstrumenterBase {
 
 } // end anonymous namespace
 
-void swift::performPlaygroundTransform(SourceFile &SF) {
+void swift::performPlaygroundTransform(SourceFile &SF, PlaygroundOptionSet Opts) {
   class ExpressionFinder : public ASTWalker {
   private:
     ASTContext &ctx;
@@ -913,8 +913,8 @@ void swift::performPlaygroundTransform(SourceFile &SF) {
     unsigned TmpNameIndex = 0;
 
   public:
-    ExpressionFinder(ASTContext &ctx) :
-      ctx(ctx), Options(ctx.LangOpts.PlaygroundOptions) {}
+    ExpressionFinder(ASTContext &ctx, PlaygroundOptionSet Opts) :
+      ctx(ctx), Options(Opts) {}
 
     // FIXME: Remove this
     bool shouldWalkAccessorsTheOldWay() override { return true; }
@@ -954,6 +954,20 @@ void swift::performPlaygroundTransform(SourceFile &SF) {
     }
   };
 
-  ExpressionFinder EF(SF.getASTContext());
+  ExpressionFinder EF(SF.getASTContext(), Opts);
   SF.walk(EF);
 }
+
+/// This function is provided for backward compatibility with the old API, since
+/// LLDB and others call it directly, passing it a boolean to control whether to
+/// only apply "high performance" options. We emulate that here.
+void swift::performPlaygroundTransform(SourceFile &SF, bool HighPerformance) {
+  PlaygroundOptionSet HighPerfTransformOpts;
+  // Enable any playground options that are marked as being applicable to high
+  // performance mode.
+#define PLAYGROUND_OPTION(OptionName, Description, DefaultOn, HighPerfOn) \
+  if (HighPerfOn) \
+    HighPerfTransformOpts.insert(PlaygroundOption::OptionName);
+#include "swift/Basic/PlaygroundOptions.def"
+  swift::performPlaygroundTransform(SF, HighPerfTransformOpts);
+}

lib/Sema/TypeChecker.cpp

@@ -337,7 +337,7 @@ TypeCheckSourceFileRequest::evaluate(Evaluator &eval, SourceFile *SF) const {
   // Playground transform knows to look out for PCMacro's changes and not
   // to playground log them.
   if (!Ctx.hadError() && Ctx.LangOpts.PlaygroundTransform)
-    performPlaygroundTransform(*SF);
+    performPlaygroundTransform(*SF, Ctx.LangOpts.PlaygroundOptions);
 
   return std::make_tuple<>();
 }