DiagnosticEngine.cpp

//===--- DiagnosticEngine.cpp - Diagnostic Display Engine -----------------===//
//
// 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 defines the DiagnosticEngine class, which manages any diagnostics
// emitted by Swift.
//
//===----------------------------------------------------------------------===//

#include"swift/AST/DiagnosticEngine.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/ASTPrinter.h"
#include"swift/AST/Decl.h"
#include"swift/AST/DiagnosticGroups.h"
#include"swift/AST/DiagnosticList.h"
#include"swift/AST/DiagnosticSuppression.h"
#include"swift/AST/DiagnosticsCommon.h"
#include"swift/AST/DiagnosticsFrontend.h"
#include"swift/AST/Expr.h"
#include"swift/AST/Module.h"
#include"swift/AST/Pattern.h"
#include"swift/AST/PrintOptions.h"
#include"swift/AST/SourceFile.h"
#include"swift/AST/Stmt.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/AST/TypeRepr.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/SourceManager.h"
#include"swift/Config.h"
#include"swift/Localization/LocalizationFormat.h"
#include"swift/Parse/Lexer.h"// bad dependency
#include"clang/AST/ASTContext.h"
#include"clang/AST/Decl.h"
#include"clang/AST/PrettyPrinter.h"
#include"clang/AST/Type.h"
#include"llvm/ADT/SmallString.h"
#include"llvm/ADT/Twine.h"
#include"llvm/Support/CommandLine.h"
#include"llvm/Support/Format.h"
#include"llvm/Support/raw_ostream.h"

usingnamespaceswift;

static_assert(IsTriviallyDestructible<ZeroArgDiagnostic>::value,
"ZeroArgDiagnostic is meant to be trivially destructable");

namespace {
enumclassDiagnosticOptions {
/// No options.
 none,

/// The location of this diagnostic points to the beginning of the first
/// token that the parser considers invalid. If this token is located at the
/// beginning of the line, then the location is adjusted to point to the end
/// of the previous token.
///
/// This behavior improves experience for "expected token X" diagnostics.
 PointsToFirstBadToken,

/// After a fatal error subsequent diagnostics are suppressed.
 Fatal,

/// An API or ABI breakage diagnostic emitted by the API digester.
 APIDigesterBreakage,

/// A deprecation warning or error.
 Deprecation,

/// A diagnostic warning about an unused element.
 NoUsage,

/// The diagnostic should be ignored by default, but will be re-enabled
/// by various warning options (-Wwarning, -Werror). This only makes sense
/// for warnings.
 DefaultIgnore,
};
structStoredDiagnosticInfo {
 DiagnosticKind kind : 2;
bool pointsToFirstBadToken : 1;
bool isFatal : 1;
bool isAPIDigesterBreakage : 1;
bool isDeprecation : 1;
bool isNoUsage : 1;
bool defaultIgnore : 1;
 DiagGroupID groupID;

constexprStoredDiagnosticInfo(DiagnosticKind k, bool firstBadToken,
bool fatal, bool isAPIDigesterBreakage,
bool deprecation, bool noUsage,
bool defaultIgnore, DiagGroupID groupID)
 : kind(k), pointsToFirstBadToken(firstBadToken), isFatal(fatal),
 isAPIDigesterBreakage(isAPIDigesterBreakage),
 isDeprecation(deprecation), isNoUsage(noUsage),
 defaultIgnore(defaultIgnore), groupID(groupID) {}
constexprStoredDiagnosticInfo(DiagnosticKind k, DiagnosticOptions opts,
 DiagGroupID groupID)
 : StoredDiagnosticInfo(k,
 opts == DiagnosticOptions::PointsToFirstBadToken,
 opts == DiagnosticOptions::Fatal,
 opts == DiagnosticOptions::APIDigesterBreakage,
 opts == DiagnosticOptions::Deprecation,
 opts == DiagnosticOptions::NoUsage,
 opts == DiagnosticOptions::DefaultIgnore,
 groupID) {}
};
} // end anonymous namespace

// TODO: categorization
staticconstconstexpr StoredDiagnosticInfo storedDiagnosticInfos[] = {
#defineGROUPED_ERROR(ID, Group, Options, Text, Signature) \
StoredDiagnosticInfo(DiagnosticKind::Error, DiagnosticOptions::Options, \
 DiagGroupID::Group),
#defineGROUPED_WARNING(ID, Group, Options, Text, Signature) \
StoredDiagnosticInfo(DiagnosticKind::Warning, DiagnosticOptions::Options, \
 DiagGroupID::Group),
#defineNOTE(ID, Options, Text, Signature) \
StoredDiagnosticInfo(DiagnosticKind::Note, DiagnosticOptions::Options, \
 DiagGroupID::no_group),
#defineREMARK(ID, Options, Text, Signature) \
StoredDiagnosticInfo(DiagnosticKind::Remark, DiagnosticOptions::Options, \
 DiagGroupID::no_group),
#include"swift/AST/DiagnosticsAll.def"
};
static_assert(sizeof(storedDiagnosticInfos) / sizeof(StoredDiagnosticInfo) ==
 NumDiagIDs,
 "array size mismatch");

