ASTPrinter.cpp

//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2025 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
//
//===----------------------------------------------------------------------===//
//
// This file implements printing for the Swift ASTs.
//
//===----------------------------------------------------------------------===//

#include"swift/AST/ASTPrinter.h"
#include"FeatureSet.h"
#include"InlinableText.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/ASTMangler.h"
#include"swift/AST/ASTVisitor.h"
#include"swift/AST/Attr.h"
#include"swift/AST/Builtins.h"
#include"swift/AST/ClangModuleLoader.h"
#include"swift/AST/Comment.h"
#include"swift/AST/ConformanceLookup.h"
#include"swift/AST/Decl.h"
#include"swift/AST/Expr.h"
#include"swift/AST/FileUnit.h"
#include"swift/AST/GenericEnvironment.h"
#include"swift/AST/GenericParamList.h"
#include"swift/AST/GenericSignature.h"
#include"swift/AST/MacroDefinition.h"
#include"swift/AST/Module.h"
#include"swift/AST/NameLookup.h"
#include"swift/AST/NameLookupRequests.h"
#include"swift/AST/ParameterList.h"
#include"swift/AST/PrintOptions.h"
#include"swift/AST/ProtocolConformance.h"
#include"swift/AST/SILLayout.h"
#include"swift/AST/Stmt.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/AST/TypeVisitor.h"
#include"swift/AST/TypeWalker.h"
#include"swift/AST/Types.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/Defer.h"
#include"swift/Basic/Feature.h"
#include"swift/Basic/PrimitiveParsing.h"
#include"swift/Basic/QuotedString.h"
#include"swift/Basic/STLExtras.h"
#include"swift/Basic/StringExtras.h"
#include"swift/Basic/Unicode.h"
#include"swift/ClangImporter/ClangImporterRequests.h"
#include"swift/Config.h"
#include"swift/Parse/Lexer.h"
#include"swift/Strings.h"
#include"clang/AST/ASTContext.h"
#include"clang/AST/Attr.h"
#include"clang/AST/Decl.h"
#include"clang/AST/DeclObjC.h"
#include"clang/Basic/Module.h"
#include"clang/Basic/SourceManager.h"
#include"clang/Lex/MacroInfo.h"
#include"llvm/ADT/STLExtras.h"
#include"llvm/ADT/StringSwitch.h"
#include"llvm/Support/CommandLine.h"
#include"llvm/Support/Compiler.h"
#include"llvm/Support/ConvertUTF.h"
#include"llvm/Support/SaveAndRestore.h"
#include"llvm/Support/raw_ostream.h"
#include<algorithm>
#include<queue>

usingnamespaceswift;

#ifndef NDEBUG
static llvm::cl::opt<bool> NumberSuppressionChecks(
"swift-ast-printer-number-suppression-checks",
llvm::cl::desc("Used to number suppression checks in swift interface files "
"to make it easier to FileCheck them. Only available with "
"asserts enabled and intended for compiler tests."),
 llvm::cl::init(false), llvm::cl::Hidden);
#endif

// Defined here to avoid repeatedly paying the price of template instantiation.
const std::function<bool(const ExtensionDecl *)>
 PrintOptions::defaultPrintExtensionContentAsMembers
 = [] (const ExtensionDecl *) { returnfalse; };

voidPrintOptions::setBaseType(Type T) {
if (T->is<ErrorType>())
return;
if (auto DynamicSelf = T->getAs<DynamicSelfType>()) {
// TypeTransformContext requires `T` to have members. Look through dynamic
// Self.
 T = DynamicSelf->getSelfType();
 }
 TransformContext = TypeTransformContext(T);
}

voidPrintOptions::initForSynthesizedExtension(TypeOrExtensionDecl D) {
 TransformContext = TypeTransformContext(D);
}

voidPrintOptions::clearSynthesizedExtension() {
 TransformContext.reset();
}

staticboolisPublicOrUsableFromInline(const ValueDecl *VD) {
 AccessScope scope =
 VD->getFormalAccessScope(/*useDC*/nullptr,
/*treatUsableFromInlineAsPublic*/true);
return scope.isPublic();
}

