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