ASTWalker.cpp

//===--- ASTWalker.cpp - AST Traversal ------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 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 a recursive traversal of every node in an AST.
//
// It's important to update this traversal whenever the AST is
// changed, whether by adding a new node class or adding a new child
// to an existing node. Many walker implementations rely on being
// invoked with every node in the AST.
//
// Please follow these general rules when implementing traversal for
// a node:
//
// - Every node should be walked. If a node has both syntactic and
// semantic components, you should make sure you visit every node
// in both.
//
// - Nodes should only be walked once. So if a node has both
// syntactic and semantic components, but the type-checker builds
// the semantic components directly on top of the syntactic
// components, walking the semantic components will be sufficient
// to visit all the nodes in both.
//
// - Explicitly-written nodes should be walked in left-to-right
// syntactic order. The ordering of implicit nodes isn't
// particularly important.
//
// Note that semantic components will generally preserve the
// syntactic order of their children because doing something else
// could illegally change order of evaluation. This is why, for
// example, shuffling a TupleExpr creates a DestructureTupleExpr
// instead of just making a new TupleExpr with the elements in
// different order.
//
// - Sub-expressions and sub-statements should be replaceable.
// It's reasonable to expect that the replacement won't be
// completely unrelated to the original, but try to avoid making
// assumptions about the exact representation type. For example,
// assuming that a child expression is literally a TupleExpr may
// only be a reasonable assumption in an unchecked parse tree.
//
// - Avoid relying on the AST being type-checked or even
// well-formed during traversal.
//
//===----------------------------------------------------------------------===//

#include"swift/AST/ASTWalker.h"
#include"swift/AST/ASTVisitor.h"
#include"swift/AST/GenericParamList.h"
#include"swift/AST/ParameterList.h"
#include"swift/AST/PrettyStackTrace.h"
#include"swift/Basic/Assertions.h"
usingnamespaceswift;

voidASTWalker::anchor() {}

boolASTWalker::isDeclInMacroExpansion(Decl *decl) const {
return decl->isInMacroExpansionInContext();
}