staticboolisPublicOrUsableFromInline(Type ty) {
// Note the double negative here: we're looking for any referenced decls that
// are *not* public-or-usableFromInline.
return !ty.findIf([](Type typePart) -> bool {
// FIXME: If we have an internal typealias for a non-internal type, we ought
// to be able to print it by desugaring.
if (auto *aliasTy = dyn_cast<TypeAliasType>(typePart.getPointer()))
return !isPublicOrUsableFromInline(aliasTy->getDecl());
if (auto *nominal = typePart->getAnyNominal())
return !isPublicOrUsableFromInline(nominal);
returnfalse;
 });
}

staticboolisPackage(const ValueDecl *VD) {
 AccessScope scope =
 VD->getFormalAccessScope(/*useDC*/nullptr,
/*treatUsableFromInlineAsPublic*/true);
return scope.isPackage();
}

staticboolisPackage(Type ty) {
// \see isPublicOrUsableFromInline(Type ty)
return !ty.findIf([](Type typePart) -> bool {
if (auto *aliasTy = dyn_cast<TypeAliasType>(typePart.getPointer()))
return !isPackage(aliasTy->getDecl());
if (auto *nominal = typePart->getAnyNominal())
return !isPackage(nominal);
returnfalse;
 });
}

staticboolisPrespecilizationDeclWithTarget(const ValueDecl *vd) {
// Add exported prespecialized symbols.
for (auto *attr : vd->getAttrs().getAttributes<SpecializeAttr>()) {
if (!attr->isExported())
continue;
if (attr->getTargetFunctionDecl(vd))
returntrue;
 }
returnfalse;
}

staticboolcontributesToParentTypeStorage(const AbstractStorageDecl *ASD) {
auto *DC = ASD->getDeclContext()->getAsDecl();
if (!DC) returnfalse;
auto *ND = dyn_cast<NominalTypeDecl>(DC);
if (!ND) returnfalse;
return !ND->isResilient() && ASD->hasStorage() && !ASD->isStatic();
}

staticboolisInObjCImpl(const ValueDecl *VD) {
auto *ED = dyn_cast<ExtensionDecl>(VD->getDeclContext());
return ED && ED->isObjCImplementation();
}

/// Triggering type checking requests while printing is desirable in compiler
/// modes in which type checking is lazy and the printed content is expected to
/// be complete (for example, when printing a .swiftinterface). In other
/// contexts, though, triggering type checking could cause re-entrancy and
/// should be avoided.
staticboolshouldPrintAllSemanticDetails(const PrintOptions &options) {
if (options.IsForSwiftInterface)
returntrue;

returnfalse;
}

boolPrintOptions::excludeAttr(const DeclAttribute *DA) const {
if (excludeAttrKind(DA->getKind())) {
returntrue;
 }
if (auto CA = dyn_cast<CustomAttr>(DA)) {
if (std::any_of(ExcludeCustomAttrList.begin(), ExcludeCustomAttrList.end(),
 [CA](CustomAttr *other) { return other == CA; }))
returntrue;
 }
returnfalse;
}

/// Forces printing types with the `some` keyword, instead of the full stable
/// reference.
structPrintWithOpaqueResultTypeKeywordRAII {
PrintWithOpaqueResultTypeKeywordRAII(PrintOptions &Options)
 : Options(Options) {
 SavedMode = Options.OpaqueReturnTypePrinting;
 Options.OpaqueReturnTypePrinting =
 PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword;
 }
~PrintWithOpaqueResultTypeKeywordRAII() {
 Options.OpaqueReturnTypePrinting = SavedMode;
 }

private:
 PrintOptions &Options;
 PrintOptions::OpaqueReturnTypePrintingMode SavedMode;
};

PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
bool preferTypeRepr,
bool printFullConvention,
 InterfaceMode interfaceMode,
