clang_delta: Skip non-dep typedefs in replace-dependent-typedef

clang_delta/CMakeLists.txt

@@ -353,6 +353,8 @@ set(SOURCE_FILES
   "/tests/replace-dependent-typedef/test1.output"
   "/tests/replace-dependent-typedef/test1.output2"
   "/tests/replace-dependent-typedef/test1.output3"
+  "/tests/replace-dependent-typedef/test2.cc"
+  "/tests/replace-dependent-typedef/test2.output"
   "/tests/replace-derived-class/replace-derived1.cpp"
   "/tests/replace-derived-class/replace-derived1.output"
   "/tests/replace-derived-class/replace-derived2.cpp"

clang_delta/ReplaceDependentTypedef.cpp

@@ -45,11 +45,54 @@ It also tries to reduce the typedef chain, e.g. \n\
 static RegisterTransformation<ReplaceDependentTypedef>
          Trans("replace-dependent-typedef", DescriptionMsg);
 
+static bool DependsOnTypedef(const Type &Ty) {
+  switch (Ty.getTypeClass()) {
+  case Type::SubstTemplateTypeParm: {
+    const SubstTemplateTypeParmType *TP =
+      dyn_cast<SubstTemplateTypeParmType>(&Ty);
+    const Type *ReplTy = TP->getReplacementType().getTypePtr();
+    return DependsOnTypedef(*ReplTy);
+  }
+
+  case Type::Elaborated: {
+    const ElaboratedType *ETy = dyn_cast<ElaboratedType>(&Ty);
+    const Type *NamedTy = ETy->getNamedType().getTypePtr();
+    return DependsOnTypedef(*NamedTy);
+  }
+
+  case Type::Typedef: {
+    return true;
+  }
+
+  case Type::DependentName: {
+    const DependentNameType *DNT = dyn_cast<DependentNameType>(&Ty);
+    const NestedNameSpecifier *Specifier = DNT->getQualifier();
+    if (!Specifier)
+      return false;
+    const Type *NestedTy = Specifier->getAsType();
+    if (!NestedTy)
+      return false;
+    return DependsOnTypedef(*NestedTy);
+  }
+
+  case Type::Record:
+  case Type::Builtin: { // fall-through
+    return false;
+  }
+
+  default:
+    return false;
+  }
+
+  TransAssert(0 && "Unreachable code!");
+  return false;
+}
+
 class ReplaceDependentTypedefCollectionVisitor : public
   RecursiveASTVisitor<ReplaceDependentTypedefCollectionVisitor> {
 
 public:
-  explicit 
+  explicit
   ReplaceDependentTypedefCollectionVisitor(ReplaceDependentTypedef *Instance)
     : ConsumerInstance(Instance)
   { }
@@ -61,14 +104,14 @@ class ReplaceDependentTypedefCollectionVisitor : public
 
 };
 
-bool 
+bool
 ReplaceDependentTypedefCollectionVisitor::VisitTypedefNameDecl(TypedefNameDecl *D)
 {
   ConsumerInstance->handleOneTypedefDecl(D);
   return true;
 }
 
-void ReplaceDependentTypedef::Initialize(ASTContext &context) 
+void ReplaceDependentTypedef::Initialize(ASTContext &context)
 {
   Transformation::Initialize(context);
   CollectionVisitor = new ReplaceDependentTypedefCollectionVisitor(this);
@@ -121,7 +164,7 @@ bool ReplaceDependentTypedef::isValidType(const QualType &QT)
     return ((Keyword == ETK_Typename) || (Keyword == ETK_None));
 #endif
   }
-  
+
   default:
     return false;
   }
@@ -137,6 +180,8 @@ void ReplaceDependentTypedef::handleOneTypedefDecl(const TypedefNameDecl *D)
 
   if (!isValidType(D->getUnderlyingType()))
     return;
+  if (!DependsOnTypedef(*D->getUnderlyingType()))
+    return;
 
   std::string Str = "";
   bool Typename = false;

clang_delta/tests/replace-dependent-typedef/test2.cc

@@ -0,0 +1,19 @@
+template <typename T>
+struct A {
+  struct Inner;
+  // This shouldn't be treated as an instance:
+  typedef A::Inner Foo;
+};
+
+template <class T> struct S { typedef T type; };
+
+struct B {
+  struct Inner;
+};
+
+template <typename T>
+struct C {
+  typedef typename S<T>::type::Inner Bar;
+};
+
+typedef C<B>::Bar D;

clang_delta/tests/replace-dependent-typedef/test2.output

@@ -0,0 +1,19 @@
+template <typename T>
+struct A {
+  struct Inner;
+  // This shouldn't be treated as an instance:
+  typedef A::Inner Foo;
+};
+
+template <class T> struct S { typedef T type; };
+
+struct B {
+  struct Inner;
+};
+
+template <typename T>
+struct C {
+  typedef typename S<T>::type::Inner Bar;
+};
+
+typedef B::Inner D;

clang_delta/tests/test_clang_delta.py

@@ -1069,6 +1069,17 @@ def test_replace_derived_class_replace_dependent_typedef_1_3(self):
             'replace-dependent-typedef/test1.output3',
         )
 
+    def test_replace_derived_class_replace_dependent_typedef_2(self):
+        self.check_query_instances(
+            'replace-dependent-typedef/test2.cc',
+            '--query-instances=replace-dependent-typedef',
+            'Available transformation instances: 1',
+        )
+        self.check_clang_delta(
+            'replace-dependent-typedef/test2.cc',
+            '--transformation=replace-dependent-typedef --counter=1',
+        )
+
     def test_replace_derived_class_replace_derived1(self):
         self.check_clang_delta(
             'replace-derived-class/replace-derived1.cpp',