namespace {

/// Traversal - This class implements a simple expression/statement
/// recursive traverser which queries a user-provided walker class
/// on every node in an AST.
classTraversal : publicASTVisitor<Traversal, Expr*, Stmt*,
/*Decl*/bool,
 Pattern *, /*TypeRepr*/bool>
{
friendclassASTVisitor<Traversal, Expr*, Stmt*, bool, Pattern*, bool>;
typedef ASTVisitor<Traversal, Expr*, Stmt*, bool, Pattern*, bool> inherited;

 ASTWalker &Walker;

/// RAII object that sets the parent of the walk context 
/// appropriately.
classSetParentRAII {
 ASTWalker &Walker;
decltype(ASTWalker::Parent) PriorParent;

public:
template<typename T>
SetParentRAII(ASTWalker &walker, T *newParent)
 : Walker(walker), PriorParent(walker.Parent) {
 walker.Parent = newParent;
 }

~SetParentRAII() {
 Walker.Parent = PriorParent;
 }
 };

 [[nodiscard]]
 Expr *visit(Expr *E) {
 SetParentRAII SetParent(Walker, E);
returninherited::visit(E);
 }

 [[nodiscard]]
 Stmt *visit(Stmt *S) {
 SetParentRAII SetParent(Walker, S);
returninherited::visit(S);
 }

 [[nodiscard]]
 Pattern *visit(Pattern *P) {
 SetParentRAII SetParent(Walker, P);
returninherited::visit(P);
 }

 [[nodiscard]]
boolvisit(Decl *D) {
 SetParentRAII SetParent(Walker, D);
returninherited::visit(D);
 }

 [[nodiscard]]
boolvisit(TypeRepr *T) {
 SetParentRAII SetParent(Walker, T);
returninherited::visit(T);
 }

 [[nodiscard]]
boolvisit(ParameterList *PL) {
returninherited::visit(PL);
 }

//===--------------------------------------------------------------------===//
// Decls
//===--------------------------------------------------------------------===//

 [[nodiscard]]
boolvisitGenericParamListIfNeeded(GenericContext *GC) {
// Must check this first in case extensions have not been bound yet
if (Walker.shouldWalkIntoGenericParams()) {
if (auto *params = GC->getParsedGenericParams()) {
if (doIt(params))
returntrue;
 }
returntrue;
 }
returnfalse;
 }

 [[nodiscard]]
boolvisitTrailingRequirements(GenericContext *GC) {
if (constauto Where = GC->getTrailingWhereClause()) {
for (auto &Req: Where->getRequirements())
if (doIt(Req))
returntrue;
 }
returnfalse;
 }

boolvisitImportDecl(ImportDecl *ID) {
returnfalse;
 }

boolvisitExtensionDecl(ExtensionDecl *ED) {
if (auto *typeRepr = ED->getExtendedTypeRepr())
if (doIt(typeRepr))
returntrue;
auto inheritedTypes = ED->getInherited();
for (auto i : inheritedTypes.getIndices()) {
if (auto *const TyR = inheritedTypes.getTypeRepr(i))
if (doIt(TyR))
returntrue;
 }
if (visitTrailingRequirements(ED))
returntrue;

for (Decl *M : ED->getMembers()) {
if (doIt(M))
returntrue;

if (Walker.shouldWalkAccessorsTheOldWay()) {
// Pretend that accessors share a parent with the storage.
//
// FIXME: Update existing ASTWalkers to deal with accessors appearing as
// children of the storage instead.
if (auto *ASD = dyn_cast<AbstractStorageDecl>(M)) {
for (auto AD : ASD->getAllAccessors()) {
if (doIt(AD))
returntrue;
 }
 }
 }
 }
returnfalse;
 }

boolvisitPatternBindingDecl(PatternBindingDecl *PBD) {
auto *singleVar = PBD->getSingleVar();

for (auto idx : range(PBD->getNumPatternEntries())) {
if (Pattern *Pat = doIt(PBD->getPattern(idx)))
 PBD->setPattern(idx, Pat);
else
returntrue;

if (!PBD->getInit(idx))
continue;

if (singleVar && singleVar->getOriginalWrappedProperty())
continue;

if (PBD->isInitializerSubsumed(idx) && singleVar &&
 singleVar->getAttrs().hasAttribute<LazyAttr>() &&
 Walker.getLazyInitializerWalkingBehavior() !=
 LazyInitializerWalking::InPatternBinding) {
break;
 }

#ifndef NDEBUG
 PrettyStackTraceDecl debugStack("walking into initializer for", PBD);
#endif
if (Expr *E2 = doIt(PBD->getInit(idx)))
 PBD->setInit(idx, E2);
else
returntrue;
 }
returnfalse;
 }

boolvisitEnumCaseDecl(EnumCaseDecl *ECD) {
// We'll visit the EnumElementDecls separately.
returnfalse;
 }

boolvisitTopLevelCodeDecl(TopLevelCodeDecl *TLCD) {
if (BraceStmt *S = cast_or_null<BraceStmt>(doIt(TLCD->getBody()))) {
 TLCD->setBody(S);
returnfalse;
 }
returntrue;
 }

boolvisitOperatorDecl(OperatorDecl *OD) {
returnfalse;
 }

boolvisitPrecedenceGroupDecl(PrecedenceGroupDecl *PGD) {
returnfalse;
 }

boolvisitTypeAliasDecl(TypeAliasDecl *TAD) {
bool WalkGenerics = visitGenericParamListIfNeeded(TAD);

if (auto typerepr = TAD->getUnderlyingTypeRepr())
if (doIt(typerepr))
returntrue;

return WalkGenerics && visitTrailingRequirements(TAD);
 }

boolvisitOpaqueTypeDecl(OpaqueTypeDecl *OTD) {
if (Walker.shouldWalkIntoGenericParams() && OTD->getGenericParams()) {
if (doIt(OTD->getGenericParams()))
returntrue;
 }
returnfalse;
 }

boolvisitGenericTypeParamDecl(GenericTypeParamDecl *GTPD) {
for (constauto &Inherit : GTPD->getInherited().getEntries()) {
if (auto *const TyR = Inherit.getTypeRepr())
if (doIt(TyR))
returntrue;
 }
returnfalse;
 }

boolvisitAssociatedTypeDecl(AssociatedTypeDecl *ATD) {
for (constauto &Inherit : ATD->getInherited().getEntries()) {
if (auto *const TyR = Inherit.getTypeRepr())
if (doIt(TyR))
returntrue;
 }
if (constauto DefaultTy = ATD->getDefaultDefinitionTypeRepr())
if (doIt(DefaultTy))
returntrue;

if (auto *WhereClause = ATD->getTrailingWhereClause()) {
for (auto &Req: WhereClause->getRequirements()) {
if (doIt(Req))
returntrue;
 }
 }
returnfalse;
 }

boolvisitNominalTypeDecl(NominalTypeDecl *NTD) {
#ifndef NDEBUG
 PrettyStackTraceDecl debugStack("walking into", NTD);
#endif

bool WalkGenerics = visitGenericParamListIfNeeded(NTD);

auto inheritedTypes = NTD->getInherited();
for (auto i : inheritedTypes.getIndices()) {
if (auto *const TyR = inheritedTypes.getTypeRepr(i))
if (doIt(TyR))
returntrue;
 }

// Visit requirements
if (WalkGenerics && visitTrailingRequirements(NTD))
returntrue;

for (Decl *Member : NTD->getMembers()) {
if (doIt(Member))
returntrue;

if (Walker.shouldWalkAccessorsTheOldWay()) {
// Pretend that accessors share a parent with the storage.
//
// FIXME: Update existing ASTWalkers to deal with accessors appearing as
// children of the storage instead.
if (auto *ASD = dyn_cast<AbstractStorageDecl>(Member)) {
for (auto AD : ASD->getAllAccessors()) {
if (doIt(AD))
returntrue;
 }
 }
 }
 }
returnfalse;
 }

boolvisitModuleDecl(ModuleDecl *MD) {
// TODO: should we recurse within the module?
returnfalse;
 }

boolvisitVarDecl(VarDecl *VD) {
if (!Walker.shouldWalkAccessorsTheOldWay()) {
for (auto *AD : VD->getAllAccessors())
if (doIt(AD))
returntrue;
 }

returnfalse;
 }

boolvisitParamDecl(ParamDecl *P) {
// Don't walk into the type if the decl is implicit, or if the type is
// implicit.
if (!P->isImplicit()) {
if (auto *repr = P->getTypeRepr()) {
if (doIt(repr)) {
returntrue;
 }
 }
 }
if (auto *E = P->getStructuralDefaultExpr()) {
auto res = doIt(E);
if (!res) returntrue;
 P->setDefaultExpr(res);
 }

if (!Walker.shouldWalkAccessorsTheOldWay()) {
for (auto *AD : P->getAllAccessors())
if (doIt(AD))
returntrue;
 }

returnfalse;
 }

boolvisitSubscriptDecl(SubscriptDecl *SD) {
bool WalkGenerics = visitGenericParamListIfNeeded(SD);

if (visit(SD->getIndices()))
returntrue;

if (auto *const TyR = SD->getElementTypeRepr())
if (doIt(TyR))
returntrue;

// Visit trailing requirements
if (WalkGenerics && visitTrailingRequirements(SD))
returntrue;

if (!Walker.shouldWalkAccessorsTheOldWay()) {
for (auto *AD : SD->getAllAccessors())
if (doIt(AD))
returntrue;
 }

returnfalse;
 }

boolvisitMissingDecl(MissingDecl *missing) {
returnfalse;
 }

boolvisitMissingMemberDecl(MissingMemberDecl *MMD) {
returnfalse;
 }

boolvisitMacroDecl(MacroDecl *MD) {
bool WalkGenerics = visitGenericParamListIfNeeded(MD);

if (MD->parameterList && visit(MD->parameterList))
returntrue;

if (auto resultTypeRepr = MD->resultType.getTypeRepr()) {
if (doIt(resultTypeRepr))
returntrue;
 }

if (auto def = MD->definition) {
// Don't walk into unchecked definitions.
if (auto expansion = dyn_cast<MacroExpansionExpr>(def)) {
if (!expansion->getType().isNull() ||
 Walker.shouldWalkIntoUncheckedMacroDefinitions()) {
if (auto newDef = doIt(def))
 MD->definition = newDef;
else
returntrue;
 }
 }
 }

// Visit trailing requirements
if (WalkGenerics && visitTrailingRequirements(MD))
returntrue;

returnfalse;
 }

boolvisitFreestandingMacroArgs(FreestandingMacroExpansion *ME) {
for (TypeRepr *genArg : ME->getGenericArgs()) {
if (doIt(genArg))
returntrue;
 }

if (ME->getArgs()) {
 ArgumentList *args = doIt(ME->getArgs());
if (!args)
returntrue;
 ME->setArgs(args);
 }

returnfalse;
 }

boolvisitMacroExpansionDecl(MacroExpansionDecl *MED) {
#ifndef NDEBUG
 PrettyStackTraceDecl debugStack("walking into", MED);
#endif

bool shouldWalkArguments, shouldWalkExpansion;
std::tie(shouldWalkArguments, shouldWalkExpansion) =
 Walker.shouldWalkMacroArgumentsAndExpansion();

if (shouldWalkArguments && visitFreestandingMacroArgs(MED))
returntrue;

bool alreadyFailed = false;
if (shouldWalkExpansion) {
 MED->forEachExpandedNode([&](ASTNode expandedNode) {
if (alreadyFailed) return;

if (auto *expr = expandedNode.dyn_cast<Expr *>()) {
 alreadyFailed = doIt(expr) == nullptr;
 } elseif (auto *stmt = expandedNode.dyn_cast<Stmt *>()) {
 alreadyFailed = doIt(stmt) == nullptr;
 } else {
auto decl = expandedNode.get<Decl *>();
if (!isa<VarDecl>(decl))
 alreadyFailed = doIt(decl);
 }
 });
 }
return alreadyFailed;
 }

boolvisitAbstractFunctionDecl(AbstractFunctionDecl *AFD) {
#ifndef NDEBUG
 PrettyStackTraceDecl debugStack("walking into body of", AFD);
#endif

bool WalkGenerics =
// accessor generics are visited from the storage decl
 !isa<AccessorDecl>(AFD) && visitGenericParamListIfNeeded(AFD);

if (auto *PD = AFD->getImplicitSelfDecl(/*createIfNeeded=*/false)) {
if (visit(PD))
returntrue;
 }
if (visit(AFD->getParameters()))
returntrue;

if (auto *const ThrownTyR = AFD->getThrownTypeRepr()) {
if (doIt(ThrownTyR))
returntrue;
 }

if (auto *FD = dyn_cast<FuncDecl>(AFD)) {
if (!isa<AccessorDecl>(FD))
if (auto *const TyR = FD->getResultTypeRepr())
if (doIt(TyR))
returntrue;
 }

// Visit trailing requirements
if (WalkGenerics && visitTrailingRequirements(AFD))
returntrue;

if (AFD->getBody(/*canSynthesize=*/false)) {
 AbstractFunctionDecl::BodyKind PreservedKind = AFD->getBodyKind();
if (BraceStmt *S = cast_or_null<BraceStmt>(doIt(AFD->getBody())))
 AFD->setBody(S, PreservedKind);
else
returntrue;
 }

if (auto ctor = dyn_cast<ConstructorDecl>(AFD)) {
if (auto superInit = ctor->getSuperInitCall()) {
if ((superInit = doIt(superInit)))
 ctor->setSuperInitCall(superInit);
else
returntrue;
 }
 }

returnfalse;
 }

boolvisitEnumElementDecl(EnumElementDecl *ED) {
if (auto *PL = ED->getParameterList()) {
if (visit(PL))
returntrue;
 }

if (auto *rawLiteralExpr = ED->getRawValueUnchecked()) {
if (Expr *newRawExpr = doIt(rawLiteralExpr)) {
auto *newLiteralRawExpr = cast<LiteralExpr>(newRawExpr);
 ED->setRawValueExpr(newLiteralRawExpr);
 } else {
returntrue;
 }
 }
returnfalse;
 }

//===--------------------------------------------------------------------===//
// Exprs
//===--------------------------------------------------------------------===//

// A macro for handling the "semantic expressions" that are common
// on sugared expression nodes like string interpolation. The
// semantic expression is set up by type-checking to include all the
// other children as sub-expressions, so if it exists, we should
// just bypass the rest of the visitation.
#defineHANDLE_SEMANTIC_EXPR(NODE) \
do { \
if (Expr *_semanticExpr = NODE->getSemanticExpr()) { \
if ((_semanticExpr = doIt(_semanticExpr))) { \
 NODE->setSemanticExpr(_semanticExpr); \
 } else { \
returnnullptr; \
 } \
return NODE; \
 } \
 } while (false)

 Expr *visitErrorExpr(ErrorExpr *E) { return E; }
 Expr *visitCodeCompletionExpr(CodeCompletionExpr *E) {
if (Expr *baseExpr = E->getBase()) {
 Expr *newBaseExpr = doIt(baseExpr);
if (!newBaseExpr)
returnnullptr;
 E->setBase(newBaseExpr);
 }
return E;
 }
 Expr *visitLiteralExpr(LiteralExpr *E) { return E; }
 Expr *visitDiscardAssignmentExpr(DiscardAssignmentExpr *E) { return E; }
 Expr *visitTypeExpr(TypeExpr *E) {
if (!E->isImplicit())
if (auto *typerepr = E->getTypeRepr())
if (doIt(typerepr))
returnnullptr;

return E;
 }
 Expr *visitSuperRefExpr(SuperRefExpr *E) { return E; }
 Expr *visitOtherConstructorDeclRefExpr(OtherConstructorDeclRefExpr *E) {
return E;
 }

 Expr *visitOverloadedDeclRefExpr(OverloadedDeclRefExpr *E) { return E; }
 Expr *visitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *E) { return E; }