staticconstexprconstchar * const diagnosticStrings[] = {
#defineDIAG(KIND, ID, Group, Options, Text, Signature) Text,
#include"swift/AST/DiagnosticsAll.def"
"<not a diagnostic>",
};

staticconstexprconstchar *const diagnosticIDStrings[] = {
#defineDIAG(KIND, ID, Group, Options, Text, Signature) #ID,
#include"swift/AST/DiagnosticsAll.def"
"<not a diagnostic>",
};

staticconstexprconstchar *const fixItStrings[] = {
#defineDIAG(KIND, ID, Group, Options, Text, Signature)
#defineFIXIT(ID, Text, Signature) Text,
#include"swift/AST/DiagnosticsAll.def"
"<not a fix-it>",
};

DiagnosticState::DiagnosticState() {
// Initialize our ignored diagnostics to defaults
 ignoredDiagnostics.reserve(NumDiagIDs);
for (constauto &info : storedDiagnosticInfos) {
 ignoredDiagnostics.push_back(info.defaultIgnore);
 }

// Initialize warningsAsErrors to default
 warningsAsErrors.resize(DiagGroupsCount);
}

Diagnostic::Diagnostic(DiagID ID)
 : Diagnostic(ID, storedDiagnosticInfos[(unsigned)ID].groupID) {}

std::optional<const DiagnosticInfo *> Diagnostic::getWrappedDiagnostic() const {
for (constauto &arg : getArgs()) {
if (arg.getKind() == DiagnosticArgumentKind::Diagnostic) {
return arg.getAsDiagnostic();
 }
 }

return std::nullopt;
}

static CharSourceRange toCharSourceRange(SourceManager &SM, SourceRange SR) {
returnCharSourceRange(SM, SR.Start, Lexer::getLocForEndOfToken(SM, SR.End));
}

static CharSourceRange toCharSourceRange(SourceManager &SM, SourceLoc Start,
 SourceLoc End) {
returnCharSourceRange(SM, Start, End);
}

/// Extract a character at \p Loc. If \p Loc is the end of the buffer,
/// return '\f'.
staticcharextractCharAfter(SourceManager &SM, SourceLoc Loc) {
auto chars = SM.extractText({Loc, 1});
return chars.empty() ? '\f' : chars[0];
}

/// Extract a character immediately before \p Loc. If \p Loc is the
/// start of the buffer, return '\f'.
staticcharextractCharBefore(SourceManager &SM, SourceLoc Loc) {
// We have to be careful not to go off the front of the buffer.
auto bufferID = SM.findBufferContainingLoc(Loc);
auto bufferRange = SM.getRangeForBuffer(bufferID);
if (bufferRange.getStart() == Loc)
return'\f';
auto chars = SM.extractText({Loc.getAdvancedLoc(-1), 1}, bufferID);
assert(!chars.empty() && "Couldn't extractText with valid range");
return chars[0];
}

InFlightDiagnostic &InFlightDiagnostic::highlight(SourceRange R) {
assert(IsActive && "Cannot modify an inactive diagnostic");
if (Engine && R.isValid())
 Engine->getActiveDiagnostic()
 .addRange(toCharSourceRange(Engine->SourceMgr, R));
return *this;
}

InFlightDiagnostic &InFlightDiagnostic::highlightChars(SourceLoc Start,
 SourceLoc End) {
assert(IsActive && "Cannot modify an inactive diagnostic");
if (Engine && Start.isValid())
 Engine->getActiveDiagnostic()
 .addRange(toCharSourceRange(Engine->SourceMgr, Start, End));
return *this;
}

InFlightDiagnostic &InFlightDiagnostic::highlightChars(CharSourceRange Range) {
assert(IsActive && "Cannot modify an inactive diagnostic");
if (Engine && Range.getStart().isValid())
 Engine->getActiveDiagnostic().addRange(Range);
return *this;
}

/// Add an insertion fix-it to the currently-active diagnostic. The
/// text is inserted immediately *after* the token specified.
///
InFlightDiagnostic &
InFlightDiagnostic::fixItInsertAfter(SourceLoc L, StringRef FormatString,
 ArrayRef<DiagnosticArgument> Args) {
 L = Lexer::getLocForEndOfToken(Engine->SourceMgr, L);
returnfixItInsert(L, FormatString, Args);
}

