Remove diagnostic for implicit template instantiation;

Address other review comments

Author: schittir

clang/lib/Sema/SemaDecl.cpp

@@ -3068,6 +3068,10 @@ static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
       cast<SYCLKernelEntryPointAttr>(NewAttribute)->setInvalidAttr();
       ++I;
       continue;
+    } else if (isa<SYCLExternalAttr>(NewAttribute)) {
+      // SYCLExternalAttr may be added after a definition.
+      ++I;
+      continue;
     }
 
     S.Diag(NewAttribute->getLocation(),

clang/lib/Sema/SemaSYCL.cpp

@@ -253,9 +253,12 @@ static bool CheckSYCLKernelName(Sema &S, SourceLocation Loc,
 void SemaSYCL::CheckSYCLExternalFunctionDecl(FunctionDecl *FD) {
   const auto *SEAttr = FD->getAttr<SYCLExternalAttr>();
   assert(SEAttr && "Missing sycl_external attribute");
-  if (!FD->isExternallyVisible()) {
-    Diag(SEAttr->getLocation(), diag::err_sycl_external_invalid_linkage)
-        << SEAttr;
+  if (!FD->isInvalidDecl() && !FD->isTemplated()) {
+    if (!FD->isExternallyVisible())
+      if (!FD->isFunctionTemplateSpecialization() ||
+          FD->getTemplateSpecializationInfo()->isExplicitSpecialization())
+        Diag(SEAttr->getLocation(), diag::err_sycl_external_invalid_linkage)
+            << SEAttr;
   }
   if (FD->isDeletedAsWritten()) {
     Diag(SEAttr->getLocation(),

clang/test/CodeGenSYCL/kernel-caller-entry-point.cpp

@@ -101,7 +101,7 @@ int main() {
 // Verify that SYCL kernel caller functions are emitted for each device target.
 //
 // main() shouldn't be emitted in device code.
-// CHECK-NOT: define {{[a-z_ ]*}}noundef i32 @main() #0
+// CHECK-NOT: @main()
 
 // IR for the SYCL kernel caller function generated for
 // single_purpose_kernel_task with single_purpose_kernel_name as the SYCL kernel

clang/test/CodeGenSYCL/sycl-external-attr.cpp

@@ -10,17 +10,23 @@
 [[clang::sycl_external]] int squareUsed(int x) { return x*x; }
 // CHECK: define dso_local spir_func noundef i32 @_Z10squareUsedi
 
-// Constexpr function defined and not used - symbols emitted
+// FIXME: Constexpr function defined and not used - symbols emitted
 [[clang::sycl_external]] constexpr int squareInlined(int x) { return x*x; }
 // CHECK: define linkonce_odr spir_func noundef i32 @_Z13squareInlinedi
 
 // Function declared but not defined or used - no symbols emitted
 [[clang::sycl_external]] int declOnly();
 // CHECK-NOT: define {{.*}} i32 @_Z8declOnlyv
+// CHECK-NOT: declare {{.*}} i32 @_Z8declOnlyv
 
+// Function declared and used in host but not defined - no symbols emitted
+[[clang::sycl_external]] void declUsedInHost(int y);
 
-// FIXME: Function declared and used but not defined - emit external reference
-[[clang::sycl_external]] void declUsed(int y);
+// Function declared and used in device but not defined - emit external reference
+[[clang::sycl_external]] void declUsedInDevice(int y);
+// CHECK: define dso_local spir_func void @_Z9deviceUsev
+[[clang::sycl_external]] void deviceUse() { declUsedInDevice(3); }
+// CHECK: declare spir_func void @_Z16declUsedInDevicei
 
 // Function declared with the attribute and later defined - definition emitted
 [[clang::sycl_external]] int func1(int arg);
@@ -66,12 +72,13 @@ template<> void tFunc2<char>(char arg) {}
 template<> [[clang::sycl_external]] void  tFunc2<long>(long arg) {}
 // CHECK: define dso_local spir_func void @_Z6tFunc2IlEvT_
 
-// Test that symbols are not emitted without the sycl_external attribute
+// Functions defined without the sycl_external attribute that are used
+// in host code, but not in device code are not emitted.
 int squareNoAttr(int x) { return x*x; }
 // CHECK-NOT: define {{.*}} i32 @_Z12squareNoAttri
 
 int main() {
-  declUsed(4);
+  declUsedInHost(4);
   int i = squareUsed(5);
   int j = squareNoAttr(6);
   return 0;

clang/test/SemaSYCL/sycl-external-attr.cpp

@@ -20,24 +20,20 @@ namespace { struct S4 {}; }
 [[clang::sycl_external]] void func4(S4) {}
 
 // expected-error@+3{{'clang::sycl_external' can only be applied to functions with external linkage}}
+namespace { struct S5 {}; }
+template<typename> [[clang::sycl_external]] void func5();
+template<> [[clang::sycl_external]] void func5<S5>() {}
+
 namespace { struct S6 {}; }
 template<typename>
 [[clang::sycl_external]] void func6() {}
 template void func6<S6>();
-// expected-note@-1{{in instantiation of function template specialization 'func6<(anonymous namespace)::S6>' requested here}}
-
-// FIXME: C++23 [temp.expl.spec]p12 states:
-//   ... Similarly, attributes appearing in the declaration of a template
-//   have no effect on an explicit specialization of that template.
-// Clang currently instantiates and propagates attributes from a function
-// template to its explicit specializations resulting in the following
-// spurious error.
-// expected-error@+3 2{{'clang::sycl_external' can only be applied to functions with external linkage}}
+
+// expected-error@+3{{'clang::sycl_external' can only be applied to functions with external linkage}}
 namespace { struct S7 {}; }
 template<typename>
 [[clang::sycl_external]] void func7();
 template<> void func7<S7>() {}
-// expected-note@-1{{in instantiation of function template specialization 'func7<(anonymous namespace)::S7>' requested here}}
 
 // FIXME: The explicit function template specialization appears to trigger
 // instantiation of a declaration from the primary template without the
@@ -51,21 +47,17 @@ template<> [[clang::sycl_external]] void func8<S8>() {}
 // expected-error@-2{{'clang::sycl_external' can only be applied to functions with external linkage}}
 // expected-note@-3{{previous declaration is here}}
 
-// FIXME: The implicit instantiation of func9<S9>() is valid.
 namespace { struct S9 {}; }
 struct T9 {
   using type = S9;
 };
-// expected-error@+2{{'clang::sycl_external' can only be applied to functions with external linkage}}
 template<typename>
 [[clang::sycl_external]] void func9() {}
-// expected-note@+3{{in instantiation of function template specialization 'func9<(anonymous namespace)::S9>' requested here}}
 template<typename T>
 [[clang::sycl_external]] void test_func9() {
   func9<typename T::type>();
 }
-// expected-note@+1{{in instantiation of function template specialization 'test_func9<T9>' requested here}}
-template void test_func9<T9>(); // FIXME: don't diagnose implicit instantiation of func9<S9>().
+template void test_func9<T9>();
 
 // The first declaration of a SYCL external function is required to have this attribute.
 // expected-note@+1{{previous declaration is here}}
@@ -79,10 +71,8 @@ void goo();
 [[clang::sycl_external]] void goo();
 void goo() {}
 
-// expected-note@+2{{previous definition is here}}
 // expected-note@+1{{previous declaration is here}}
 void hoo() {}
-// expected-warning@+2{{attribute declaration must precede definition}}
 // expected-warning@+1{{'clang::sycl_external' attribute does not appear on the first declaration}}
 [[clang::sycl_external]] void hoo();