[ModuleInterface] Factor out common AST-layer withOutputFile helper.

Author: graydon

include/swift/AST/FileSystem.h

@@ -0,0 +1,44 @@
+//===--- FileSystem.h - File helpers that interact with Diags ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_FILESYSTEM_H
+#define SWIFT_AST_FILESYSTEM_H
+
+#include "swift/Basic/FileSystem.h"
+#include "swift/AST/DiagnosticEngine.h"
+
+namespace swift {
+
+/// A wrapper around swift::atomicallyWritingToFile that handles diagnosing any
+/// filesystem errors and asserts the output path is nonempty.
+///
+/// \returns true if there were any errors, either from the filesystem
+/// operations or from \p action returning true.
+inline bool
+withOutputFile(DiagnosticEngine &diags, StringRef outputPath,
+               llvm::function_ref<bool(llvm::raw_pwrite_stream &)> action) {
+  assert(!outputPath.empty());
+
+  bool actionFailed = false;
+  std::error_code EC = swift::atomicallyWritingToFile(
+      outputPath,
+      [&](llvm::raw_pwrite_stream &out) { actionFailed = action(out); });
+  if (EC) {
+    diags.diagnose(SourceLoc(), diag::error_opening_output, outputPath,
+                   EC.message());
+    return true;
+  }
+  return actionFailed;
+}
+} // end namespace swift
+
+#endif // SWIFT_AST_FILESYSTEM_H

lib/FrontendTool/FrontendTool.cpp

@@ -29,6 +29,7 @@
 #include "swift/AST/ASTScope.h"
 #include "swift/AST/DiagnosticsFrontend.h"
 #include "swift/AST/DiagnosticsSema.h"
+#include "swift/AST/FileSystem.h"
 #include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/ASTMangler.h"
@@ -312,30 +313,6 @@ static bool writeSIL(SILModule &SM, const PrimarySpecificPaths &PSPs,
                   PSPs.OutputFilename, opts.EmitSortedSIL);
 }
 
-/// A wrapper around swift::atomicallyWritingToFile that handles diagnosing any
-/// filesystem errors and ignores empty output paths.
-///
-/// \returns true if there were any errors, either from the filesystem
-/// operations or from \p action returning true.
-static bool atomicallyWritingToTextFile(
-    StringRef outputPath, DiagnosticEngine &diags,
-    llvm::function_ref<bool(llvm::raw_pwrite_stream &)> action) {
-  assert(!outputPath.empty());
-
-  bool actionFailed = false;
-  std::error_code EC =
-      swift::atomicallyWritingToFile(outputPath,
-                                     [&](llvm::raw_pwrite_stream &out) {
-    actionFailed = action(out);
-  });
-  if (EC) {
-    diags.diagnose(SourceLoc(), diag::error_opening_output,
-                   outputPath, EC.message());
-    return true;
-  }
-  return actionFailed;
-}
-
 /// Prints the Objective-C "generated header" interface for \p M to \p
 /// outputPath.
 ///
@@ -348,8 +325,8 @@ static bool printAsObjCIfNeeded(StringRef outputPath, ModuleDecl *M,
                                 StringRef bridgingHeader, bool moduleIsPublic) {
   if (outputPath.empty())
     return false;
-  return atomicallyWritingToTextFile(outputPath, M->getDiags(),
-                                     [&](raw_ostream &out) -> bool {
+  return withOutputFile(M->getDiags(), outputPath,
+                        [&](raw_ostream &out) -> bool {
     auto requiredAccess = moduleIsPublic ? AccessLevel::Public
                                          : AccessLevel::Internal;
     return printAsObjC(out, M, bridgingHeader, requiredAccess);
@@ -368,8 +345,8 @@ static bool printParseableInterfaceIfNeeded(StringRef outputPath,
                                             ModuleDecl *M) {
   if (outputPath.empty())
     return false;
-  return atomicallyWritingToTextFile(outputPath, M->getDiags(),
-                                     [M, Opts](raw_ostream &out) -> bool {
+  return withOutputFile(M->getDiags(), outputPath,
+                        [M, Opts](raw_ostream &out) -> bool {
     return swift::emitParseableInterface(out, Opts, M);
   });
 }

lib/FrontendTool/ReferenceDependencies.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsFrontend.h"
 #include "swift/AST/ExistentialLayout.h"
+#include "swift/AST/FileSystem.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ModuleLoader.h"
 #include "swift/AST/NameLookup.h"
@@ -193,17 +194,10 @@ bool ReferenceDependenciesEmitter::emit(DiagnosticEngine &diags,
   // that may have been there. No error handling -- this is just a nicety, it
   // doesn't matter if it fails.
   llvm::sys::fs::rename(outputPath, outputPath + "~");
-  std::error_code EC =
-      swift::atomicallyWritingToFile(outputPath,
-                                     [&](llvm::raw_pwrite_stream &out) {
+  return withOutputFile(diags, outputPath, [&](llvm::raw_pwrite_stream &out) {
     ReferenceDependenciesEmitter::emit(SF, depTracker, out);
+    return false;
   });
-  if (EC) {
-    diags.diagnose(SourceLoc(), diag::error_opening_output, outputPath,
-                   EC.message());
-    return true;
-  }
-  return false;
 }
 
 void ReferenceDependenciesEmitter::emit(SourceFile *SF,

lib/Serialization/Serialization.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/DiagnosticsCommon.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/FileSystem.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
@@ -5158,19 +5159,6 @@ void Serializer::writeDocToStream(raw_ostream &os, ModuleOrSourceFile DC,
   S.writeToStream(os);
 }
 
-static inline bool
-withOutputFile(ASTContext &ctx, StringRef outputPath,
-               llvm::function_ref<void(raw_ostream &)> action){
-  std::error_code EC = swift::atomicallyWritingToFile(outputPath,
-                                                      action);
-  if (!EC)
-    return false;
-
-  ctx.Diags.diagnose(SourceLoc(), diag::error_opening_output,
-                     outputPath, EC.message());
-  return true;
-}
-
 void swift::serialize(ModuleOrSourceFile DC,
                       const SerializationOptions &options,
                       const SILModule *M) {
@@ -5183,20 +5171,24 @@ void swift::serialize(ModuleOrSourceFile DC,
     return;
   }
 
-  bool hadError = withOutputFile(getContext(DC), options.OutputPath,
+  bool hadError = withOutputFile(getContext(DC).Diags,
+                                 options.OutputPath,
                                  [&](raw_ostream &out) {
     SharedTimer timer("Serialization, swiftmodule");
     Serializer::writeToStream(out, DC, M, options);
+    return false;
   });
   if (hadError)
     return;
 
   if (options.DocOutputPath && options.DocOutputPath[0] != '\0') {
-    (void)withOutputFile(getContext(DC), options.DocOutputPath,
+    (void)withOutputFile(getContext(DC).Diags,
+                         options.DocOutputPath,
                          [&](raw_ostream &out) {
       SharedTimer timer("Serialization, swiftdoc");
       Serializer::writeDocToStream(out, DC, options.GroupInfoPath,
                                    getContext(DC));
+      return false;
     });
   }
 }