 Expr *visitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { return E; }

 Expr *visitOpaqueValueExpr(OpaqueValueExpr *E) { return E; }

 Expr *visitPropertyWrapperValuePlaceholderExpr(
 PropertyWrapperValuePlaceholderExpr *E) {
if (E->getOpaqueValuePlaceholder()) {
if (auto *placeholder = doIt(E->getOpaqueValuePlaceholder()))
 E->setOpaqueValuePlaceholder(dyn_cast<OpaqueValueExpr>(placeholder));
else
returnnullptr;
 }

if (Walker.shouldWalkIntoPropertyWrapperPlaceholderValue()) {
if (E->getOriginalWrappedValue()) {
if (auto *newValue = doIt(E->getOriginalWrappedValue()))
 E->setOriginalWrappedValue(newValue);
else
returnnullptr;
 }
 }

return E;
 }

 Expr *visitAppliedPropertyWrapperExpr(AppliedPropertyWrapperExpr *E) {
if (auto *newValue = doIt(E->getValue())) {
 E->setValue(newValue);
 } else {
returnnullptr;
 }

return E;
 }

 Expr *visitDefaultArgumentExpr(DefaultArgumentExpr *E) { return E; }

 Expr *visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E) {
if (auto oldAppendingExpr = E->getAppendingExpr()) {
if (auto appendingExpr = doIt(oldAppendingExpr))
 E->setAppendingExpr(dyn_cast<TapExpr>(appendingExpr));
else
returnnullptr;
 }
return E;
 }

 Expr *visitObjectLiteralExpr(ObjectLiteralExpr *E) {
if (auto *args = doIt(E->getArgs())) {
 E->setArgs(args);
 } else {
returnnullptr;
 }
return E;
 }

 Expr *visitCollectionExpr(CollectionExpr *E) {
for (auto &elt : E->getElements())
if (Expr *Sub = doIt(elt))
 elt = Sub;
else
returnnullptr;
return E;
 }

 Expr *visitDeclRefExpr(DeclRefExpr *E) {
return E;
 }

 Expr *visitMemberRefExpr(MemberRefExpr *E) {
if (Expr *Base = doIt(E->getBase())) {
 E->setBase(Base);
return E;
 }
returnnullptr;
 }

 Expr *visitDynamicMemberRefExpr(DynamicMemberRefExpr *E) {
if (Expr *Base = doIt(E->getBase())) {
 E->setBase(Base);
return E;
 }

returnnullptr;
 }

 Expr *visitAnyTryExpr(AnyTryExpr *E) {
if (Expr *subExpr = doIt(E->getSubExpr())) {
 E->setSubExpr(subExpr);
return E;
 }
returnnullptr;
 }

 Expr *visitIdentityExpr(IdentityExpr *E) {
if (Expr *subExpr = doIt(E->getSubExpr())) {
 E->setSubExpr(subExpr);
return E;
 }
returnnullptr;
 }

 Expr *visitCopyExpr(CopyExpr *E) {
if (Expr *subExpr = doIt(E->getSubExpr())) {
 E->setSubExpr(subExpr);
return E;
 }
returnnullptr;
 }

 Expr *visitConsumeExpr(ConsumeExpr *E) {
if (Expr *subExpr = doIt(E->getSubExpr())) {
 E->setSubExpr(subExpr);
return E;
 }
returnnullptr;
 }

 Expr *visitTupleExpr(TupleExpr *E) {
for (unsigned i = 0, e = E->getNumElements(); i != e; ++i)
if (E->getElement(i)) {
if (Expr *Elt = doIt(E->getElement(i)))
 E->setElement(i, Elt);
else
returnnullptr;
 }
return E;
 }
 Expr *visitSubscriptExpr(SubscriptExpr *E) {
if (Expr *Base = doIt(E->getBase()))
 E->setBase(Base);
else
returnnullptr;

if (auto *args = doIt(E->getArgs())) {
 E->setArgs(args);
 } else {
returnnullptr;
 }

return E;
 }
 Expr *visitKeyPathApplicationExpr(KeyPathApplicationExpr *E) {
if (Expr *Base = doIt(E->getBase()))
 E->setBase(Base);
else
returnnullptr;

if (Expr *KeyPath = doIt(E->getKeyPath()))
 E->setKeyPath(KeyPath);
else
returnnullptr;

return E;
 }
 Expr *visitDynamicSubscriptExpr(DynamicSubscriptExpr *E) {
if (Expr *Base = doIt(E->getBase()))
 E->setBase(Base);
else
returnnullptr;

if (auto *args = doIt(E->getArgs())) {
 E->setArgs(args);
 } else {
returnnullptr;
 }

return E;
 }
 Expr *visitUnresolvedDotExpr(UnresolvedDotExpr *E) {
if (!E->getBase())
return E;

if (Expr *E2 = doIt(E->getBase())) {
 E->setBase(E2);
return E;
 }
returnnullptr;
 }
 Expr *visitUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *E) {
if (!E->getSubExpr())
return E;

if (Expr *Sub = doIt(E->getSubExpr()))
 E->setSubExpr(Sub);
else
returnnullptr;

for (auto &TyLoc : E->getUnresolvedParams()) {
if (doIt(TyLoc))
returnnullptr;
 }

return E;
 }

 Expr *visitTupleElementExpr(TupleElementExpr *E) {
if (Expr *E2 = doIt(E->getBase())) {
 E->setBase(E2);
return E;
 }
returnnullptr;
 }

 Expr *visitImplicitConversionExpr(ImplicitConversionExpr *E) {
if (Expr *E2 = doIt(E->getSubExpr())) {
 E->setSubExpr(E2);
return E;
 }
returnnullptr;
 }

 Expr *visitErasureExpr(ErasureExpr *E) {
if (Expr *E2 = doIt(E->getSubExpr())) {
 E->setSubExpr(E2);
 } else {
returnnullptr;
 }

for (unsigned i = 0; i < E->getArgumentConversions().size(); ++i) {
constauto &conv = E->getArgumentConversions()[i];
autokConv = conv.Conversion;
if (!kConv) {
returnnullptr;
 } elseif (Expr *E2 = doIt(kConv)) {
 E->setArgumentConversion(i, {conv.OrigValue, E2});
 } else {
returnnullptr;
 }
 }

return E;
 }

 Expr *visitCollectionUpcastConversionExpr(CollectionUpcastConversionExpr *E) {
if (Expr *E2 = doIt(E->getSubExpr())) {
 E->setSubExpr(E2);
 } else {
returnnullptr;
 }

if (auto &keyConv = E->getKeyConversion()) {
autokConv = keyConv.Conversion;
if (!kConv) {
returnnullptr;
 } elseif (Expr *E2 = doIt(kConv)) {
 E->setKeyConversion({keyConv.OrigValue, E2});
 } else {
returnnullptr;
 }
 }

if (auto &valueConv = E->getValueConversion()) {
auto vConv = valueConv.Conversion;
if (!vConv) {
returnnullptr;
 } elseif (Expr *E2 = doIt(vConv)) {
 E->setValueConversion({valueConv.OrigValue, E2});
 } else {
returnnullptr;
 }
 }

return E;
 }

 Expr *visitDestructureTupleExpr(DestructureTupleExpr *E) {
if (auto *src = doIt(E->getSubExpr())) {
 E->setSubExpr(src);
 } else {
returnnullptr;
 }

if (auto *dst = doIt(E->getResultExpr())) {
 E->setResultExpr(dst);
 } else {
returnnullptr;
 }

return E;
 }

 Expr *visitTryExpr(TryExpr *E) {
if (Expr *E2 = doIt(E->getSubExpr())) {
 E->setSubExpr(E2);
return E;
 }
returnnullptr;
 }

 Expr *visitForceTryExpr(ForceTryExpr *E) {
if (Expr *E2 = doIt(E->getSubExpr())) {
 E->setSubExpr(E2);
return E;
 }
returnnullptr;
 }

 Expr *visitOptionalTryExpr(OptionalTryExpr *E) {
if (Expr *E2 = doIt(E->getSubExpr())) {
 E->setSubExpr(E2);
return E;
 }
returnnullptr;
 }

 Expr *visitInOutExpr(InOutExpr *E) {
if (Expr *E2 = doIt(E->getSubExpr())) {
 E->setSubExpr(E2);
return E;
 }
returnnullptr;
 }

 Expr *visitVarargExpansionExpr(VarargExpansionExpr *E) {
if (Expr *E2 = doIt(E->getSubExpr())) {
 E->setSubExpr(E2);
return E;
 }
returnnullptr;
 }

 Expr *visitPackExpansionExpr(PackExpansionExpr *E) {
if (Expr *pattern = doIt(E->getPatternExpr())) {
 E->setPatternExpr(pattern);
return E;
 }
returnnullptr;
 }

 Expr *visitPackElementExpr(PackElementExpr *E) {
if (Expr *pattern = doIt(E->getPackRefExpr())) {
 E->setPackRefExpr(pattern);
return E;
 }
returnnullptr;
 }

 Expr *visitMaterializePackExpr(MaterializePackExpr *E) {
if (Expr *fromExpr = doIt(E->getFromExpr())) {
 E->setFromExpr(fromExpr);
return E;
 }
returnnullptr;
 }

 Expr *visitSequenceExpr(SequenceExpr *E) {
// After folding, the SequenceExpr elements can contain a broken mess of
// partially folded and/or duplicate nodes (since folding can mutate nodes
// in-place). We remove the SequenceExpr from the AST after folding, but
// there's still a period of time during pre-checking when it's still in the
// AST. To avoid issues for e.g ASTScope and availability scope
// construction, only walk the folded expression if we have it.
if (auto *foldedExpr = E->getFoldedExpr()) {
auto *newExpr = doIt(foldedExpr);
if (!newExpr)
returnnullptr;

 E->setFoldedExpr(newExpr);
return E;
 }

for (unsigned i = 0, e = E->getNumElements(); i != e; ++i)
if (Expr *Elt = doIt(E->getElement(i)))
 E->setElement(i, Elt);
else
returnnullptr;
return E;
 }

 Expr *visitDynamicTypeExpr(DynamicTypeExpr *E) {
 Expr *base = E->getBase();
if ((base = doIt(base)))
 E->setBase(base);
else
returnnullptr;

return E;
 }

 Expr *visitCaptureListExpr(CaptureListExpr *expr) {
for (auto c : expr->getCaptureList()) {
if (doIt(c.PBD))
returnnullptr;
 }

 AbstractClosureExpr *body = expr->getClosureBody();
if ((body = cast_or_null<AbstractClosureExpr>(doIt(body))))
 expr->setClosureBody(body);
else
returnnullptr;
return expr;
 }

 Expr *visitClosureExpr(ClosureExpr *expr) {