/// Add a token-based removal fix-it to the currently-active
/// diagnostic.
InFlightDiagnostic &InFlightDiagnostic::fixItRemove(SourceRange R) {
assert(IsActive && "Cannot modify an inactive diagnostic");
if (R.isInvalid() || !Engine) return *this;

// Convert from a token range to a CharSourceRange, which points to the end of
// the token we want to remove.
auto &SM = Engine->SourceMgr;
auto charRange = toCharSourceRange(SM, R);

// If we're removing something (e.g. a keyword), do a bit of extra work to
// make sure that we leave the code in a good place, without extraneous white
// space around its hole. Specifically, check to see there is whitespace
// before and after the end of range. If so, nuke the space afterward to keep
// things consistent.
if (extractCharAfter(SM, charRange.getEnd()) == '' &&
isspace(extractCharBefore(SM, charRange.getStart()))) {
 charRange = CharSourceRange(charRange.getStart(),
 charRange.getByteLength()+1);
 }
 Engine->getActiveDiagnostic().addFixIt(Diagnostic::FixIt(charRange, {}, {}));
return *this;
}

InFlightDiagnostic &
InFlightDiagnostic::fixItReplace(SourceRange R, StringRef FormatString,
 ArrayRef<DiagnosticArgument> Args) {
auto &SM = Engine->SourceMgr;
auto charRange = toCharSourceRange(SM, R);

 Engine->getActiveDiagnostic().addFixIt(
Diagnostic::FixIt(charRange, FormatString, Args));
return *this;
}

InFlightDiagnostic &InFlightDiagnostic::fixItReplace(SourceRange R,
 StringRef Str) {
if (Str.empty())
returnfixItRemove(R);

assert(IsActive && "Cannot modify an inactive diagnostic");
if (R.isInvalid() || !Engine) return *this;

auto &SM = Engine->SourceMgr;
auto charRange = toCharSourceRange(SM, R);

// If we're replacing with something that wants spaces around it, do a bit of
// extra work so that we don't suggest extra spaces.
// FIXME: This could probably be applied to structured fix-its as well.
if (Str.back() == '') {
if (isspace(extractCharAfter(SM, charRange.getEnd())))
 Str = Str.drop_back();
 }
if (!Str.empty() && Str.front() == '') {
if (isspace(extractCharBefore(SM, charRange.getStart())))
 Str = Str.drop_front();
 }

returnfixItReplace(R, "%0", {Str});
}

InFlightDiagnostic &
InFlightDiagnostic::fixItReplaceChars(SourceLoc Start, SourceLoc End,
 StringRef FormatString,
 ArrayRef<DiagnosticArgument> Args) {
assert(IsActive && "Cannot modify an inactive diagnostic");
if (Engine && Start.isValid())
 Engine->getActiveDiagnostic().addFixIt(
Diagnostic::FixIt(toCharSourceRange(Engine->SourceMgr, Start, End),
 FormatString, Args));
return *this;
}

SourceLoc
DiagnosticEngine::getBestAddImportFixItLoc(const Decl *Member,
 SourceFile *sourceFile) const {
auto &SM = SourceMgr;

 SourceLoc bestLoc;

auto SF =
 sourceFile ? sourceFile : Member->getDeclContext()->getParentSourceFile();
if (!SF) {
return bestLoc;
 }

for (auto item : SF->getTopLevelItems()) {
// If we found an import declaration, we want to insert after it.
if (auto importDecl =
 dyn_cast_or_null<ImportDecl>(item.dyn_cast<Decl *>())) {
 SourceLoc loc = importDecl->getEndLoc();
if (loc.isValid()) {
 bestLoc = Lexer::getLocForEndOfLine(SM, loc);
 }

// Keep looking for more import declarations.
continue;
 }

// If we got a location based on import declarations, we're done.
if (bestLoc.isValid())
break;

// For any other item, we want to insert before it.
 SourceLoc loc = item.getStartLoc();
if (loc.isValid()) {
 bestLoc = Lexer::getLocForStartOfLine(SM, loc);
break;
 }
 }

return bestLoc;
}

InFlightDiagnostic &InFlightDiagnostic::fixItAddImport(StringRef ModuleName) {
assert(IsActive && "Cannot modify an inactive diagnostic");
auto Member = Engine->ActiveDiagnostic->getDecl();
 SourceLoc bestLoc = Engine->getBestAddImportFixItLoc(Member);

if (bestLoc.isValid()) {
 llvm::SmallString<64> importText;

// @_spi imports.
if (Member->isSPI()) {
auto spiGroups = Member->getSPIGroups();
if (!spiGroups.empty()) {
 importText += "@_spi(";
 importText += spiGroups[0].str();
 importText += ") ";
 }
 }

 importText += "import ";
 importText += ModuleName;
 importText += "\n";

returnfixItInsert(bestLoc, importText);
 }

return *this;
}

