Add a flag to dump the AST as JSON. (Second version)

include/swift/AST/Attr.h

@@ -1722,6 +1722,12 @@ class ImplementsAttr : public DeclAttribute {
                                 DeclName MemberName);
 
   ProtocolDecl *getProtocol(DeclContext *dc) const;
+
+  /// Returns the protocol declaration containing the requirement being
+  /// implemented by the attributed declaration if it has already been computed,
+  /// otherwise `nullopt`. This should only be used for dumping.
+  std::optional<ProtocolDecl *> getCachedProtocol(DeclContext *dc) const;
+
   TypeRepr *getProtocolTypeRepr() const { return TyR; }
 
   DeclName getMemberName() const { return MemberName; }

include/swift/AST/CatchNode.h

@@ -45,6 +45,11 @@ class CatchNode: public llvm::PointerUnion<
   /// needs to be inferred.
   Type getExplicitCaughtType(ASTContext &ctx) const;
 
+  /// Returns the explicitly-specified type error that will be caught by this
+  /// catch node, or `nullopt` if it has not yet been computed. This should only
+  /// be used for dumping.
+  std::optional<Type> getCachedExplicitCaughtType(ASTContext &ctx) const;
+
   friend llvm::hash_code hash_value(CatchNode catchNode) {
     using llvm::hash_value;
     return hash_value(catchNode.getOpaqueValue());

include/swift/AST/Decl.h

@@ -3326,6 +3326,10 @@ class ValueDecl : public Decl {
   /// Get the decl for this value's opaque result type, if it has one.
   OpaqueTypeDecl *getOpaqueResultTypeDecl() const;
 
+  /// Gets the decl for this value's opaque result type if it has already been
+  /// computed, or `nullopt` otherwise. This should only be used for dumping.
+  std::optional<OpaqueTypeDecl *> getCachedOpaqueResultTypeDecl() const;
+
   /// Get the representative for this value's opaque result type, if it has one.
   /// Returns a `TypeRepr` instead of an `OpaqueReturnTypeRepr` because 'some'
   /// types might appear in one or more structural positions, e.g.  (some P,
@@ -7769,6 +7773,10 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Retrieves the thrown interface type.
   Type getThrownInterfaceType() const;
 
+  /// Returns the thrown interface type of this function if it has already been
+  /// computed, otherwise `nullopt`. This should only be used for dumping.
+  std::optional<Type> getCachedThrownInterfaceType() const;
+
   /// Retrieve the "effective" thrown interface type, or std::nullopt if
   /// this function cannot throw.
   ///
@@ -8329,6 +8337,10 @@ class FuncDecl : public AbstractFunctionDecl {
   /// Retrieve the result interface type of this function.
   Type getResultInterfaceType() const;
 
+  /// Returns the result interface type of this function if it has already been
+  /// computed, otherwise `nullopt`. This should only be used for dumping.
+  std::optional<Type> getCachedResultInterfaceType() const;
+
   /// isUnaryOperator - Determine whether this is a unary operator
   /// implementation.  This check is a syntactic rather than type-based check,
   /// which looks at the number of parameters specified, in order to allow
@@ -9529,6 +9541,10 @@ class MacroDecl : public GenericContext, public ValueDecl {
   /// Retrieve the interface type produced when expanding this macro.
   Type getResultInterfaceType() const;
 
+  /// Returns the result interface type of this macro if it has already been
+  /// computed, otherwise `nullopt`. This should only be used for dumping.
+  std::optional<Type> getCachedResultInterfaceType() const;
+
   /// Determine the contexts in which this macro can be applied.
   MacroRoles getMacroRoles() const;
 

include/swift/AST/DiagnosticsFrontend.def

@@ -603,5 +603,15 @@ GROUPED_WARNING(command_line_conflicts_with_strict_safety,Unsafe,none,
       "'%0' is not memory-safe and should not be combined with "
       "strict memory safety checking", (StringRef))
 
+ERROR(json_zlib_not_supported,none,
+      "this compiler was not built with zlib compression support enabled; "
+      "'-dump-ast-format json-zlib' cannot be used", ())
+
+ERROR(ast_format_requires_dump_ast,none,
+      "structured AST formats are only supported when using -dump-ast", ())
+
+ERROR(unknown_dump_ast_format,none,
+      "unknown format '%0' requested with '-dump-ast-format'", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/SourceFile.h

@@ -686,6 +686,9 @@ class SourceFile final : public FileUnit {
   SWIFT_DEBUG_DUMP;
   void dump(raw_ostream &os, bool parseIfNeeded = false) const;
 
+  /// Dumps this source file's AST in JSON format to the given output stream.
+  void dumpJSON(raw_ostream &os) const;
+
   /// Pretty-print the contents of this source file.
   ///
   /// \param Printer The AST printer used for printing the contents.

include/swift/Frontend/FrontendOptions.h

@@ -433,6 +433,16 @@ class FrontendOptions {
   /// -dump-scope-maps.
   SmallVector<std::pair<unsigned, unsigned>, 2> DumpScopeMapLocations;
 
+  /// The possible output formats supported for dumping ASTs.
+  enum class ASTFormat {
+    Default,  ///< S-expressions for debugging
+    JSON,     ///< Structured JSON for analysis
+    JSONZlib, ///< Like JSON, but zlib-compressed
+  };
+
+  /// The output format generated by the `-dump-ast` flag.
+  ASTFormat DumpASTFormat = ASTFormat::Default;
+
   /// Determines whether the static or shared resource folder is used.
   /// When set to `true`, the default resource folder will be set to
   /// '.../lib/swift', otherwise '.../lib/swift_static'.

include/swift/Option/Options.td

@@ -1350,6 +1350,12 @@ def emit_parse : Flag<["-"], "emit-parse">, Alias<dump_parse>,
 def dump_ast : Flag<["-"], "dump-ast">,
   HelpText<"Parse and type-check input file(s) and dump AST(s)">, ModeOpt,
   Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
+def dump_ast_format : Separate<["-"], "dump-ast-format">,
+  HelpText<"Desired format for -dump-ast output "
+           "('default', 'json', or 'json-zlib'); no format is guaranteed "
+           "stable across different compiler versions">,
+  MetaVarName<"<format>">,
+  Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
 def emit_ast : Flag<["-"], "emit-ast">, Alias<dump_ast>,
   Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
 def dump_scope_maps : Separate<["-"], "dump-scope-maps">,