diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h index 29941aad091e..319447335c50 100644 --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -182,6 +182,11 @@ public: void dump(const char *s) const; void dump() const; + /// viewInheritance - Renders and displays an inheritance diagram + /// for a C++ class and all of its base classes (transitively) using + /// GraphViz. Only available in debug builds. + void viewInheritance(ASTContext& Context); + void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddPointer(getAsOpaquePtr()); } diff --git a/clang/include/clang/AST/TypeOrdering.h b/clang/include/clang/AST/TypeOrdering.h new file mode 100644 index 000000000000..38e7f76ac43e --- /dev/null +++ b/clang/include/clang/AST/TypeOrdering.h @@ -0,0 +1,34 @@ +//===-------------- TypeOrdering.h - Total ordering for types -------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file provides a function object that gives a total ordering +// on QualType values, so that they can be sorted, used in std::maps +// and std::sets, and so on. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_TYPE_ORDERING_H +#define LLVM_CLANG_TYPE_ORDERING_H + +#include "clang/AST/Type.h" +#include + +namespace clang { + +/// QualTypeOrdering - Function object that provides a total ordering +/// on QualType values. +struct QualTypeOrdering : std::binary_function { + bool operator()(QualType T1, QualType T2) { + return std::less()(T1.getAsOpaquePtr(), T2.getAsOpaquePtr()); + } +}; + +} + +#endif diff --git a/clang/lib/AST/InheritViz.cpp b/clang/lib/AST/InheritViz.cpp new file mode 100644 index 000000000000..bb6e870498cb --- /dev/null +++ b/clang/lib/AST/InheritViz.cpp @@ -0,0 +1,265 @@ +//===- InheritViz.cpp - Graphviz visualization for inheritance --*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements CXXRecordDecl::viewInheritance, which +// generates a GraphViz DOT file that depicts the class inheritance +// diagram and then calls Graphviz/dot+gv on it. +// +//===----------------------------------------------------------------------===// + +#include "clang/AST/ASTContext.h" +#include "clang/AST/Decl.h" +#include "clang/AST/DeclCXX.h" +#include "clang/AST/TypeOrdering.h" +#include "llvm/ADT/GraphTraits.h" +#include "llvm/ADT/DepthFirstIterator.h" +#include "llvm/Support/GraphWriter.h" +#include +#include +#include +#include + +using namespace llvm; + +namespace clang { + /// InheritanceGraphOutEdgeIterator - Enumerates the base classes + /// based on base specifiers. + class InheritanceGraphOutEdgeIterator { + const CXXBaseSpecifier *Base; + + public: + typedef const RecordType *value_type; + typedef const RecordType *reference; + typedef const RecordType **pointer; + typedef ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + InheritanceGraphOutEdgeIterator(const CXXBaseSpecifier* Base = 0) + : Base(Base) { } + + reference operator*() const { + assert(Base->getType()->getAsRecordType()); + return Base->getType()->getAsRecordType(); + } + + pointer operator->() const { return 0; } + + InheritanceGraphOutEdgeIterator& operator++() { + ++Base; + return *this; + } + + InheritanceGraphOutEdgeIterator operator++(int) { + return InheritanceGraphOutEdgeIterator(Base++); + } + + friend bool operator==(InheritanceGraphOutEdgeIterator const& x, + InheritanceGraphOutEdgeIterator const& y) { + return x.Base == y.Base; + } + + friend bool operator!=(InheritanceGraphOutEdgeIterator const& x, + InheritanceGraphOutEdgeIterator const& y) { + return x.Base != y.Base; + } + }; + +} // end namespace clang + +namespace llvm { + template<> struct GraphTraits { + typedef const clang::RecordType NodeType; + typedef clang::InheritanceGraphOutEdgeIterator ChildIteratorType; + typedef llvm::df_iterator nodes_iterator; + + static const NodeType *getEntryNode(const clang::RecordType *Type) { + return Type; + } + + static ChildIteratorType child_begin(const clang::RecordType *Type) { + const clang::CXXRecordDecl *Decl + = dyn_cast_or_null(Type->getDecl()); + if (Decl->getNumBases() == 0) + return clang::InheritanceGraphOutEdgeIterator(0); + else + return clang::InheritanceGraphOutEdgeIterator(Decl->getBase(0)); + } + static ChildIteratorType child_end(const clang::RecordType *Type) { + const clang::CXXRecordDecl *Decl + = dyn_cast_or_null(Type->getDecl()); + if (Decl->getNumBases() == 0) + return clang::InheritanceGraphOutEdgeIterator(0); + else + return clang::InheritanceGraphOutEdgeIterator(Decl->getBase(0) + + Decl->getNumBases()); + } + + static nodes_iterator nodes_begin(const clang::RecordType *Type) { + return df_begin(Type); + } + + static nodes_iterator nodes_end(const clang::RecordType *Type) { + return df_end(Type); + } + }; +} + +namespace clang { + +/// InheritanceHierarchyWriter - Helper class that writes out a +/// GraphViz file that diagrams the inheritance hierarchy starting at +/// a given C++ class type. Note that we do not use LLVM's +/// GraphWriter, because the interface does not permit us to properly +/// differentiate between uses of types as virtual bases +/// vs. non-virtual bases. +class InheritanceHierarchyWriter { + ASTContext& Context; + std::ostream &Out; + std::map DirectBaseCount; + std::set KnownVirtualBases; + +public: + InheritanceHierarchyWriter(ASTContext& Context, std::ostream& Out) + : Context(Context), Out(Out) { } + + void WriteGraph(QualType Type) { + Out << "digraph \"" << DOT::EscapeString(Type.getAsString()) << "\" {\n"; + WriteNode(Type, false); + Out << "}\n"; + } + +protected: + /// WriteNode - Write out the description of node in the inheritance + /// diagram, which may be a base class or it may be the root node. + void WriteNode(QualType Type, bool FromVirtual); + + /// WriteNodeReference - Write out a reference to the given node, + /// using a unique identifier for each direct base and for the + /// (only) virtual base. + std::ostream& WriteNodeReference(QualType Type, bool FromVirtual); +}; + +void InheritanceHierarchyWriter::WriteNode(QualType Type, bool FromVirtual) { + QualType CanonType = Context.getCanonicalType(Type); + + if (FromVirtual) { + if (KnownVirtualBases.find(CanonType) != KnownVirtualBases.end()) + return; + + // We haven't seen this virtual base before, so display it and + // its bases. + KnownVirtualBases.insert(CanonType); + } + + // Declare the node itself. + Out << " "; + WriteNodeReference(Type, FromVirtual); + + // Give the node a label based on the name of the class. + std::string TypeName = Type.getAsString(); + Out << " [ shape=\"box\", label=\"" << DOT::EscapeString(TypeName); + + // If the name of the class was a typedef or something different + // from the "real" class name, show the real class name in + // parentheses so we don't confuse ourselves. + if (TypeName != CanonType.getAsString()) { + Out << "\\n(" << CanonType.getAsString() << ")"; + } + + // Finished describing the node. + Out << " \"];\n"; + + // Display the base classes. + const CXXRecordDecl *Decl + = static_cast(Type->getAsRecordType()->getDecl()); + for (unsigned idx = 0; idx < Decl->getNumBases(); ++idx) { + const CXXBaseSpecifier *Base = Decl->getBase(idx); + QualType CanonBaseType = Context.getCanonicalType(Base->getType()); + + // If this is not virtual inheritance, bump the direct base + // count for the type. + if (!Base->isVirtual()) + ++DirectBaseCount[CanonBaseType]; + + // Write out the node (if we need to). + WriteNode(Base->getType(), Base->isVirtual()); + + // Write out the edge. + Out << " "; + WriteNodeReference(Type, FromVirtual); + Out << " -> "; + WriteNodeReference(Base->getType(), Base->isVirtual()); + + // Write out edge attributes to show the kind of inheritance. + if (Base->isVirtual()) { + Out << " [ style=\"dashed\" ]"; + } + Out << ";"; + } +} + +/// WriteNodeReference - Write out a reference to the given node, +/// using a unique identifier for each direct base and for the +/// (only) virtual base. +std::ostream& +InheritanceHierarchyWriter::WriteNodeReference(QualType Type, + bool FromVirtual) { + QualType CanonType = Context.getCanonicalType(Type); + + Out << "Class_" << CanonType.getAsOpaquePtr(); + if (!FromVirtual) + Out << "_" << DirectBaseCount[CanonType]; + return Out; +} + +/// viewInheritance - Display the inheritance hierarchy of this C++ +/// class using GraphViz. +void QualType::viewInheritance(ASTContext& Context) { + if (!(*this)->getAsRecordType()) { + cerr << "Type " << getAsString() << " is not a C++ class type.\n"; + } +#ifndef NDEBUG + // std::string Title = "Inheritance graph for " + getAsString(); + // llvm::ViewGraph((*this)->getAsRecordType(), Title.c_str()); + std::string ErrMsg; + sys::Path Filename = sys::Path::GetTemporaryDirectory(&ErrMsg); + if (Filename.isEmpty()) { + cerr << "Error: " << ErrMsg << "\n"; + return; + } + Filename.appendComponent(getAsString() + ".dot"); + if (Filename.makeUnique(true,&ErrMsg)) { + cerr << "Error: " << ErrMsg << "\n"; + return; + } + + cerr << "Writing '" << Filename << "'... "; + + std::ofstream O(Filename.c_str()); + + if (O.good()) { + InheritanceHierarchyWriter Writer(Context, O); + Writer.WriteGraph(*this); + cerr << " done. \n"; + + O.close(); + + // Display the graph + DisplayGraph(Filename); + } else { + cerr << "error opening file for writing!\n"; + Filename.clear(); + } +#else + cerr << "QualType::viewInheritance is only available in debug " + << "builds on systems with Graphviz or gv!\n"; +#endif +} + +} diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 7c4444fab611..f17875b98670 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -14,13 +14,13 @@ #include "Sema.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" +#include "clang/AST/TypeOrdering.h" #include "clang/AST/StmtVisitor.h" #include "clang/Lex/Preprocessor.h" #include "clang/Basic/Diagnostic.h" #include "clang/Parse/DeclSpec.h" #include "llvm/Support/Compiler.h" #include // for std::equal -#include #include using namespace clang; @@ -306,14 +306,6 @@ Sema::ActOnBaseSpecifier(DeclTy *classdecl, SourceRange SpecifierRange, return BS; } -/// QualTypeOrder - Function object that provides a total ordering on -/// QualType values. -struct QualTypeOrdering : std::binary_function { - bool operator()(QualType T1, QualType T2) { - return std::less()(T1.getAsOpaquePtr(), T2.getAsOpaquePtr()); - } -}; - /// ActOnBaseSpecifiers - Attach the given base specifiers to the /// class, after checking whether there are any duplicate base /// classes.