InFlightDiagnostic &
InFlightDiagnostic::fixItInsertAttribute(SourceLoc L,
const DeclAttribute *Attr) {
returnfixItInsert(L, "%0 ", {Attr});
}

InFlightDiagnostic &
InFlightDiagnostic::fixItAddAttribute(const DeclAttribute *Attr,
const ClosureExpr *E) {
ASSERT(!E->isImplicit());

 SourceLoc insertionLoc;

if (auto *paramList = E->getParameters()) {
// HACK: Don't set insertion loc to param list start loc if it's equal to
// closure start loc (meaning it's implicit).
// FIXME: Don't set the start loc of an implicit param list, or put an
// isImplicit bit on ParameterList.
if (paramList->getStartLoc() != E->getStartLoc()) {
 insertionLoc = paramList->getStartLoc();
 }
 }

if (insertionLoc.isInvalid()) {
 insertionLoc = E->getInLoc();
 }

if (insertionLoc.isValid()) {
returnfixItInsert(insertionLoc, "%0 ", {Attr});
 } else {
 insertionLoc = E->getBody()->getLBraceLoc();
ASSERT(insertionLoc.isValid());
returnfixItInsertAfter(insertionLoc, " %0 in ", {Attr});
 }
}

InFlightDiagnostic &InFlightDiagnostic::fixItExchange(SourceRange R1,
 SourceRange R2) {
assert(IsActive && "Cannot modify an inactive diagnostic");

auto &SM = Engine->SourceMgr;
// Convert from a token range to a CharSourceRange
auto charRange1 = toCharSourceRange(SM, R1);
auto charRange2 = toCharSourceRange(SM, R2);
// Extract source text.
auto text1 = SM.extractText(charRange1);
auto text2 = SM.extractText(charRange2);

 Engine->getActiveDiagnostic().addFixIt(
Diagnostic::FixIt(charRange1, "%0", {text2}));
 Engine->getActiveDiagnostic().addFixIt(
Diagnostic::FixIt(charRange2, "%0", {text1}));
return *this;
}

InFlightDiagnostic &
InFlightDiagnostic::limitBehavior(DiagnosticBehavior limit) {
 Engine->getActiveDiagnostic().setBehaviorLimit(limit);
return *this;
}

InFlightDiagnostic &
InFlightDiagnostic::limitBehaviorUntilSwiftVersion(
 DiagnosticBehavior limit, unsigned majorVersion) {
if (!Engine->languageVersion.isVersionAtLeast(majorVersion)) {
// If the behavior limit is a warning or less, wrap the diagnostic
// in a message that this will become an error in a later Swift
// version. We do this before limiting the behavior, because
// wrapIn will result in the behavior of the wrapping diagnostic.
if (limit >= DiagnosticBehavior::Warning) {
if (majorVersion >= version::Version::getFutureMajorLanguageVersion()) {
wrapIn(diag::error_in_a_future_swift_lang_mode);
 } else {
wrapIn(diag::error_in_swift_lang_mode, majorVersion);
 }
 }

limitBehavior(limit);
 }

// Record all of the diagnostics that are going to be emitted.
if (majorVersion == 6 && limit != DiagnosticBehavior::Ignore) {
if (auto stats = Engine->statsReporter) {
 ++stats->getFrontendCounters().NumSwift6Errors;
 }
 }

return *this;
}

InFlightDiagnostic &InFlightDiagnostic::warnUntilFutureSwiftVersion() {
usingnamespaceversion;
returnwarnUntilSwiftVersion(Version::getFutureMajorLanguageVersion());
}

InFlightDiagnostic &
InFlightDiagnostic::warnUntilSwiftVersion(unsigned majorVersion) {
returnlimitBehaviorUntilSwiftVersion(DiagnosticBehavior::Warning,
 majorVersion);
}

InFlightDiagnostic &
InFlightDiagnostic::warnInSwiftInterface(const DeclContext *context) {
if (context->isInSwiftinterface()) {
returnlimitBehavior(DiagnosticBehavior::Warning);
 }

return *this;
}

