Utils.cpp

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

#include"Utils.h"
#include"swift/AST/Expr.h"
#include"swift/AST/Stmt.h"

usingnamespaceswift;

/// Whether or not the given statement starts a new scope. Note that most
/// statements are handled by the \c BraceStmt check. The others listed are
/// a somewhat special case since they can also declare variables in their
/// condition.
boolswift::refactoring::asyncrefactorings::startsNewScope(Stmt *S) {
switch (S->getKind()) {
case StmtKind::Brace:
case StmtKind::If:
case StmtKind::While:
case StmtKind::ForEach:
case StmtKind::Case:
returntrue;
default:
returnfalse;
 }
}

/// A more aggressive variant of \c Expr::getReferencedDecl that also looks
/// through autoclosures created to pass the \c self parameter to a member funcs
ValueDecl *swift::refactoring::asyncrefactorings::
getReferencedDeclLookingThroughAutoclosures(const Expr *Fn) {
 Fn = Fn->getSemanticsProvidingExpr();
if (auto *DRE = dyn_cast<DeclRefExpr>(Fn))
return DRE->getDecl();
if (auto ApplyE = dyn_cast<SelfApplyExpr>(Fn))
returngetReferencedDeclLookingThroughAutoclosures(ApplyE->getFn());
if (auto *ACE = dyn_cast<AutoClosureExpr>(Fn)) {
if (auto *Unwrapped = ACE->getUnwrappedCurryThunkExpr())
returngetReferencedDeclLookingThroughAutoclosures(Unwrapped);
 }
returnnullptr;
}

FuncDecl *
swift::refactoring::asyncrefactorings::getUnderlyingFunc(const Expr *Fn) {
return dyn_cast_or_null<FuncDecl>(
getReferencedDeclLookingThroughAutoclosures(Fn));
}