[Attr][Doc][NFC] Fix code snippet formatting for attribute documentation

[merge_guards_bot]

Unit tests: pass. 62057 tests passed, 0 failed and 784 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[Fznamznon]

Thank you for this!

[aaron.ballman]

LGTM!

clang/include/clang/Basic/AttrDocs.td

 
 def SYCLKernelDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``sycl_kernel`` attribute specifies that a function template will be used
 to outline device code and to generate an OpenCL kernel.
 Here is a code example of the SYCL program, which demonstrates the compiler's
 outlining job:
+
 .. code-block:: c++
 
   int foo(int x) { return ++x; }
 
   using namespace cl::sycl;
   queue Q;
   buffer<int, 1> a(range<1>{1024});
   Q.submit([&](handler& cgh) {
     auto A = a.get_access<access::mode::write>(cgh);
     cgh.parallel_for<init_a>(range<1>{1024}, [=](id<1> index) {
       A[index] = index[0] + foo(42);
     });
   }
 
 A C++ function object passed to the ``parallel_for`` is called a "SYCL kernel".
 A SYCL kernel defines the entry point to the "device part" of the code. The
 compiler will emit all symbols accessible from a "kernel". In this code
 example, the compiler will emit "foo" function.  More details about the
 compilation of functions for the device part can be found in the SYCL 1.2.1
 specification Section 6.4.
 To show to the compiler entry point to the "device part" of the code, the SYCL
 runtime can use the ``sycl_kernel`` attribute in the following way:
+
 .. code-block:: c++
+
   namespace cl {
   namespace sycl {
   class handler {
     template <typename KernelName, typename KernelType/*, ...*/>
     __attribute__((sycl_kernel)) void sycl_kernel_function(KernelType KernelFuncObj) {
       // ...
       KernelFuncObj();
     }
 
     template <typename KernelName, typename KernelType, int Dims>
     void parallel_for(range<Dims> NumWorkItems, KernelType KernelFunc) {
   #ifdef __SYCL_DEVICE_ONLY__
       sycl_kernel_function<KernelName, KernelType, Dims>(KernelFunc);
   #else
       // Host implementation
   #endif
     }
   };
   } // namespace sycl
   } // namespace cl
 
 The compiler will also generate an OpenCL kernel using the function marked with
 the ``sycl_kernel`` attribute.
 Here is the list of SYCL device compiler expectations with regard to the
 function marked with the ``sycl_kernel`` attribute:
 
 - The function must be a template with at least two type template parameters.
   The compiler generates an OpenCL kernel and uses the first template parameter