ppapi/tests/clang/find_affected_interfaces.cc

   1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Clang plugin which finds types that are affected if the types listed in the
   6 // plugin parameters are changed.  This is for use in determining what PPAPI
   7 // C-level interfaces are affected if one or more PPAPI C structs are changed.
   8
   9 #include <algorithm>
  10 #include <cstdio>
  11 #include <map>
  12 #include <sstream>
  13 #include <string>
  14 #include <vector>
  15
  16 #include "clang/AST/AST.h"
  17 #include "clang/AST/ASTConsumer.h"
  18 #include "clang/AST/CharUnits.h"
  19 #include "clang/Basic/SourceManager.h"
  20 #include "clang/Basic/TargetInfo.h"
  21 #include "clang/Frontend/CompilerInstance.h"
  22 #include "clang/Frontend/FrontendPluginRegistry.h"
  23
  24 namespace {
  25
  26 typedef std::vector<std::string> StringVec;
  27
  28 class FindAffectedInterfacesConsumer : public clang::ASTConsumer {
  29  public:
  30   explicit FindAffectedInterfacesConsumer(const StringVec& changed_classes) {
  31     StringVec::const_iterator iter(changed_classes.begin());
  32     StringVec::const_iterator the_end(changed_classes.end());
  33     for (; iter != the_end; ++iter) {
  34       class_is_affected_map_[*iter] = true;
  35     }
  36   }
  37
  38  private:
  39   typedef std::map<std::string, bool> StringBoolMap;
  40   StringBoolMap class_is_affected_map_;
  41
  42   bool IsAffected(const clang::Type& type_to_check) {
  43     std::string type_string(
  44       type_to_check.getCanonicalTypeInternal().getAsString());
  45     std::pair<StringBoolMap::iterator, bool> iter_success_pair =
  46         class_is_affected_map_.insert(
  47             StringBoolMap::value_type(type_string, false));
  48     StringBoolMap::iterator iter(iter_success_pair.first);
  49     bool successfully_inserted(iter_success_pair.second);
  50     // If we were able to insert, then we haven't yet seen this type.  Compute
  51     // IsAffected and put it at the newly inserted location in the map.
  52     if (successfully_inserted) {
  53       if (type_to_check.isPointerType()) {
  54         const clang::PointerType* pointer_type =
  55             dyn_cast<clang::PointerType>(&type_to_check);
  56         // Recurse to the pointee type.
  57         iter->second = IsAffected(*pointer_type->getPointeeType().getTypePtr());
  58       } else if (type_to_check.isFunctionProtoType()) {
  59         const clang::FunctionProtoType* func_type =
  60             dyn_cast<clang::FunctionProtoType>(&type_to_check);
  61         // Recurse to the return type and parameter types.
  62         iter->second = IsAffected(*func_type->getResultType().getTypePtr());
  63         if (!iter->second) {
  64           clang::FunctionProtoType::arg_type_iterator arg_iter =
  65               func_type->arg_type_begin();
  66           clang::FunctionProtoType::arg_type_iterator arg_end =
  67               func_type->arg_type_end();
  68           for (; (arg_iter != arg_end) && (!iter->second); ++arg_iter) {
  69             iter->second = IsAffected(*(arg_iter->getTypePtr()));
  70           }
  71         }
  72       } else if (type_to_check.isRecordType()) {
  73         // For records (unions, structs), recurse to the fields.
  74         const clang::RecordType* record =
  75             dyn_cast<clang::RecordType>(&type_to_check);
  76         const clang::RecordDecl* decl = record->getDecl();
  77         clang::RecordDecl::field_iterator field_iter(decl->field_begin());
  78         clang::RecordDecl::field_iterator field_end(decl->field_end());
  79         for (; (field_iter != field_end) && (!iter->second); ++field_iter) {
  80           iter->second = IsAffected(*(field_iter->getType().getTypePtr()));
  81         }
  82       }
  83     }
  84     // By this point, the bool in the map at the location referenced by iter has
  85     // the correct value.  Either it was cached, or we computed & inserted it.
  86     return iter->second;
  87   }
  88
  89   // Virtual function to consume top-level declarations.  For each one, we check
  90   // to see if it is a type definition.  If it is, we print information about
  91   // it.
  92   virtual void HandleTopLevelDecl(clang::DeclGroupRef decl_group) {
  93     clang::DeclGroupRef::iterator iter(decl_group.begin());
  94     clang::DeclGroupRef::iterator the_end(decl_group.end());
  95     for (; iter != the_end; ++iter) {
  96       const clang::Decl *decl = *iter;
  97       if (const clang::TypeDecl* type_decl = dyn_cast<clang::TypeDecl>(decl)) {
  98         std::string name(type_decl->getNameAsString());
  99         // TagDecl covers structs, enums, unions, and classes.
 100         if (const clang::TagDecl* tag = dyn_cast<clang::TagDecl>(type_decl)) {
 101           // Only print out info when we find the definition;  ignore forward
 102           // references.
 103           if (tag->isDefinition()) {
 104             clang::Type* type = type_decl->getTypeForDecl();
 105             if (IsAffected(*type)) {
 106               std::printf("%s\n", name.c_str());
 107             }
 108           }
 109         } else if (const clang::TypedefDecl* td =
 110                    dyn_cast<clang::TypedefDecl>(type_decl)) {
 111           clang::Type* type = td->getUnderlyingType().getTypePtr();
 112           if (IsAffected(*type)) {
 113             std::printf("%s\n", name.c_str());
 114           }
 115         }
 116       }
 117     }
 118   }
 119 };
 120
 121 class FindAffectedInterfacesAction : public clang::PluginASTAction {
 122  public:
 123   FindAffectedInterfacesAction() {}
 124
 125  private:
 126   StringVec types_;
 127
 128   virtual clang::ASTConsumer *CreateASTConsumer(
 129       clang::CompilerInstance &instance, llvm::StringRef /*input_file*/) {
 130     return new FindAffectedInterfacesConsumer(types_);
 131   }
 132
 133   virtual bool ParseArgs(const clang::CompilerInstance& /*instance*/,
 134                          const std::vector<std::string>& args) {
 135     // Every argument is interpreted as a comma-delimited list of names of types
 136     // that have been changed.
 137     StringVec::const_iterator iter(args.begin()), end(args.end());
 138     for (; iter != end; ++iter) {
 139       std::stringstream stream(*iter);
 140       std::string type_name;
 141       while (std::getline(stream, type_name, ',')) {
 142         types_.push_back(type_name);
 143       }
 144     }
 145     return true;
 146   }
 147 };
 148
 149 }  // namespace
 150
 151 static clang::FrontendPluginRegistry::Add<FindAffectedInterfacesAction>
 152 X("FindAffectedInterfaces",
 153   "Find interfaces affected by changes to the passes classes.");
 154