bool useExportedModuleNames,
bool aliasModuleNames,
 llvm::SmallSet<StringRef, 4>
 *aliasModuleNamesTargets
 ) {
 PrintOptions result;
 result.IsForSwiftInterface = true;
 result.PrintLongAttrsOnSeparateLines = true;
 result.TypeDefinitions = true;
 result.CurrentModule = ModuleToPrint;
 result.FullyQualifiedTypes = true;
 result.FullyQualifiedTypesIfAmbiguous = true;
 result.FullyQualifiedExtendedTypesIfAmbiguous = true;
 result.UseExportedModuleNames = useExportedModuleNames;
 result.AllowNullTypes = false;
 result.SkipImports = true;
 result.OmitNameOfInaccessibleProperties = true;
 result.FunctionDefinitions = true;
 result.CollapseSingleGetterProperty = false;
 result.VarInitializers = true;
 result.EnumRawValues = EnumRawValueMode::PrintObjCOnly;
 result.OpaqueReturnTypePrinting =
 OpaqueReturnTypePrintingMode::StableReference;
 result.PreferTypeRepr = preferTypeRepr;
 result.AliasModuleNames = aliasModuleNames;
 result.AliasModuleNamesTargets = aliasModuleNamesTargets;
if (printFullConvention)
 result.PrintFunctionRepresentationAttrs =
 PrintOptions::FunctionRepresentationMode::Full;
 result.AlwaysTryPrintParameterLabels = true;
 result.InterfaceContentKind = interfaceMode;
 result.DesugarExistentialConstraint = true;

// We should print __consuming, __owned, etc for the module interface file.
 result.SkipUnderscoredKeywords = false;

// We should provide backward-compatible Swift interfaces when we can.
 result.PrintCompatibilityFeatureChecks = true;

 result.FunctionBody = [](const ValueDecl *decl, ASTPrinter &printer) {
auto AFD = dyn_cast<AbstractFunctionDecl>(decl);
if (!AFD)
return;
if (AFD->getResilienceExpansion() != ResilienceExpansion::Minimal)
return;
if (!AFD->hasInlinableBodyText())
return;

 SmallString<128> scratch;
 printer << "" << AFD->getInlinableBodyText(scratch);
 };

classShouldPrintForModuleInterface : publicShouldPrintChecker {
boolshouldPrint(const Decl *D, const PrintOptions &options) override {
if (!D)
returnfalse;

// Skip anything that is marked `@_implementationOnly` itself.
if (D->getAttrs().hasAttribute<ImplementationOnlyAttr>())
returnfalse;

// Skip SPI decls if `PrintSPIs`.
if (options.printPublicInterface() && D->isSPI())
returnfalse;

if (auto *VD = dyn_cast<ValueDecl>(D)) {
// Skip anything that isn't 'public' or '@usableFromInline' or has a
// _specialize attribute with a targetFunction parameter.
if (!isPublicOrUsableFromInline(VD) &&
 !isPrespecilizationDeclWithTarget(VD)) {
// We do want to print private stored properties, without their
// original names present.
if (auto *ASD = dyn_cast<AbstractStorageDecl>(VD))
if (contributesToParentTypeStorage(ASD))
returntrue;

if (!options.printPackageInterface() || !isPackage(VD))
returnfalse;
 }

// Skip member implementations and @objc overrides in @objcImpl
// extensions.
if (VD->isObjCMemberImplementation()
 || (isInObjCImpl(VD) && VD->getOverriddenDecl() && VD->isObjC())) {
returnfalse;
 }
 }

// Skip extensions that extend things we wouldn't print.
if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
if (!shouldPrint(ED->getExtendedNominal(), options))
returnfalse;

// Skip extensions to implementation-only imported types that have
// no public members.
auto localModule = ED->getParentModule();
auto nominalModule = ED->getExtendedNominal()->getParentModule();
if (localModule != nominalModule &&
 localModule->isImportedImplementationOnly(nominalModule)) {

bool shouldPrintMembers = llvm::any_of(
 ED->getAllMembers(),
 [&](const Decl *member) -> bool {
returnshouldPrint(member, options);
 });

if (!shouldPrintMembers)
returnfalse;
 }

for (const Requirement &req : ED->getGenericRequirements()) {
if (!isPublicOrUsableFromInline(req.getFirstType())) {
if (!options.printPackageInterface() || !isPackage(req.getSecondType()))
returnfalse;
 }

switch (req.getKind()) {
case RequirementKind::Conformance:
case RequirementKind::Superclass:
case RequirementKind::SameType:
if (!isPublicOrUsableFromInline(req.getSecondType())) {
if (!options.printPackageInterface() || !isPackage(req.getSecondType()))
returnfalse;
 }
break;
case RequirementKind::SameShape:
case RequirementKind::Layout:
break;
 }
 }
 }

// Skip typealiases that just redeclare generic parameters.
if (auto *alias = dyn_cast<TypeAliasDecl>(D)) {
if (alias->isImplicit()) {
const Decl *parent =
 D->getDeclContext()->getAsDecl();
if (auto *genericCtx = parent->getAsGenericContext()) {
bool matchesGenericParam =
llvm::any_of(genericCtx->getInnermostGenericParamTypes(),
 [alias](const GenericTypeParamType *param) {
return param->getName() == alias->getName();
 });
if (matchesGenericParam)
returnfalse;
 }
 }
 }

// Skip stub constructors.
if (auto *ctor = dyn_cast<ConstructorDecl>(D)) {
if (ctor->hasStubImplementation())
returnfalse;
 }

// Skip enum cases containing enum elements we wouldn't print.
if (auto *ECD = dyn_cast<EnumCaseDecl>(D)) {
if (auto *element = ECD->getFirstElement()) {
// Enum elements are usually not printed, so we have to override the
// print option controlling that.
 PrintOptions optionsCopy = options;
 optionsCopy.ExplodeEnumCaseDecls = true;
if (!shouldPrint(element, optionsCopy))
returnfalse;
 }
 }

returnShouldPrintChecker::shouldPrint(D, options);
 }
 };
 result.CurrentPrintabilityChecker =
 std::make_shared<ShouldPrintForModuleInterface>();