InFlightDiagnostic &
InFlightDiagnostic::wrapIn(const Diagnostic &wrapper) {
// Save current active diagnostic into WrappedDiagnostics, ignoring state
// so we don't get a None return or influence future diagnostics.
 DiagnosticState tempState;
 Engine->state.swap(tempState);
 llvm::SaveAndRestore<DiagnosticBehavior>
limit(Engine->getActiveDiagnostic().BehaviorLimit,
 DiagnosticBehavior::Unspecified);

 Engine->WrappedDiagnostics.push_back(*Engine->diagnosticInfoForDiagnostic(
 Engine->getActiveDiagnostic(), /* includeDiagnosticName= */false));

 Engine->state.swap(tempState);

auto &wrapped = Engine->WrappedDiagnostics.back();

// Copy and update its arg list.
 Engine->WrappedDiagnosticArgs.emplace_back(wrapped.FormatArgs);
 wrapped.FormatArgs = Engine->WrappedDiagnosticArgs.back();

// Overwrite the ID and arguments with those from the wrapper.
 Engine->getActiveDiagnostic().ID = wrapper.ID;
 Engine->getActiveDiagnostic().Args = wrapper.Args;
// Intentionally keeping the original GroupID here

// Set the argument to the diagnostic being wrapped.
ASSERT(wrapper.getArgs().front().getKind() ==
 DiagnosticArgumentKind::Diagnostic);
 Engine->getActiveDiagnostic().Args.front() = &wrapped;

return *this;
}

voidInFlightDiagnostic::flush() {
if (!IsActive)
return;

 IsActive = false;
if (Engine)
 Engine->flushActiveDiagnostic();
}

voidDiagnostic::addChildNote(Diagnostic &&D) {
assert(storedDiagnosticInfos[(unsigned)D.ID].kind == DiagnosticKind::Note &&
"Only notes can have a parent.");
assert(storedDiagnosticInfos[(unsigned)ID].kind != DiagnosticKind::Note &&
"Notes can't have children.");
 ChildNotes.push_back(std::move(D));
}

boolDiagnosticEngine::isDiagnosticPointsToFirstBadToken(DiagID ID) const {
return storedDiagnosticInfos[(unsigned) ID].pointsToFirstBadToken;
}

boolDiagnosticEngine::isAPIDigesterBreakageDiagnostic(DiagID ID) const {
return storedDiagnosticInfos[(unsigned)ID].isAPIDigesterBreakage;
}

boolDiagnosticEngine::isDeprecationDiagnostic(DiagID ID) const {
return storedDiagnosticInfos[(unsigned)ID].isDeprecation;
}

boolDiagnosticEngine::isNoUsageDiagnostic(DiagID ID) const {
return storedDiagnosticInfos[(unsigned)ID].isNoUsage;
}

boolDiagnosticEngine::finishProcessing() {
bool hadError = false;
for (auto &Consumer : Consumers) {
 hadError |= Consumer->finishProcessing();
 }
return hadError;
}

voidDiagnosticEngine::setWarningsAsErrorsRules(
const std::vector<WarningAsErrorRule> &rules) {
 std::vector<std::string> unknownGroups;
for (constauto &rule : rules) {
bool isEnabled = [&] {
switch (rule.getAction()) {
case WarningAsErrorRule::Action::Enable:
returntrue;
case WarningAsErrorRule::Action::Disable:
returnfalse;
 }
 }();
auto target = rule.getTarget();
if (auto group = std::get_if<WarningAsErrorRule::TargetGroup>(&target)) {
auto name = std::string_view(group->name);
// Validate the group name and set the new behavior for each diagnostic
// associated with the group and all its subgroups.
if (auto groupID = getDiagGroupIDByName(name);
 groupID && *groupID != DiagGroupID::no_group) {
getDiagGroupInfoByID(*groupID).traverseDepthFirst([&](auto group) {
 state.setWarningsAsErrorsForDiagGroupID(*groupID, isEnabled);
for (DiagID diagID : group.diagnostics) {
 state.setIgnoredDiagnostic(diagID, false);
 }
 });
 } else {
 unknownGroups.push_back(std::string(name));
 }
 } elseif (std::holds_alternative<WarningAsErrorRule::TargetAll>(target)) {
 state.setAllWarningsAsErrors(isEnabled);
 } else {
llvm_unreachable("unhandled WarningAsErrorRule::Target");
 }
 }
for (constauto &unknownGroup : unknownGroups) {
diagnose(SourceLoc(), diag::unknown_warning_group, unknownGroup);
 }
}

