[AST] Implemented missing import for the Template type parameter and Injected Class Name in ASTImporter class.

[esakella]

Summary

-Implemented the VisitTemplateTypeParmType and VisitInjectedClassNameType functions in the ASTImporter class, and also enabled the import of the definition of the template class.

-Edited the existing tests to check for the import of these ASTNodes.

[akyrtzi]

If I apply just the test changes without the rest of the changes, I don't see any failures, so I'm not sure these are effective tests.

[esakella]

In D17029#356428, @akyrtzi wrote:

If I apply just the test changes without the rest of the changes, I don't see any failures, so I'm not sure these are effective tests.

This happens because also one of the changes is the new line 4304 which triggers the import of the template class definition , which in turn triggers the import of the other two elements.

If you only apply this change and the run the tests, then you see the respective error messages 'error: cannot import unsupported AST node InjectedClassName' and 'error: cannot import unsupported AST node TemplateTypeParm'.

I thought it would be better not to split and add this small change by itself, so I put them all together.

lib/AST/ASTImporter.cpp

     QualType VisitRecordType(const RecordType *T);
     QualType VisitEnumType(const EnumType *T);
     QualType VisitAttributedType(const AttributedType *T);
-    // FIXME: TemplateTypeParmType
+    QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
     // FIXME: SubstTemplateTypeParmType
     QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
     QualType VisitElaboratedType(const ElaboratedType *T);
+    QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
     // FIXME: DependentNameType
     // FIXME: DependentTemplateSpecializationType
     QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);

     ToModifiedType, ToEquivalentType);
 }
 
+QualType ASTNodeImporter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
+  TemplateTypeParmDecl *ToDecl
+    = dyn_cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
+  if (!ToDecl)
+    return QualType();
+
+  return Importer.getToContext().getTemplateTypeParmType(T->getDepth(),
+                                                         T->getIndex(),
+                                                         T->isParameterPack(),
+                                                         ToDecl);
+}
+
 QualType ASTNodeImporter::VisitTemplateSpecializationType(
                                        const TemplateSpecializationType *T) {
   TemplateName ToTemplate = Importer.Import(T->getTemplateName());

                                                    ToQualifier, ToNamedType);
 }
 
+QualType ASTNodeImporter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
+  CXXRecordDecl *ToDecl
+    = dyn_cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
+  if (!ToDecl)
+    return  QualType();
+
+  return Importer.getToContext().getTagDeclType(ToDecl);
+}
+
 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
   ObjCInterfaceDecl *Class
     = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));

 
   if (DTemplated->isCompleteDefinition() &&
       !D2Templated->isCompleteDefinition()) {
-    // FIXME: Import definition!
+    ImportDefinition(DTemplated, D2Templated);
   }
   
   return D2;

test/ASTMerge/Inputs/class-template1.cpp

 struct X0<wchar_t> {
   int member;
 };
+
+template<class V, typename T>
+class X7 {
+  V var;
+  void f(T t) { }
+  V g(T t) { return t; }
+};
+
+template<class V>
+class X8 {
+  typedef X8 x;
+  X8() { }
+  int var;
+};

test/ASTMerge/Inputs/class-template2.cpp

 struct X0<wchar_t> {
   float member;
 };
+
+template<class V, typename T>
+class X7 {
+  V var;
+  void f(T t) { }
+  V g(T t) { return t; }
+};
+
+template<class V>
+class X8 {
+  typedef X8 x;
+  X8() { }
+  int var;
+};