ASTNode.cpp

//===--- ASTNode.cpp - Swift Language ASTs --------------------------------===//
//
// 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 the ASTNode, which is a union of Stmt, Expr, and Decl.
//
//===----------------------------------------------------------------------===//

#include"swift/AST/ASTNode.h"
#include"swift/AST/Decl.h"
#include"swift/AST/Expr.h"
#include"swift/AST/Stmt.h"
#include"swift/AST/Pattern.h"
#include"swift/AST/TypeRepr.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/SourceLoc.h"
#include"swift/Parse/Token.h"

usingnamespaceswift;

SourceRange ASTNode::getSourceRange() const {
if (constauto *E = this->dyn_cast<Expr*>())
return E->getSourceRange();
if (constauto *S = this->dyn_cast<Stmt*>())
return S->getSourceRange();
if (constauto *D = this->dyn_cast<Decl*>())
return D->getSourceRange();
if (constauto *P = this->dyn_cast<Pattern*>())
return P->getSourceRange();
if (constauto *T = this->dyn_cast<TypeRepr *>())
return T->getSourceRange();
if (constauto *C = this->dyn_cast<StmtConditionElement *>())
return C->getSourceRange();
if (constauto *I = this->dyn_cast<CaseLabelItem *>()) {
return I->getSourceRange();
 }
assert(!isNull() && "Null ASTNode doesn't have a source range");
llvm_unreachable("unsupported AST node");
}

/// Return the location of the start of the statement.
SourceLoc ASTNode::getStartLoc() const {
returngetSourceRange().Start;
}

/// Return the location of the end of the statement.
SourceLoc ASTNode::getEndLoc() const {
returngetSourceRange().End;
}

DeclContext *ASTNode::getAsDeclContext() const {
if (auto *E = this->dyn_cast<Expr*>()) {
if (isa<AbstractClosureExpr>(E))
returnstatic_cast<AbstractClosureExpr*>(E);
 } elseif (is<Stmt*>()) {
returnnullptr;
 } elseif (auto *D = this->dyn_cast<Decl*>()) {
if (isa<DeclContext>(D))
return cast<DeclContext>(D);
 } elseif (getOpaqueValue())
llvm_unreachable("unsupported AST node");
returnnullptr;
}

boolASTNode::isImplicit() const {
if (constauto *E = this->dyn_cast<Expr*>())
return E->isImplicit();
if (constauto *S = this->dyn_cast<Stmt*>())
return S->isImplicit();
if (constauto *D = this->dyn_cast<Decl*>())
return D->isImplicit();
if (constauto *P = this->dyn_cast<Pattern*>())
return P->isImplicit();
if (this->is<TypeRepr *>())
returnfalse;
if (this->is<StmtConditionElement *>())
returnfalse;
if (this->is<CaseLabelItem *>())
returnfalse;
llvm_unreachable("unsupported AST node");
}

voidASTNode::walk(ASTWalker &Walker) {
if (auto *E = this->dyn_cast<Expr*>())
 E->walk(Walker);
elseif (auto *S = this->dyn_cast<Stmt*>())
 S->walk(Walker);
elseif (auto *D = this->dyn_cast<Decl*>())
 D->walk(Walker);
elseif (auto *P = this->dyn_cast<Pattern*>())
 P->walk(Walker);
elseif (auto *T = this->dyn_cast<TypeRepr*>())
 T->walk(Walker);
elseif (auto *C = this->dyn_cast<StmtConditionElement *>())
 C->walk(Walker);
elseif (auto *I = this->dyn_cast<CaseLabelItem *>()) {
if (auto *P = I->getPattern())
 P->walk(Walker);

if (auto *G = I->getGuardExpr())
 G->walk(Walker);
 } else
llvm_unreachable("unsupported AST node");
}

voidASTNode::dump(raw_ostream &OS, unsigned Indent) const {
if (isNull())
 OS << "(null)";
elseif (auto S = dyn_cast<Stmt*>())
 S->dump(OS, /*context=*/nullptr, Indent);
elseif (auto E = dyn_cast<Expr*>())
 E->dump(OS, Indent);
elseif (auto D = dyn_cast<Decl*>())
 D->dump(OS, Indent);
elseif (auto P = dyn_cast<Pattern*>())
 P->dump(OS, Indent);
elseif (auto T = dyn_cast<TypeRepr*>())
 T->print(OS);
elseif (is<StmtConditionElement *>())
 OS.indent(Indent) << "(statement condition)";
elseif (is<CaseLabelItem *>()) {
 OS.indent(Indent) << "(case label item)";
 } else
llvm_unreachable("unsupported AST node");
}

voidASTNode::dump() const {
dump(llvm::errs());
}

StringRef swift::getTokenText(tok kind) {
switch(kind) {
#defineKEYWORD(KW) case tok::kw_##KW: return #KW;
#definePOUND_KEYWORD(KW) case tok::pound_##KW: return"#"#KW;
#definePUNCTUATOR(PUN, TEXT) case tok::PUN: return TEXT;
#include"swift/AST/TokenKinds.def"
default: returnStringRef();
 }
}

#defineFUNC(T) \
bool ASTNode::is##T(T##Kind Kind) const { \
if (!is<T*>()) \
returnfalse; \
return get<T*>()->getKind() == Kind; \
}
FUNC(Stmt)
FUNC(Expr)
FUNC(Decl)
FUNC(Pattern)
#undef FUNC