/// Skip forward to one of the given delimiters.
///
/// \param Text The text to search through, which will be updated to point
/// just after the delimiter.
///
/// \param Delim The first character delimiter to search for.
///
/// \param FoundDelim On return, true if the delimiter was found, or false
/// if the end of the string was reached.
///
/// \returns The string leading up to the delimiter, or the empty string
/// if no delimiter is found.
static StringRef 
skipToDelimiter(StringRef &Text, char Delim, bool *FoundDelim = nullptr) {
unsigned Depth = 0;
if (FoundDelim)
 *FoundDelim = false;

unsigned I = 0;
for (unsigned N = Text.size(); I != N; ++I) {
if (Text[I] == '{') {
 ++Depth;
continue;
 }
if (Depth > 0) {
if (Text[I] == '}')
 --Depth;
continue;
 }

if (Text[I] == Delim) {
if (FoundDelim)
 *FoundDelim = true;
break;
 }
 }

assert(Depth == 0 && "Unbalanced {} set in diagnostic text");
 StringRef Result = Text.substr(0, I);
 Text = Text.substr(I + 1);
return Result;
}

/// Handle the integer 'select' modifier. This is used like this:
/// %select{foo|bar|baz}2. This means that the integer argument "%2" has a
/// value from 0-2. If the value is 0, the diagnostic prints 'foo'.
/// If the value is 1, it prints 'bar'. If it has the value 2, it prints 'baz'.
/// This is very useful for certain classes of variant diagnostics.
staticvoidformatSelectionArgument(StringRef ModifierArguments,
 ArrayRef<DiagnosticArgument> Args,
unsigned SelectedIndex,
 DiagnosticFormatOptions FormatOpts,
 llvm::raw_ostream &Out) {
bool foundPipe = false;
do {
assert((!ModifierArguments.empty() || foundPipe) &&
"Index beyond bounds in %select modifier");
 StringRef Text = skipToDelimiter(ModifierArguments, '|', &foundPipe);
if (SelectedIndex == 0) {
DiagnosticEngine::formatDiagnosticText(Out, Text, Args, FormatOpts);
break;
 }
 --SelectedIndex;
 } while (true);

}

staticboolisInterestingTypealias(Type type) {
// Dig out the typealias declaration, if there is one.
 TypeAliasDecl *aliasDecl = nullptr;
if (auto aliasTy = dyn_cast<TypeAliasType>(type.getPointer()))
 aliasDecl = aliasTy->getDecl();
else
returnfalse;

if (type->isVoid())
returnfalse;

// The 'Swift.AnyObject' typealias is not 'interesting'.
if (aliasDecl->getName() ==
 aliasDecl->getASTContext().getIdentifier("AnyObject") &&
 (aliasDecl->getParentModule()->isStdlibModule() ||
 aliasDecl->getParentModule()->isBuiltinModule())) {
returnfalse;
 }

// Compatibility aliases are only interesting insofar as their underlying
// types are interesting.
if (aliasDecl->isCompatibilityAlias()) {
auto underlyingTy = aliasDecl->getUnderlyingType();
returnisInterestingTypealias(underlyingTy);
 }

// Builtin types are never interesting typealiases.
if (type->is<BuiltinType>()) returnfalse;

returntrue;
}

/// Walks the type recursively desugaring types to display, but skipping
/// `GenericTypeParamType` because we would lose association with its original
/// declaration and end up presenting the parameter in τ_0_0 format on
/// diagnostic.
static Type getAkaTypeForDisplay(Type type) {
return type.transformRec([&](TypeBase *visitTy) -> std::optional<Type> {
if (isa<SugarType>(visitTy) &&
 !isa<GenericTypeParamType>(visitTy))
returngetAkaTypeForDisplay(visitTy->getDesugaredType());
return std::nullopt;
 });
}

/// Decide whether to show the desugared type or not. We filter out some
/// cases to avoid too much noise.
staticboolshouldShowAKA(Type type, StringRef typeName) {
// Canonical types are already desugared.
if (type->isCanonical())
returnfalse;

// Only show 'aka' if there's a typealias involved; other kinds of sugar
// are easy enough for people to read on their own.
if (!type.findIf(isInterestingTypealias))
returnfalse;

// If they are textually the same, don't show them. This can happen when
// they are actually different types, because they exist in different scopes
// (e.g. everyone names their type parameters 'T').
if (typeName == getAkaTypeForDisplay(type).getString())
returnfalse;

returntrue;
}

