added more tests

Author: fahadnayyar

lib/ClangImporter/ImportDecl.cpp

@@ -1501,27 +1501,19 @@ namespace {
         // or the original C type.
         clang::QualType ClangType = Decl->getUnderlyingType();
 
-        clang::QualType checkType = ClangType;
-        if (auto elaborated =
-                dyn_cast<clang::ElaboratedType>(checkType.getTypePtr())) {
-          checkType = elaborated->getNamedType();
-        }
-
-        if (auto templateSpec = dyn_cast<clang::TemplateSpecializationType>(
-                checkType.getTypePtr())) {
-          checkType = templateSpec->desugar();
-        }
-
-        if (auto recordType = checkType->getAs<clang::RecordType>()) {
-          if (auto spec = dyn_cast<clang::ClassTemplateSpecializationDecl>(
-                  recordType->getDecl())) {
-            if (spec->getSpecializationKind() ==
-                    clang::TSK_ExplicitSpecialization &&
-                !spec->isCompleteDefinition()) {
-              Impl.addImportDiagnostic(
-                  Decl, Diagnostic(diag::record_is_dependent, Decl->getName()),
-                  Decl->getLocation());
-              return nullptr;
+        // Prevent import of typedefs to forward-declared explicit template
+        // specializations, which would trigger assertion in Clang.
+        if (auto *templateSpec = dyn_cast<clang::TemplateSpecializationType>(
+                importer::desugarIfElaborated(ClangType).getTypePtr())) {
+          if (auto *recordType =
+                  templateSpec->desugar()->getAs<clang::RecordType>()) {
+            if (auto *spec = dyn_cast<clang::ClassTemplateSpecializationDecl>(
+                    recordType->getDecl())) {
+              if (spec->getSpecializationKind() ==
+                      clang::TSK_ExplicitSpecialization &&
+                  !spec->isCompleteDefinition()) {
+                return nullptr;
+              }
             }
           }
         }

test/Interop/Cxx/templates/Inputs/ForwardDeclaredSpecialization.h

@@ -1,19 +1,63 @@
 #ifndef FORWARD_DECLARED_SPECIALIZATION_H
 #define FORWARD_DECLARED_SPECIALIZATION_H
 
-template <typename T> 
-struct MyTemplate { 
-  T value; 
+// Basic template definition
+template <typename T>
+struct BasicTemplate {
+  T value;
 };
 
-template <> 
-struct MyTemplate<int>;
-typedef MyTemplate<int> MyIntTemplate;
+// Case 1: Forward-declared specialization (should NOT import)
+template <>
+struct BasicTemplate<int>;
+typedef BasicTemplate<int> ForwardDeclaredInt;
 
-template <> 
-struct MyTemplate<double> {
+// Case 2: Complete specialization (should import successfully)
+template <>
+struct BasicTemplate<double> {
   double value;
+  double getValue() const { return value; }
 };
-typedef MyTemplate<double> MyCompleteIntTemplate;
+typedef BasicTemplate<double> CompleteDouble;
 
-#endif // FORWARD_DECLARED_SPECIALIZATION_H
+// Case 3: Specialization defined after typedef (should import)
+template <>
+struct BasicTemplate<float>;
+typedef BasicTemplate<float> FloatTypedef;
+
+template <>
+struct BasicTemplate<float> {
+  float value;
+};
+
+// Case 4: For comparison - forward-declared non-templated struct (have same behavior)
+struct ForwardDeclaredStruct;
+typedef ForwardDeclaredStruct ForwardDeclaredStructType;
+
+// Case 5: Complete non-templated struct (imports successfully)
+struct CompleteStruct {
+  int value;
+};
+typedef CompleteStruct CompleteStructType;
+
+// Template for partial specialization test
+template <typename T, typename U>
+struct PartialTemplate {
+  T first;
+  U second;
+};
+
+// Case 6: Forward-declared partial specialization (should NOT import - same as explicit)
+template <typename T>
+struct PartialTemplate<T*, int>;  // Forward declaration only
+typedef PartialTemplate<double*, int> ForwardDeclaredPartial;
+
+// Case 7: Complete partial specialization (should import successfully)
+template <typename T>
+struct PartialTemplate<T*, double> {
+  T* ptr;
+  double value;
+};
+typedef PartialTemplate<int*, double> CompletePartial;
+
+#endif

test/Interop/Cxx/templates/forward-declared-specialization.swift

@@ -2,8 +2,31 @@
 
 import ForwardDeclaredSpecialization
 
-func testForwardDeclaredSpecialization(_ param: MyIntTemplate) { // expected-error {{cannot find type 'MyIntTemplate' in scope}}
+func testForwardDeclaredSpecialization(_ param: ForwardDeclaredInt) {
+  // expected-error@-1 {{cannot find type 'ForwardDeclaredInt' in scope}}
 }
 
-func testCompleteSpecialization(_ param: MyCompleteIntTemplate) {
+func testCompleteSpecialization(_ param: CompleteDouble) {
+  let _ = param.getValue()
+}
+
+func testSpecializationDefinedAfter(_ param: FloatTypedef) {
+  let _ = param.value
+}
+
+func testForwardDeclaredStruct(_ param: ForwardDeclaredStructType) {
+  // expected-error@-1 {{cannot find type 'ForwardDeclaredStructType' in scope}}
+}
+
+func testCompleteStruct(_ param: CompleteStructType) {
+  let _ = param.value
+}
+
+func testForwardDeclaredPartial(_ param: ForwardDeclaredPartial) {
+  // expected-error@-1 {{cannot find type 'ForwardDeclaredPartial' in scope}}
+}
+
+func testCompletePartial(_ param: CompletePartial) {
+  let _ = param.ptr
+  let _ = param.value
 }