// FIXME: We don't really need 'public' on everything; we could just change
// the default to 'public' and mark the 'internal' things.
 result.PrintAccess = true;

 result.ExcludeAttrList = {
 DeclAttrKind::AccessControl,
 DeclAttrKind::SetterAccess,
 DeclAttrKind::Lazy,
 DeclAttrKind::ObjCImplementation,
 DeclAttrKind::StaticInitializeObjCMetadata,
 DeclAttrKind::RestatedObjCConformance,
 DeclAttrKind::NonSendable,
 DeclAttrKind::AllowFeatureSuppression,
 };

return result;
}

TypeTransformContext::TypeTransformContext(Type T)
 : BaseType(T.getPointer()) {
assert(T->mayHaveMembers());
}

TypeTransformContext::TypeTransformContext(TypeOrExtensionDecl D)
 : BaseType(nullptr), Decl(D) {
if (auto NTD = Decl.Decl.dyn_cast<NominalTypeDecl *>())
 BaseType = NTD->getDeclaredTypeInContext().getPointer();
else {
auto *ED = Decl.Decl.get<ExtensionDecl *>();
 BaseType = ED->getDeclaredTypeInContext().getPointer();
 }
}

TypeOrExtensionDecl TypeTransformContext::getDecl() const { return Decl; }

DeclContext *TypeTransformContext::getDeclContext() const {
return Decl.getAsDecl()->getDeclContext();
}

Type TypeTransformContext::getBaseType() const {
returnType(BaseType);
}

boolTypeTransformContext::isPrintingSynthesizedExtension() const {
return !Decl.isNull();
}

voidASTPrinter::anchor() {}

voidASTPrinter::printIndent() {
 llvm::SmallString<16> Str;
for (unsigned i = 0; i != CurrentIndentation; ++i)
 Str += '';

printText(Str);
}

voidASTPrinter::printTextImpl(StringRef Text) {
forceNewlines();
printText(Text);
}

voidASTPrinter::printEscapedStringLiteral(StringRef str) {
 SmallString<128> encodeBuf;
 StringRef escaped =
Lexer::getEncodedStringSegment(str, encodeBuf,
/*isFirstSegment*/true,
/*isLastSegment*/true,
/*indentToStrip*/~0U/* sentinel */);

// FIXME: This is wasteful, but ASTPrinter is an abstract class that doesn't
// have a directly-accessible ostream.
 SmallString<128> escapeBuf;
 llvm::raw_svector_ostream os(escapeBuf);
 os << QuotedString(escaped);
printTextImpl(escapeBuf.str());
}

// Returns true if the given declaration is backed by a C++ template
// specialization.
staticboolisSpecializedCxxDecl(const Decl *D) {
return D->hasClangNode() &&
 isa<clang::ClassTemplateSpecializationDecl>(D->getClangDecl());
}

voidASTPrinter::printTypeRef(Type T, const TypeDecl *RefTo, Identifier Name,
 PrintNameContext Context) {
if (isa<GenericTypeParamDecl>(RefTo)) {
 Context = PrintNameContext::GenericParameter;
 } elseif (T && T->is<DynamicSelfType>()) {
assert(T->castTo<DynamicSelfType>()->getSelfType()->getAnyNominal() &&
"protocol Self handled as GenericTypeParamDecl");
 Context = PrintNameContext::ClassDynamicSelf;
 }

printName(Name, Context, isSpecializedCxxDecl(RefTo));
}