/// If a type is part of an argument list which includes another, distinct type
/// with the same string representation, it should be qualified during
/// formatting.
staticbooltypeSpellingIsAmbiguous(Type type,
 ArrayRef<DiagnosticArgument> Args,
 PrintOptions &PO) {
for (auto arg : Args) {
if (arg.getKind() == DiagnosticArgumentKind::Type) {
auto argType = arg.getAsType();
if (argType && argType.getPointer() != type.getPointer() &&
 argType.getString(PO) == type.getString(PO)) {
// Currently, existential types are spelled the same way
// as protocols and compositions. We can remove this once
// existenials are printed with 'any'.
if (type->is<ExistentialType>() || argType->isExistentialType()) {
auto constraint = type;
if (auto existential = type->getAs<ExistentialType>())
 constraint = existential->getConstraintType();

auto argConstraint = argType;
if (auto existential = argType->getAs<ExistentialType>())
 argConstraint = existential->getConstraintType();

if (constraint.getPointer() != argConstraint.getPointer())
returntrue;

continue;
 }

returntrue;
 }
 }
 }
returnfalse;
}

voidswift::printClangDeclName(const clang::NamedDecl *ND,
 llvm::raw_ostream &os) {
 ND->getNameForDiagnostic(os, ND->getASTContext().getPrintingPolicy(), false);
}

voidswift::printClangTypeName(const clang::Type *Ty, llvm::raw_ostream &os) {
clang::QualType::print(Ty, clang::Qualifiers(), os,
 clang::PrintingPolicy{clang::LangOptions()}, "");
}

