Files
swift-mirror/include/swift/AST/ASTNode.h
Brent Royal-Gordon 99faa033fc [NFC] Standardize dump() methods in frontend
By convention, most structs and classes in the Swift compiler include a `dump()` method which prints debugging information. This method is meant to be called only from the debugger, but this means they’re often unused and may be eliminated from optimized binaries. On the other hand, some parts of the compiler call `dump()` methods directly despite them being intended as a pure debugging aid. clang supports attributes which can be used to avoid these problems, but they’re used very inconsistently across the compiler.

This commit adds `SWIFT_DEBUG_DUMP` and `SWIFT_DEBUG_DUMPER(<name>(<params>))` macros to declare `dump()` methods with the appropriate set of attributes and adopts this macro throughout the frontend. It does not pervasively adopt this macro in SILGen, SILOptimizer, or IRGen; these components use `dump()` methods in a different way where they’re frequently called from debugging code. Nor does it adopt it in runtime components like swiftRuntime and swiftReflection, because I’m a bit worried about size.

Despite the large number of files and lines affected, this change is NFC.
2019-10-31 18:37:42 -07:00

93 lines
2.6 KiB
C++

//===--- ASTNode.h - Swift Language ASTs ------------------------*- C++ -*-===//
//
// 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 defines the ASTNode, which is a union of Stmt, Expr, and Decl.
//
//===----------------------------------------------------------------------===//
#ifndef SWIFT_AST_AST_NODE_H
#define SWIFT_AST_AST_NODE_H
#include "llvm/ADT/PointerUnion.h"
#include "swift/Basic/Debug.h"
#include "swift/AST/TypeAlignments.h"
namespace llvm {
class raw_ostream;
}
namespace swift {
class Expr;
class Stmt;
class Decl;
class DeclContext;
class SourceLoc;
class SourceRange;
class ASTWalker;
enum class ExprKind : uint8_t;
enum class DeclKind : uint8_t;
enum class StmtKind;
struct ASTNode : public llvm::PointerUnion<Expr*, Stmt*, Decl*> {
// Inherit the constructors from PointerUnion.
using PointerUnion::PointerUnion;
SourceRange getSourceRange() const;
/// Return the location of the start of the statement.
SourceLoc getStartLoc() const;
/// Return the location of the end of the statement.
SourceLoc getEndLoc() const;
void walk(ASTWalker &Walker);
void walk(ASTWalker &&walker) { walk(walker); }
/// get the underlying entity as a decl context if it is one,
/// otherwise, return nullptr;
DeclContext *getAsDeclContext() const;
/// Provides some utilities to decide detailed node kind.
#define FUNC(T) bool is##T(T##Kind Kind) const;
FUNC(Stmt)
FUNC(Expr)
FUNC(Decl)
#undef FUNC
SWIFT_DEBUG_DUMP;
void dump(llvm::raw_ostream &OS, unsigned Indent = 0) const;
/// Whether the AST node is implicit.
bool isImplicit() const;
};
} // namespace swift
namespace llvm {
using swift::ASTNode;
template <> struct DenseMapInfo<ASTNode> {
static inline ASTNode getEmptyKey() {
return DenseMapInfo<swift::Expr *>::getEmptyKey();
}
static inline ASTNode getTombstoneKey() {
return DenseMapInfo<swift::Expr *>::getTombstoneKey();
}
static unsigned getHashValue(const ASTNode Val) {
return DenseMapInfo<void *>::getHashValue(Val.getOpaqueValue());
}
static bool isEqual(const ASTNode LHS, const ASTNode RHS) {
return LHS.getOpaqueValue() == RHS.getOpaqueValue();
}
};
}
#endif // LLVM_SWIFT_AST_AST_NODE_H