voidASTPrinter::printModuleRef(ModuleEntity Mod, Identifier Name) {
printName(Name);
}

voidASTPrinter::callPrintDeclPre(const Decl *D,
 std::optional<BracketOptions> Bracket) {
forceNewlines();

if (SynthesizeTarget && isa<ExtensionDecl>(D))
printSynthesizedExtensionPre(cast<ExtensionDecl>(D), SynthesizeTarget, Bracket);
else
printDeclPre(D, Bracket);
}

ASTPrinter &ASTPrinter::operator<<(QuotedString s) {
 llvm::SmallString<32> Str;
 llvm::raw_svector_ostream OS(Str);
 OS << s;
printTextImpl(OS.str());
return *this;
}

ASTPrinter &ASTPrinter::operator<<(unsignedlonglong N) {
 llvm::SmallString<32> Str;
 llvm::raw_svector_ostream OS(Str);
 OS << N;
printTextImpl(OS.str());
return *this;
}

ASTPrinter &ASTPrinter::operator<<(UUID UU) {
 llvm::SmallString<UUID::StringBufferSize> Str;
 UU.toString(Str);
printTextImpl(Str);
return *this;
}

ASTPrinter &ASTPrinter::operator<<(Identifier name) {
return *this << DeclName(name);
}

ASTPrinter &ASTPrinter::operator<<(DeclBaseName name) {
return *this << DeclName(name);
}

ASTPrinter &ASTPrinter::operator<<(DeclName name) {
 llvm::SmallString<32> str;
 llvm::raw_svector_ostream os(str);
 name.print(os);
printTextImpl(os.str());
return *this;
}

ASTPrinter &ASTPrinter::operator<<(DeclNameRef ref) {
 llvm::SmallString<32> str;
 llvm::raw_svector_ostream os(str);
 ref.print(os);
printTextImpl(os.str());
return *this;
}

llvm::raw_ostream &swift::
operator<<(llvm::raw_ostream &OS, tok keyword) {
switch (keyword) {
#defineKEYWORD(KW) case tok::kw_##KW: OS << #KW; break;
#definePOUND_KEYWORD(KW) case tok::pound_##KW: OS << "#"#KW; break;
#definePUNCTUATOR(PUN, TEXT) case tok::PUN: OS << TEXT; break;
#include"swift/AST/TokenKinds.def"
default:
llvm_unreachable("unexpected keyword or punctuator kind");
 }
return OS;
}

uint8_tswift::getKeywordLen(tok keyword) {
switch (keyword) {
#defineKEYWORD(KW) case tok::kw_##KW: return StringRef(#KW).size();
#definePOUND_KEYWORD(KW) case tok::pound_##KW: return StringRef("#"#KW).size();
#definePUNCTUATOR(PUN, TEXT) case tok::PUN: return StringRef(TEXT).size();
#include"swift/AST/TokenKinds.def"
default:
llvm_unreachable("unexpected keyword or punctuator kind");
 }
}

StringRef swift::getCodePlaceholder() { return"<#code#>"; }

ASTPrinter &operator<<(ASTPrinter &printer, tok keyword) {
 SmallString<16> Buffer;
 llvm::raw_svector_ostream OS(Buffer);
 OS << keyword;
 printer.printKeyword(Buffer.str(), PrintOptions());
return printer;
}

