Rename "textual interface" to "parseable interface" (swiftlang#19713)

We already have something called "module interfaces" -- it's the
generated interface view that you can see in Xcode, the interface
that's meant for developers using a library. Of course, that's also a
textual format. To reduce confusion, rename the new module stability
feature to "parseable [module] interfaces".

Author: jrose-apple

include/swift/AST/DiagnosticsFrontend.def

@@ -121,7 +121,7 @@ ERROR(error_mode_cannot_emit_module,none,
 ERROR(error_mode_cannot_emit_module_doc,none,
       "this mode does not support emitting module documentation files", ())
 ERROR(error_mode_cannot_emit_interface,none,
-      "this mode does not support emitting textual interface files", ())
+      "this mode does not support emitting parseable interface files", ())
 
 WARNING(emit_reference_dependencies_without_primary_file,none,
   "ignoring -emit-reference-dependencies (requires -primary-file)", ())
@@ -260,8 +260,8 @@ ERROR(error_invalid_debug_prefix_map, none,
 ERROR(invalid_vfs_overlay_file,none,
       "invalid virtual overlay file '%0'", (StringRef))
 
-WARNING(textual_interface_scoped_import_unsupported,none,
-        "scoped imports are not yet supported in textual module interfaces",
+WARNING(parseable_interface_scoped_import_unsupported,none,
+        "scoped imports are not yet supported in parseable module interfaces",
         ())
 
 #ifndef DIAG_NO_UNDEF

include/swift/AST/PrintOptions.h

@@ -449,13 +449,13 @@ struct PrintOptions {
     return result;
   }
 
-  /// Retrieve the set of options suitable for stable textual interfaces.
+  /// Retrieve the set of options suitable for parseable module interfaces.
   ///
   /// This is a format that will be parsed again later, so the output must be
   /// consistent and well-formed.
   ///
-  /// \see swift::emitModuleInterface
-  static PrintOptions printTextualInterfaceFile();
+  /// \see swift::emitParseableInterface
+  static PrintOptions printParseableInterfaceFile();
 
   static PrintOptions printModuleInterface();
   static PrintOptions printTypeInterface(Type T);

include/swift/Basic/SupplementaryOutputPaths.h

@@ -113,16 +113,16 @@ struct SupplementaryOutputPaths {
   /// \sa swift::writeTBDFile
   std::string TBDPath;
 
-  /// The path to which we should emit a textual module interface, which can be
-  /// used by a client source file to import this module.
+  /// The path to which we should emit a parseable module interface, which can
+  /// be used by a client source file to import this module.
   ///
   /// This format is similar to the binary format used for #ModuleOutputPath,
   /// but is intended to be stable across compiler versions.
   ///
   /// Currently only makes sense when the compiler has whole-module knowledge.
   ///
-  /// \sa swift::emitModuleInterface
-  std::string ModuleInterfaceOutputPath;
+  /// \sa swift::emitParseableInterface
+  std::string ParseableInterfaceOutputPath;
 
   SupplementaryOutputPaths() = default;
   SupplementaryOutputPaths(const SupplementaryOutputPaths &) = default;
@@ -132,7 +132,7 @@ struct SupplementaryOutputPaths {
            ModuleDocOutputPath.empty() && DependenciesFilePath.empty() &&
            ReferenceDependenciesFilePath.empty() &&
            SerializedDiagnosticsPath.empty() && LoadedModuleTracePath.empty() &&
-           TBDPath.empty() && ModuleInterfaceOutputPath.empty();
+           TBDPath.empty() && ParseableInterfaceOutputPath.empty();
   }
 };
 } // namespace swift

include/swift/Driver/Driver.h

@@ -341,10 +341,10 @@ class Driver {
                                       StringRef workingDirectory,
                                       CommandOutput *Output) const;
 
-  void chooseTextualInterfacePath(Compilation &C, const JobAction *JA,
-                                  StringRef workingDirectory,
-                                  llvm::SmallString<128> &buffer,
-                                  CommandOutput *output) const;
+  void chooseParseableInterfacePath(Compilation &C, const JobAction *JA,
+                                    StringRef workingDirectory,
+                                    llvm::SmallString<128> &buffer,
+                                    CommandOutput *output) const;
 
   void chooseRemappingOutputPath(Compilation &C, const TypeToPathMap *OutputMap,
                                  CommandOutput *Output) const;

include/swift/Frontend/Frontend.h

@@ -338,10 +338,10 @@ class CompilerInvocation {
   /// if not in that mode.
   std::string getTBDPathForWholeModule() const;
 
-  /// ModuleInterfaceOutputPath only makes sense in whole module compilation
-  /// mode, so return the ModuleInterfaceOutputPath when in that mode and fail
-  /// an assert if not in that mode.
-  std::string getModuleInterfaceOutputPathForWholeModule() const;
+  /// ParseableInterfaceOutputPath only makes sense in whole module compilation
+  /// mode, so return the ParseableInterfaceOutputPath when in that mode and
+  /// fail an assert if not in that mode.
+  std::string getParseableInterfaceOutputPathForWholeModule() const;
 };
 
 /// A class which manages the state and execution of the compiler.

include/swift/Frontend/FrontendInputsAndOutputs.h

@@ -235,7 +235,7 @@ class FrontendInputsAndOutputs {
   bool hasLoadedModuleTracePath() const;
   bool hasModuleOutputPath() const;
   bool hasModuleDocOutputPath() const;
-  bool hasModuleInterfaceOutputPath() const;
+  bool hasParseableInterfaceOutputPath() const;
   bool hasTBDPath() const;
 
   bool hasDependencyTrackerPath() const;

include/swift/Option/FrontendOptions.td

@@ -65,7 +65,7 @@ def emit_fixits_path
 
 def emit_interface_path
   : Separate<["-"], "emit-interface-path">, MetaVarName<"<path>">,
-    HelpText<"Output textual interface file to <path>">;
+    HelpText<"Output parseable interface file to <path>">;
 
 def tbd_install_name
   : Separate<["-"], "tbd-install_name">, MetaVarName<"<path>">,

include/swift/Option/Options.td

@@ -302,7 +302,7 @@ def emit_module_path_EQ : Joined<["-"], "emit-module-path=">,
 
 def experimental_emit_interface : Flag<["-"], "experimental-emit-interface">,
   Flags<[NoInteractiveOption, HelpHidden]>,
-  HelpText<"Test out the textual interfaces feature">;
+  HelpText<"Test out the parseable interfaces feature">;
 
 def emit_objc_header : Flag<["-"], "emit-objc-header">,
   Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,

lib/AST/ASTPrinter.cpp

@@ -79,7 +79,7 @@ static bool contributesToParentTypeStorage(const AbstractStorageDecl *ASD) {
   return !ND->isResilient() && ASD->hasStorage() && !ASD->isStatic();
 }
 
-PrintOptions PrintOptions::printTextualInterfaceFile() {
+PrintOptions PrintOptions::printParseableInterfaceFile() {
   PrintOptions result;
   result.PrintLongAttrsOnSeparateLines = true;
   result.TypeDefinitions = true;
@@ -100,7 +100,7 @@ PrintOptions PrintOptions::printTextualInterfaceFile() {
     printer << " " << AFD->getInlinableBodyText(scratch);
   };
 
-  class ShouldPrintForTextualInterface : public ShouldPrintChecker {
+  class ShouldPrintForParseableInterface : public ShouldPrintChecker {
     bool shouldPrint(const Decl *D, const PrintOptions &options) override {
       // Skip anything that isn't 'public' or '@usableFromInline'.
       if (auto *VD = dyn_cast<ValueDecl>(D)) {
@@ -143,7 +143,7 @@ PrintOptions PrintOptions::printTextualInterfaceFile() {
     }
   };
   result.CurrentPrintabilityChecker =
-      std::make_shared<ShouldPrintForTextualInterface>();
+      std::make_shared<ShouldPrintForParseableInterface>();
 
   // FIXME: We don't really need 'public' on everything; we could just change
   // the default to 'public' and mark the 'internal' things.

lib/Driver/Driver.cpp

@@ -2474,7 +2474,7 @@ Job *Driver::buildJobsForAction(Compilation &C, const JobAction *JA,
                                    Output.get());
 
   if (C.getArgs().hasArg(options::OPT_experimental_emit_interface))
-    chooseTextualInterfacePath(C, JA, workingDirectory, Buf, Output.get());
+    chooseParseableInterfacePath(C, JA, workingDirectory, Buf, Output.get());
 
   if (C.getArgs().hasArg(options::OPT_update_code) && isa<CompileJobAction>(JA))
     chooseRemappingOutputPath(C, OutputMap, Output.get());
@@ -2772,7 +2772,7 @@ void Driver::chooseRemappingOutputPath(Compilation &C,
   }
 }
 
-void Driver::chooseTextualInterfacePath(Compilation &C, const JobAction *JA,
+void Driver::chooseParseableInterfacePath(Compilation &C, const JobAction *JA,
                                         StringRef workingDirectory,
                                         llvm::SmallString<128> &buffer,
                                         CommandOutput *output) const {