/// Format a single diagnostic argument and write it to the given
/// stream.
staticvoidformatDiagnosticArgument(StringRef Modifier,
 StringRef ModifierArguments,
 ArrayRef<DiagnosticArgument> Args,
unsigned ArgIndex,
 DiagnosticFormatOptions FormatOpts,
 llvm::raw_ostream &Out) {
const DiagnosticArgument &Arg = Args[ArgIndex];
switch (Arg.getKind()) {
case DiagnosticArgumentKind::Integer:
if (Modifier == "select") {
assert(Arg.getAsInteger() >= 0 && "Negative selection index");
formatSelectionArgument(ModifierArguments, Args, Arg.getAsInteger(),
 FormatOpts, Out);
 } elseif (Modifier == "s") {
if (Arg.getAsInteger() != 1)
 Out << 's';
 } else {
assert(Modifier.empty() && "Improper modifier for integer argument");
 Out << Arg.getAsInteger();
 }
break;

case DiagnosticArgumentKind::Unsigned:
if (Modifier == "select") {
formatSelectionArgument(ModifierArguments, Args, Arg.getAsUnsigned(),
 FormatOpts, Out);
 } elseif (Modifier == "s") {
if (Arg.getAsUnsigned() != 1)
 Out << 's';
 } else {
assert(Modifier.empty() && "Improper modifier for unsigned argument");
 Out << Arg.getAsUnsigned();
 }
break;

case DiagnosticArgumentKind::String:
if (Modifier == "select") {
formatSelectionArgument(ModifierArguments, Args,
 Arg.getAsString().empty() ? 0 : 1, FormatOpts,
 Out);
 } else {
assert(Modifier.empty() && "Improper modifier for string argument");
 Out << Arg.getAsString();
 }
break;

case DiagnosticArgumentKind::Identifier:
if (Modifier == "select") {
formatSelectionArgument(ModifierArguments, Args,
 Arg.getAsIdentifier() ? 1 : 0, FormatOpts,
 Out);
 } else {
assert(Modifier.empty() && "Improper modifier for identifier argument");
 Out << FormatOpts.OpeningQuotationMark;
 Arg.getAsIdentifier().printPretty(Out);
 Out << FormatOpts.ClosingQuotationMark;
 }
break;

case DiagnosticArgumentKind::ObjCSelector:
assert(Modifier.empty() && "Improper modifier for selector argument");
 Out << FormatOpts.OpeningQuotationMark << Arg.getAsObjCSelector()
 << FormatOpts.ClosingQuotationMark;
break;

case DiagnosticArgumentKind::Decl: {
auto D = Arg.getAsDecl();

if (Modifier == "select") {
formatSelectionArgument(ModifierArguments, Args, D ? 1 : 0, FormatOpts,
 Out);
break;
 }

// Parse info out of modifier
bool includeKind = false;
bool includeName = true;
bool baseNameOnly = false;

if (Modifier == "kind") {
 includeKind = true;
 } elseif (Modifier == "base") {
 baseNameOnly = true;
 } elseif (Modifier == "kindbase") {
 includeKind = true;
 baseNameOnly = true;
 } elseif (Modifier == "kindonly") {
 includeName = false;
 } else {
assert(Modifier.empty() && "Improper modifier for ValueDecl argument");
 }

if (includeName) {
if (auto accessor = dyn_cast<AccessorDecl>(D)) {
// If it's an accessor, describe that and then switch to discussing its
// storage declaration.
 Out << Decl::getDescriptiveKindName(D->getDescriptiveKind()) << " for ";
 D = accessor->getStorage();
 } elseif (auto ext = dyn_cast<ExtensionDecl>(D)) {
// If it's an extension with a valid bound type declaration, describe
// the extension itself then switch to discussing the bound
// declaration.
if (auto *nominal = ext->getSelfNominalTypeDecl()) {
 Out << Decl::getDescriptiveKindName(D->getDescriptiveKind())
 << " of ";
 D = nominal;
 }
 }
 }

// Figure out the name we want to print.
 DeclName name;
if (includeName) {
if (auto MD = dyn_cast<ModuleDecl>(D))
 name = MD->getPublicModuleName(/*onlyIfImported=*/true);
elseif (auto VD = dyn_cast<ValueDecl>(D))
 name = VD->getName();
elseif (auto PGD = dyn_cast<PrecedenceGroupDecl>(D))
 name = PGD->getName();
elseif (auto OD = dyn_cast<OperatorDecl>(D))
 name = OD->getName();
elseif (auto MMD = dyn_cast<MissingMemberDecl>(D))
 name = MMD->getName();

if (baseNameOnly && name)
 name = name.getBaseName();
 }

// If the declaration is anonymous or we asked for a descriptive kind, print
// it.
if (!name || includeKind) {
 Out << Decl::getDescriptiveKindName(D->getDescriptiveKind());
if (name)
 Out << "";
 }

// Print the name.
if (name) {
 Out << FormatOpts.OpeningQuotationMark;
 name.printPretty(Out);
 Out << FormatOpts.ClosingQuotationMark;
 }
break;
 }

case DiagnosticArgumentKind::FullyQualifiedType:
case DiagnosticArgumentKind::Type:
case DiagnosticArgumentKind::WitnessType: {
 std::optional<DiagnosticFormatOptions> TypeFormatOpts;
if (Modifier == "noformat") {
 TypeFormatOpts.emplace(DiagnosticFormatOptions::formatForFixIts());
 } else {
assert(Modifier.empty() && "Improper modifier for Type argument");
 TypeFormatOpts.emplace(FormatOpts);
 }

// Strip extraneous parentheses; they add no value.
 Type type;
bool needsQualification = false;

// Compute the appropriate print options for this argument.
auto printOptions = PrintOptions::forDiagnosticArguments();
if (Arg.getKind() == DiagnosticArgumentKind::Type) {
 type = Arg.getAsType();
if (type->getASTContext().TypeCheckerOpts.PrintFullConvention)
 printOptions.PrintFunctionRepresentationAttrs =
 PrintOptions::FunctionRepresentationMode::Full;
 needsQualification = typeSpellingIsAmbiguous(type, Args, printOptions);
 } elseif (Arg.getKind() == DiagnosticArgumentKind::FullyQualifiedType) {
 type = Arg.getAsFullyQualifiedType().getType();
if (type->getASTContext().TypeCheckerOpts.PrintFullConvention)
 printOptions.PrintFunctionRepresentationAttrs =
 PrintOptions::FunctionRepresentationMode::Full;
 needsQualification = true;
 } else {
assert(Arg.getKind() == DiagnosticArgumentKind::WitnessType);
 type = Arg.getAsWitnessType().getType();
 printOptions.PrintGenericRequirements = false;
 printOptions.PrintInverseRequirements = false;
 needsQualification = typeSpellingIsAmbiguous(type, Args, printOptions);
 }

// If a type has an unresolved type, print it with syntax sugar removed for
// clarity. For example, print `Array<_>` instead of `[_]`.
if (type->hasUnresolvedType()) {
 type = type->getWithoutSyntaxSugar();
 }

if (needsQualification &&
 isa<OpaqueTypeArchetypeType>(type.getPointer()) &&
 cast<ArchetypeType>(type.getPointer())->isRoot()) {
auto opaqueTypeDecl = type->castTo<OpaqueTypeArchetypeType>()->getDecl();

 llvm::SmallString<256> NamingDeclText;
 llvm::raw_svector_ostream OutNaming(NamingDeclText);
auto namingDecl = opaqueTypeDecl->getNamingDecl();
if (namingDecl->getDeclContext()->isTypeContext()) {
auto selfTy = namingDecl->getDeclContext()->getSelfInterfaceType();
 selfTy->print(OutNaming);
 OutNaming << '.';
 }
 namingDecl->getName().printPretty(OutNaming);

auto descriptiveKind = opaqueTypeDecl->getDescriptiveKind();

 Out << llvm::format(TypeFormatOpts->OpaqueResultFormatString.c_str(),
 type->getString(printOptions).c_str(),
Decl::getDescriptiveKindName(descriptiveKind).data(),
 NamingDeclText.c_str());

 } else {