/// Determine whether to escape the given keyword in the given context.
boolswift::escapeIdentifierInContext(Identifier name, PrintNameContext context,
bool isSpecializedCxxTemplate) {
 StringRef keyword = name.str();
bool isKeyword = llvm::StringSwitch<bool>(keyword)
#defineKEYWORD(KW) \
 .Case(#KW, true)
#include"swift/AST/TokenKinds.def"
 .Default(false);

// NB: ClangImporter synthesizes C++ template specializations with Identifiers
// that contain the full type signature; e.g., a type named literally
// `X<Y, Z>`. These would normally be interpreted as raw identifiers and
// escaped with backticks, but we need to avoid that for those specific decls.

switch (context) {
case PrintNameContext::Normal:
case PrintNameContext::Attribute:
return isKeyword ||
 (!isSpecializedCxxTemplate && name.mustAlwaysBeEscaped());
case PrintNameContext::Keyword:
case PrintNameContext::IntroducerKeyword:
returnfalse;

case PrintNameContext::ClassDynamicSelf:
case PrintNameContext::GenericParameter:
return isKeyword && keyword != "Self";

case PrintNameContext::TypeMember:
return isKeyword || !canBeMemberName(keyword) ||
 (!isSpecializedCxxTemplate && name.mustAlwaysBeEscaped());

case PrintNameContext::FunctionParameterExternal:
case PrintNameContext::FunctionParameterLocal:
case PrintNameContext::TupleElement:
return !canBeArgumentLabel(keyword) ||
 (!isSpecializedCxxTemplate && name.mustAlwaysBeEscaped());
 }

llvm_unreachable("Unhandled PrintNameContext in switch.");
}

voidASTPrinter::printName(Identifier Name, PrintNameContext Context,
bool IsSpecializedCxxTemplate) {
callPrintNamePre(Context);

if (Name.empty()) {
 *this << "_";
printNamePost(Context);
return;
 }

bool shouldEscapeIdentifier =
escapeIdentifierInContext(Name, Context, IsSpecializedCxxTemplate);

if (shouldEscapeIdentifier)
 *this << "`";
 *this << Name.str();
if (shouldEscapeIdentifier)
 *this << "`";

printNamePost(Context);
}

voidStreamPrinter::printText(StringRef Text) {
 OS << Text;
}

/// Whether we will be printing a TypeLoc by using the TypeRepr printer
staticboolwillUseTypeReprPrinting(TypeLoc tyLoc,
 Type currentType,
const PrintOptions &options) {
// Special case for when transforming archetypes
if (currentType && tyLoc.getType())
returnfalse;

return ((options.PreferTypeRepr && tyLoc.hasLocation()) ||
 (tyLoc.getType().isNull() && tyLoc.getTypeRepr()));
}

namespace {
/// AST pretty-printer.
classPrintAST : publicASTVisitor<PrintAST> {
 ASTPrinter &Printer;
 PrintOptions Options;
unsigned IndentLevel = 0;
 Decl *Current = nullptr;
 Type CurrentType;

voidsetCurrentType(Type NewCurrentType) {
 CurrentType = NewCurrentType;
assert(CurrentType.isNull() ||
 !CurrentType->hasArchetype() &&
"CurrentType should be an interface type");
 }

friend DeclVisitor<PrintAST>;

/// RAII object that increases the indentation level.
classIndentRAII {
 PrintAST &Self;
bool DoIndent;

public:
IndentRAII(PrintAST &self, bool DoIndent = true)
 : Self(self), DoIndent(DoIndent) {
if (DoIndent)
 Self.IndentLevel += Self.Options.Indent;
 }

~IndentRAII() {
if (DoIndent)
 Self.IndentLevel -= Self.Options.Indent;
 }
 };

/// Indent the current number of indentation spaces.
voidindent() {
 Printer.setIndent(IndentLevel);
 }

/// Record the location of this declaration, which is about to
/// be printed, marking the name and signature end locations.
template<typename FnTy>
voidrecordDeclLoc(Decl *decl, const FnTy &NameFn,
 llvm::function_ref<void()> ParamFn = []{}) {
 Printer.callPrintDeclLoc(decl);
NameFn();
 Printer.printDeclNameEndLoc(decl);
ParamFn();
 Printer.printDeclNameOrSignatureEndLoc(decl);
 }

voidprintSourceRange(CharSourceRange Range, ASTContext &Ctx) {
 Printer << Ctx.SourceMgr.extractText(Range);
 }

static std::string sanitizeClangDocCommentStyle(StringRef Line) {
static StringRef ClangStart = "/*!";
static StringRef SwiftStart = "/**";
auto Pos = Line.find(ClangStart);
if (Pos == StringRef::npos)
return Line.str();
 StringRef Segment[2];
// The text before "/*!"
 Segment[0] = Line.substr(0, Pos);
// The text after "/*!"
 Segment[1] = Line.substr(Pos).substr(ClangStart.size());
// Only sanitize when "/*!" appears at the start of this line.
if (Segment[0].trim().empty()) {
return (llvm::Twine(Segment[0]) + SwiftStart + Segment[1]).str();
 }
return Line.str();
 }

voidprintClangDocumentationComment(const clang::Decl *D) {
constauto &ClangContext = D->getASTContext();
const clang::RawComment *RC = ClangContext.getRawCommentForAnyRedecl(D);
if (!RC)
return;

bool Invalid;
unsigned StartLocCol =
 ClangContext.getSourceManager().getSpellingColumnNumber(
 RC->getBeginLoc(), &Invalid);
if (Invalid)
 StartLocCol = 0;

unsigned WhitespaceToTrim = StartLocCol ? StartLocCol - 1 : 0;

 SmallVector<StringRef, 8> Lines;

 StringRef RawText =
 RC->getRawText(ClangContext.getSourceManager()).rtrim("\n\r");
trimLeadingWhitespaceFromLines(RawText, WhitespaceToTrim, Lines);
indent();
bool FirstLine = true;
for (auto Line : Lines) {
if (FirstLine)
 Printer << sanitizeClangDocCommentStyle(unicode::sanitizeUTF8(Line));
else
 Printer << unicode::sanitizeUTF8(Line);
 Printer.printNewline();
 FirstLine = false;
 }
 }

voidprintRawComment(RawComment RC) {
indent();

 SmallVector<StringRef, 8> Lines;
for (constauto &SRC : RC.Comments) {
 Lines.clear();

 StringRef RawText = SRC.RawText.rtrim("\n\r");
unsigned WhitespaceToTrim = SRC.ColumnIndent - 1;
trimLeadingWhitespaceFromLines(RawText, WhitespaceToTrim, Lines);

for (auto Line : Lines) {
 Printer << Line;
 Printer.printNewline();
 }
 }
 }

voidprintSwiftDocumentationComment(const Decl *D) {
if (Options.CascadeDocComment)
 D = D->getDocCommentProvidingDecl();
if (!D)
return;
auto RC = D->getRawComment();
if (RC.isEmpty())
return;
printRawComment(RC);
 }

voidprintDocumentationComment(const Decl *D) {
if (!Options.PrintDocumentationComments)
return;

// Try to print a comment from Clang.
auto MaybeClangNode = D->getClangNode();
if (MaybeClangNode) {
if (auto *CD = MaybeClangNode.getAsDecl())
printClangDocumentationComment(CD);
return;
 }

printSwiftDocumentationComment(D);
 }

voidprintStaticKeyword(StaticSpellingKind StaticSpelling) {
switch (StaticSpelling) {
case StaticSpellingKind::None:
llvm_unreachable("should not be called for non-static decls");
case StaticSpellingKind::KeywordStatic:
 Printer << tok::kw_static << "";
break;
case StaticSpellingKind::KeywordClass:
 Printer << tok::kw_class << "";
break;
 }
 }

voidprintAccess(AccessLevel access, StringRef suffix = "") {
switch (access) {
case AccessLevel::Private:
 Printer << tok::kw_private;
break;
case AccessLevel::FilePrivate:
 Printer << tok::kw_fileprivate;
break;
case AccessLevel::Internal:
if (!Options.PrintInternalAccessKeyword)
return;
 Printer << tok::kw_internal;
break;
case AccessLevel::Public:
 Printer << tok::kw_public;
break;
case AccessLevel::Package:
 Printer.printKeyword("package", Options);
break;
case AccessLevel::Open:
 Printer.printKeyword("open", Options);
break;
 }
 Printer << suffix << "";
 }

voidprintAccess(const ValueDecl *D) {
assert(!llvm::is_contained(Options.ExcludeAttrList,
 DeclAttrKind::AccessControl) ||
llvm::is_contained(Options.ExcludeAttrList,
 DeclAttrKind::SetterAccess));

if (!Options.PrintAccess || isa<ProtocolDecl>(D->getDeclContext()))
return;
if (D->getAttrs().hasAttribute<AccessControlAttr>() &&
 !llvm::is_contained(Options.ExcludeAttrList,
 DeclAttrKind::AccessControl))
return;
if (D->getDeclContext()->isLocalContext())
return;

if (Options.SuppressIsolatedDeinit &&
 D->getFormalAccess() == AccessLevel::Open &&
usesFeatureIsolatedDeinit(D)) {
printAccess(AccessLevel::Public);
 } else {
printAccess(D->getFormalAccess());
 }
bool shouldSkipSetterAccess =
llvm::is_contained(Options.ExcludeAttrList, DeclAttrKind::SetterAccess);

if (auto storageDecl = dyn_cast<AbstractStorageDecl>(D)) {
if (auto setter = storageDecl->getAccessor(AccessorKind::Set)) {
 AccessLevel setterAccess = setter->getFormalAccess();
if (setterAccess != D->getFormalAccess() && !shouldSkipSetterAccess)
printAccess(setterAccess, "(set)");
 }
 }
 }

voidprintTypeWithOptions(Type T, const PrintOptions &options) {
if (options.TransformContext) {
// FIXME: it's not clear exactly what we want to keep from the existing
// options, and what we want to discard.
 PrintOptions FreshOptions;
 FreshOptions.ExcludeAttrList = options.ExcludeAttrList;
 FreshOptions.ExclusiveAttrList = options.ExclusiveAttrList;
 FreshOptions.PrintOptionalAsImplicitlyUnwrapped = options.PrintOptionalAsImplicitlyUnwrapped;
 FreshOptions.TransformContext = options.TransformContext;
 FreshOptions.CurrentModule = options.CurrentModule;
 FreshOptions.FullyQualifiedTypesIfAmbiguous = options.FullyQualifiedTypesIfAmbiguous;
 T.print(Printer, FreshOptions);
return;
 }

 T.print(Printer, options);
 }

voidprintType(Type T) { printTypeWithOptions(T, Options); }

 Type getTransformedType(Type T) {
if (CurrentType && Current && CurrentType->mayHaveMembers()) {
 SubstitutionMap subMap;

if (auto *NTD = dyn_cast<NominalTypeDecl>(Current))
 subMap = CurrentType->getContextSubstitutionMap(NTD);
elseif (auto *ED = dyn_cast<ExtensionDecl>(Current))
 subMap = CurrentType->getContextSubstitutionMap(ED);
else {
 Decl *subTarget = Current;
if (isa<ParamDecl>(Current)) {
auto *DC = Current->getDeclContext();
if (auto *FD = dyn_cast<AbstractFunctionDecl>(DC))
 subTarget = FD;
 }
 subMap = CurrentType->getMemberSubstitutionMap(
 cast<ValueDecl>(subTarget));
 }

 T = T.subst(subMap, SubstFlags::DesugarMemberTypes);
 }

return T;
 }

voidprintTransformedTypeWithOptions(Type T, PrintOptions options) {
 T = getTransformedType(T);

if (CurrentType && Current && CurrentType->mayHaveMembers())
 options.TransformContext = TypeTransformContext(CurrentType);

printTypeWithOptions(T, options);
 }

voidprintTransformedType(Type T) {
printTransformedTypeWithOptions(T, Options);
 }

voidprintTypeLocWithOptions(const TypeLoc &TL, const PrintOptions &options,
 std::optional<llvm::function_ref<void()>> printBeforeType = std::nullopt) {
if (CurrentType && TL.getType()) {
if (printBeforeType) (*printBeforeType)();
printTransformedTypeWithOptions(TL.getType(), options);
return;
 }

// Print a TypeRepr if instructed to do so by options, or if the type
// is null.
if (willUseTypeReprPrinting(TL, CurrentType, options)) {
if (auto repr = TL.getTypeRepr())
 repr->print(Printer, options);
return;
 }

if (printBeforeType) (*printBeforeType)();
 TL.getType().print(Printer, options);
 }

voidprintTypeLoc(const TypeLoc &TL) { printTypeLocWithOptions(TL, Options); }

/// Print a TypeLoc. If we decide to print based on the type, rather than
/// based on the TypeRepr, call the given function before printing the type;
/// this is useful if there are attributes in the TypeRepr which don't end
/// up being part of the type, such as `@unchecked` in inheritance clauses.
voidprintTypeLoc(const TypeLoc &TL,
 llvm::function_ref<void()> printBeforeType) {
printTypeLocWithOptions(TL, Options, printBeforeType);
 }

voidprintTypeLocForImplicitlyUnwrappedOptional(TypeLoc TL, bool IUO) {
 PrintOptions options = Options;
 options.PrintOptionalAsImplicitlyUnwrapped = IUO;
printTypeLocWithOptions(TL, options);
 }

voidprintContextIfNeeded(const Decl *decl) {
if (IndentLevel > 0)
return;

switch (Options.ShouldQualifyNestedDeclarations) {
case PrintOptions::QualifyNestedDeclarations::Never:
return;
case PrintOptions::QualifyNestedDeclarations::TypesOnly:
if (!isa<TypeDecl>(decl))
return;
break;
case PrintOptions::QualifyNestedDeclarations::Always:
break;
 }

auto *container = dyn_cast<NominalTypeDecl>(decl->getDeclContext());
if (!container)