clang  6.0.0svn
InheritViz.cpp
Go to the documentation of this file.
1 //===- InheritViz.cpp - Graphviz visualization for inheritance --*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements CXXRecordDecl::viewInheritance, which
11 // generates a GraphViz DOT file that depicts the class inheritance
12 // diagram and then calls Graphviz/dot+gv on it.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/TypeOrdering.h"
20 #include "llvm/Support/FileSystem.h"
21 #include "llvm/Support/GraphWriter.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include <map>
24 #include <set>
25 using namespace clang;
26 
27 namespace {
28 /// InheritanceHierarchyWriter - Helper class that writes out a
29 /// GraphViz file that diagrams the inheritance hierarchy starting at
30 /// a given C++ class type. Note that we do not use LLVM's
31 /// GraphWriter, because the interface does not permit us to properly
32 /// differentiate between uses of types as virtual bases
33 /// vs. non-virtual bases.
34 class InheritanceHierarchyWriter {
35  ASTContext& Context;
36  raw_ostream &Out;
37  std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
38  std::set<QualType, QualTypeOrdering> KnownVirtualBases;
39 
40 public:
41  InheritanceHierarchyWriter(ASTContext& Context, raw_ostream& Out)
42  : Context(Context), Out(Out) { }
43 
44  void WriteGraph(QualType Type) {
45  Out << "digraph \"" << llvm::DOT::EscapeString(Type.getAsString())
46  << "\" {\n";
47  WriteNode(Type, false);
48  Out << "}\n";
49  }
50 
51 protected:
52  /// WriteNode - Write out the description of node in the inheritance
53  /// diagram, which may be a base class or it may be the root node.
54  void WriteNode(QualType Type, bool FromVirtual);
55 
56  /// WriteNodeReference - Write out a reference to the given node,
57  /// using a unique identifier for each direct base and for the
58  /// (only) virtual base.
59  raw_ostream& WriteNodeReference(QualType Type, bool FromVirtual);
60 };
61 } // namespace
62 
63 void InheritanceHierarchyWriter::WriteNode(QualType Type, bool FromVirtual) {
64  QualType CanonType = Context.getCanonicalType(Type);
65 
66  if (FromVirtual) {
67  if (KnownVirtualBases.find(CanonType) != KnownVirtualBases.end())
68  return;
69 
70  // We haven't seen this virtual base before, so display it and
71  // its bases.
72  KnownVirtualBases.insert(CanonType);
73  }
74 
75  // Declare the node itself.
76  Out << " ";
77  WriteNodeReference(Type, FromVirtual);
78 
79  // Give the node a label based on the name of the class.
80  std::string TypeName = Type.getAsString();
81  Out << " [ shape=\"box\", label=\"" << llvm::DOT::EscapeString(TypeName);
82 
83  // If the name of the class was a typedef or something different
84  // from the "real" class name, show the real class name in
85  // parentheses so we don't confuse ourselves.
86  if (TypeName != CanonType.getAsString()) {
87  Out << "\\n(" << CanonType.getAsString() << ")";
88  }
89 
90  // Finished describing the node.
91  Out << " \"];\n";
92 
93  // Display the base classes.
94  const CXXRecordDecl *Decl
95  = static_cast<const CXXRecordDecl *>(Type->getAs<RecordType>()->getDecl());
96  for (const auto &Base : Decl->bases()) {
97  QualType CanonBaseType = Context.getCanonicalType(Base.getType());
98 
99  // If this is not virtual inheritance, bump the direct base
100  // count for the type.
101  if (!Base.isVirtual())
102  ++DirectBaseCount[CanonBaseType];
103 
104  // Write out the node (if we need to).
105  WriteNode(Base.getType(), Base.isVirtual());
106 
107  // Write out the edge.
108  Out << " ";
109  WriteNodeReference(Type, FromVirtual);
110  Out << " -> ";
111  WriteNodeReference(Base.getType(), Base.isVirtual());
112 
113  // Write out edge attributes to show the kind of inheritance.
114  if (Base.isVirtual()) {
115  Out << " [ style=\"dashed\" ]";
116  }
117  Out << ";";
118  }
119 }
120 
121 /// WriteNodeReference - Write out a reference to the given node,
122 /// using a unique identifier for each direct base and for the
123 /// (only) virtual base.
124 raw_ostream&
125 InheritanceHierarchyWriter::WriteNodeReference(QualType Type,
126  bool FromVirtual) {
127  QualType CanonType = Context.getCanonicalType(Type);
128 
129  Out << "Class_" << CanonType.getAsOpaquePtr();
130  if (!FromVirtual)
131  Out << "_" << DirectBaseCount[CanonType];
132  return Out;
133 }
134 
135 /// viewInheritance - Display the inheritance hierarchy of this C++
136 /// class using GraphViz.
138  QualType Self = Context.getTypeDeclType(this);
139 
140  int FD;
142  if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
143  Self.getAsString(), "dot", FD, Filename)) {
144  llvm::errs() << "Error: " << EC.message() << "\n";
145  return;
146  }
147 
148  llvm::errs() << "Writing '" << Filename << "'... ";
149 
150  llvm::raw_fd_ostream O(FD, true);
151 
152  InheritanceHierarchyWriter Writer(Context, O);
153  Writer.WriteGraph(Self);
154  llvm::errs() << " done. \n";
155 
156  O.close();
157 
158  // Display the graph
159  DisplayGraph(Filename);
160 }
Defines the clang::ASTContext interface.
A (possibly-)qualified type.
Definition: Type.h:653
base_class_range bases()
Definition: DeclCXX.h:773
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
The base class of the type hierarchy.
Definition: Type.h:1353
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6307
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
std::string getAsString() const
Definition: Type.h:979
void * getAsOpaquePtr() const
Definition: Type.h:699
StringRef Filename
Definition: Format.cpp:1345
Allows QualTypes to be sorted and hence used in maps and sets.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1347
Dataflow Directional Tag Classes.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3978
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
void viewInheritance(ASTContext &Context) const
Renders and displays an inheritance diagram for this C++ class and all of its base classes (transitiv...
Definition: InheritViz.cpp:137