diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 2f26ab47cb079..1cdfd1ba1fad6 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -696,12 +696,191 @@ template <typename T> struct LShift {
   }
 };
 
+// Some assignment operators on swizzle are dependent on how many indices are
+// present. This base class represents the two variants: one index and multiple
+// indices.
+template <typename SwizzleOpParentT>
+class SwizzleOpDependentAssignmentOperatorBase;
+
+// Specialization for a swizzles with a single index.
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int Index>
+class SwizzleOpDependentAssignmentOperatorBase<SwizzleOp<
+    VecT, OperationLeftT, OperationRightT, OperationCurrentT, Index>> {
+  using SwizzleOpParentT = SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                     OperationCurrentT, Index>;
+
+  using DataT = typename VecT::element_type;
+
+public:
+  const SwizzleOpDependentAssignmentOperatorBase &operator=(DataT &&Rhs) const {
+    const SwizzleOpParentT &Self = *static_cast<const SwizzleOpParentT *>(this);
+    (*Self.m_Vector)[Index] = Rhs;
+    return *this;
+  }
+};
+
+// Specialization for a swizzles with multiple indices index.
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int Index0,
+          int... IndexRest>
+class SwizzleOpDependentAssignmentOperatorBase<
+    SwizzleOp<VecT, OperationLeftT, OperationRightT, OperationCurrentT, Index0,
+              IndexRest...>> {
+  using SwizzleOpParentT = SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                     OperationCurrentT, Index0, IndexRest...>;
+
+  using DataT = typename VecT::element_type;
+
+public:
+  const SwizzleOpDependentAssignmentOperatorBase &
+  operator=(const vec<DataT, sizeof...(IndexRest) + 1> &Rhs) const {
+    const SwizzleOpParentT &Self = *static_cast<const SwizzleOpParentT *>(this);
+    for (size_t I = 0; I < Self.Idxs.size(); ++I) {
+      (*Self.m_Vector)[Self.Idxs[I]] = Rhs[I];
+    }
+    return *this;
+  }
+};
+
+// Base class for mutable swizzles to mask out mutating operators.
+template <typename SwizzleOpParentT, typename = void>
+class SwizzleOpMutatingOperatorBase {
+public:
+  SwizzleOpMutatingOperatorBase &
+  operator=(const SwizzleOpMutatingOperatorBase &) = delete;
+};
+
+// Specialization for mutable swizzles.
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOpMutatingOperatorBase<
+    SwizzleOp<VecT, OperationLeftT, OperationRightT, OperationCurrentT,
+              Indexes...>,
+    std::enable_if_t<!std::is_const_v<VecT>>>
+    : public SwizzleOpDependentAssignmentOperatorBase<
+          SwizzleOp<VecT, OperationLeftT, OperationRightT, OperationCurrentT,
+                    Indexes...>> {
+  using SwizzleOpParentT = SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                     OperationCurrentT, Indexes...>;
+
+  static constexpr int getNumElements() { return sizeof...(Indexes); }
+  static constexpr std::array<int, getNumElements()> Idxs{Indexes...};
+
+  using DataT = typename VecT::element_type;
+  using vec_t = vec<DataT, sizeof...(Indexes)>;
+
+public:
+  // TODO: Check that Rhs arg is suitable.
+#ifdef __SYCL_OPASSIGN
+#error "Undefine __SYCL_OPASSIGN macro."
+#endif
+#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
+  friend const SwizzleOpParentT &operator OPASSIGN(                            \
+      const SwizzleOpParentT & Lhs, const DataT & Rhs) {                       \
+    Lhs.template operatorHelper<OP>(vec_t(Rhs));                               \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <typename RhsOperation>                                             \
+  friend const SwizzleOpParentT &operator OPASSIGN(                            \
+      const SwizzleOpParentT & Lhs, const RhsOperation & Rhs) {                \
+    Lhs.template operatorHelper<OP>(Rhs);                                      \
+    return Lhs;                                                                \
+  }                                                                            \
+  friend const SwizzleOpParentT &operator OPASSIGN(                            \
+      const SwizzleOpParentT & Lhs, const vec_t & Rhs) {                       \
+    Lhs.template operatorHelper<OP>(Rhs);                                      \
+    return Lhs;                                                                \
+  }
+
+  __SYCL_OPASSIGN(+=, std::plus)
+  __SYCL_OPASSIGN(-=, std::minus)
+  __SYCL_OPASSIGN(*=, std::multiplies)
+  __SYCL_OPASSIGN(/=, std::divides)
+  __SYCL_OPASSIGN(%=, std::modulus)
+  __SYCL_OPASSIGN(&=, std::bit_and)
+  __SYCL_OPASSIGN(|=, std::bit_or)
+  __SYCL_OPASSIGN(^=, std::bit_xor)
+  __SYCL_OPASSIGN(>>=, RShift)
+  __SYCL_OPASSIGN(<<=, LShift)
+#undef __SYCL_OPASSIGN
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  friend const SwizzleOpParentT &operator UOP(const SwizzleOpParentT & sv) {   \
+    sv OPASSIGN static_cast<DataT>(1);                                         \
+    return sv;                                                                 \
+  }                                                                            \
+  friend vec_t operator UOP(const SwizzleOpParentT &sv, int) {                 \
+    vec_t Ret = sv;                                                            \
+    sv OPASSIGN static_cast<DataT>(1);                                         \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  using SwizzleOpDependentAssignmentOperatorBase<SwizzleOpParentT>::operator=;
+
+  const SwizzleOpMutatingOperatorBase &operator=(const DataT &Rhs) const {
+    const SwizzleOpParentT &Self = *static_cast<const SwizzleOpParentT *>(this);
+    if constexpr (SwizzleOpParentT::getNumElements() == 1) {
+      (*Self.m_Vector)[Self.Idxs[0]] = Rhs;
+    } else {
+      for (auto Idx : Self.Idxs)
+        (*Self.m_Vector)[Idx] = Rhs;
+    }
+    return *this;
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  const SwizzleOpMutatingOperatorBase &
+  operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) const {
+    const SwizzleOpParentT &Self = *static_cast<const SwizzleOpParentT *>(this);
+    for (size_t I = 0; I < Self.Idxs.size(); ++I) {
+      (*Self.m_Vector)[Self.Idxs[I]] = Rhs.getValue(I);
+    }
+    return *this;
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  const SwizzleOpMutatingOperatorBase &
+  operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) const {
+    const SwizzleOpParentT &Self = *static_cast<const SwizzleOpParentT *>(this);
+    for (size_t I = 0; I < Self.Idxs.size(); ++I) {
+      (*Self.m_Vector)[Self.Idxs[I]] = Rhs.getValue(I);
+    }
+    return *this;
+  }
+
+  // Leave store() interface to automatic conversion to vec<>.
+  // Load to vec_t and then assign to swizzle.
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) const {
+    const SwizzleOpParentT &Self = *static_cast<const SwizzleOpParentT *>(this);
+    vec_t Tmp;
+    Tmp.load(offset, ptr);
+    Self = Tmp;
+  }
+};
+
 ///////////////////////// class SwizzleOp /////////////////////////
 // SwizzleOP represents expression templates that operate on vec.
 // Actual computation performed on conversion or assignment operators.
 template <typename VecT, typename OperationLeftT, typename OperationRightT,
           template <typename> class OperationCurrentT, int... Indexes>
-class SwizzleOp {
+class SwizzleOp : public SwizzleOpMutatingOperatorBase<
+                      SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                OperationCurrentT, Indexes...>> {
   using DataT = typename VecT::element_type;
   // Certain operators return a vector with a different element type. Also, the
   // left and right operand types may differ. CommonDataT selects a result type
@@ -736,6 +915,8 @@ class SwizzleOp {
       DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
   static constexpr int getNumElements() { return sizeof...(Indexes); }
 
+  static constexpr std::array<int, getNumElements()> Idxs{Indexes...};
+
   using rel_t = detail::rel_t<DataT>;
   using vec_t = vec<DataT, sizeof...(Indexes)>;
   using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
@@ -760,14 +941,20 @@ class SwizzleOp {
                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
                                       OperationCurrentT, Indexes...>,
                             OperationCurrentT_, Idx_...>;
+  template <int IdxNum>
+  static constexpr bool HasOneIndex =
+      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum;
 
   template <int IdxNum, typename T = void>
-  using EnableIfOneIndex = typename std::enable_if_t<
-      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+  using EnableIfOneIndex = typename std::enable_if_t<HasOneIndex<IdxNum>, T>;
+
+  template <int IdxNum>
+  static constexpr bool HasMultipleIndices =
+      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum;
 
   template <int IdxNum, typename T = void>
-  using EnableIfMultipleIndexes = typename std::enable_if_t<
-      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+  using EnableIfMultipleIndexes =
+      typename std::enable_if_t<HasMultipleIndices<IdxNum>, T>;
 
   template <typename T>
   using EnableIfScalarType = typename std::enable_if_t<
@@ -797,14 +984,16 @@ class SwizzleOp {
   using vector_t = typename vec_t::vector_t;
 #endif // __SYCL_DEVICE_ONLY__
 
+  using SwizzleOpMutatingOperatorBase<
+      SwizzleOp<VecT, OperationLeftT, OperationRightT, OperationCurrentT,
+                Indexes...>>::operator=;
+
   const DataT &operator[](int i) const {
-    std::array<int, getNumElements()> Idxs{Indexes...};
     return (*m_Vector)[Idxs[i]];
   }
 
   template <typename _T = VecT>
   std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
     return (*m_Vector)[Idxs[i]];
   }
 
@@ -851,58 +1040,6 @@ class SwizzleOp {
         Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
   }
 
-  // TODO: Check that Rhs arg is suitable.
-#ifdef __SYCL_OPASSIGN
-#error "Undefine __SYCL_OPASSIGN macro."
-#endif
-#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
-  friend const SwizzleOp &operator OPASSIGN(const SwizzleOp & Lhs,             \
-                                            const DataT & Rhs) {               \
-    Lhs.operatorHelper<OP>(vec_t(Rhs));                                        \
-    return Lhs;                                                                \
-  }                                                                            \
-  template <typename RhsOperation>                                             \
-  friend const SwizzleOp &operator OPASSIGN(const SwizzleOp & Lhs,             \
-                                            const RhsOperation & Rhs) {        \
-    Lhs.operatorHelper<OP>(Rhs);                                               \
-    return Lhs;                                                                \
-  }                                                                            \
-  friend const SwizzleOp &operator OPASSIGN(const SwizzleOp & Lhs,             \
-                                            const vec_t & Rhs) {               \
-    Lhs.operatorHelper<OP>(Rhs);                                               \
-    return Lhs;                                                                \
-  }
-
-  __SYCL_OPASSIGN(+=, std::plus)
-  __SYCL_OPASSIGN(-=, std::minus)
-  __SYCL_OPASSIGN(*=, std::multiplies)
-  __SYCL_OPASSIGN(/=, std::divides)
-  __SYCL_OPASSIGN(%=, std::modulus)
-  __SYCL_OPASSIGN(&=, std::bit_and)
-  __SYCL_OPASSIGN(|=, std::bit_or)
-  __SYCL_OPASSIGN(^=, std::bit_xor)
-  __SYCL_OPASSIGN(>>=, RShift)
-  __SYCL_OPASSIGN(<<=, LShift)
-#undef __SYCL_OPASSIGN
-
-#ifdef __SYCL_UOP
-#error "Undefine __SYCL_UOP macro"
-#endif
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  friend const SwizzleOp &operator UOP(const SwizzleOp & sv) {                 \
-    sv OPASSIGN static_cast<DataT>(1);                                         \
-    return sv;                                                                 \
-  }                                                                            \
-  friend vec_t operator UOP(const SwizzleOp &sv, int) {                        \
-    vec_t Ret = sv;                                                            \
-    sv OPASSIGN static_cast<DataT>(1);                                         \
-    return Ret;                                                                \
-  }
-
-  __SYCL_UOP(++, +=)
-  __SYCL_UOP(--, -=)
-#undef __SYCL_UOP
-
   template <typename T = DataT>
   friend typename std::enable_if_t<
       std::is_same_v<T, DataT> && !detail::is_vgenfloat_v<T>, vec_t>
@@ -1027,40 +1164,6 @@ class SwizzleOp {
   __SYCL_RELLOGOP(||, (!detail::is_byte_v<T> && !detail::is_vgenfloat_v<T>))
 #undef __SYCL_RELLOGOP
 
-  template <int IdxNum = getNumElements(),
-            typename = EnableIfMultipleIndexes<IdxNum>>
-  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      (*m_Vector)[Idxs[I]] = Rhs[I];
-    }
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
-  SwizzleOp &operator=(const DataT &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    (*m_Vector)[Idxs[0]] = Rhs;
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(),
-            EnableIfMultipleIndexes<IdxNum, bool> = true>
-  SwizzleOp &operator=(const DataT &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    for (auto Idx : Idxs) {
-      (*m_Vector)[Idx] = Rhs;
-    }
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
-  SwizzleOp &operator=(DataT &&Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    (*m_Vector)[Idxs[0]] = Rhs;
-    return *this;
-  }
-
   template <typename T, typename = EnableIfScalarType<T>>
   NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
   operator*(const T &Rhs) const {
@@ -1203,30 +1306,6 @@ class SwizzleOp {
     return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
   }
 
-  template <
-      typename T1, typename T2, typename T3, template <typename> class T4,
-      int... T5,
-      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
-  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      (*m_Vector)[Idxs[I]] = Rhs.getValue(I);
-    }
-    return *this;
-  }
-
-  template <
-      typename T1, typename T2, typename T3, template <typename> class T4,
-      int... T5,
-      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
-  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      (*m_Vector)[Idxs[I]] = Rhs.getValue(I);
-    }
-    return *this;
-  }
-
   template <typename T, typename = EnableIfScalarType<T>>
   NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
     return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
@@ -1358,20 +1437,10 @@ class SwizzleOp {
 #undef __SYCL_ACCESS_RETURN
   // End of hi/lo, even/odd, xyzw, and rgba swizzles.
 
-  // Leave store() interface to automatic conversion to vec<>.
-  // Load to vec_t and then assign to swizzle.
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
-    vec_t Tmp;
-    Tmp.load(offset, ptr);
-    *this = Tmp;
-  }
-
   template <typename convertT, rounding_mode roundingMode>
   vec<convertT, sizeof...(Indexes)> convert() const {
     // First materialize the swizzle to vec_t and then apply convert() to it.
     vec_t Tmp;
-    std::array<int, getNumElements()> Idxs{Indexes...};
     for (size_t I = 0; I < Idxs.size(); ++I) {
       Tmp[I] = (*m_Vector)[Idxs[I]];
     }
@@ -1415,7 +1484,6 @@ class SwizzleOp {
   template <int IdxNum = getNumElements()>
   CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
     if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
-      std::array<int, getNumElements()> Idxs{Indexes...};
       return (*m_Vector)[Idxs[Index]];
     }
     auto Op = OperationCurrentT<CommonDataT>();
@@ -1426,7 +1494,6 @@ class SwizzleOp {
   template <int IdxNum = getNumElements()>
   DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
     if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
-      std::array<int, getNumElements()> Idxs{Indexes...};
       return (*m_Vector)[Idxs[Index]];
     }
     auto Op = OperationCurrentT<DataT>();
@@ -1437,7 +1504,6 @@ class SwizzleOp {
   template <template <typename> class Operation, typename RhsOperation>
   void operatorHelper(const RhsOperation &Rhs) const {
     Operation<DataT> Op;
-    std::array<int, getNumElements()> Idxs{Indexes...};
     for (size_t I = 0; I < Idxs.size(); ++I) {
       DataT Res = Op((*m_Vector)[Idxs[I]], Rhs.getValue(I));
       (*m_Vector)[Idxs[I]] = Res;
@@ -1456,6 +1522,12 @@ class SwizzleOp {
   template <typename T1, typename T2, typename T3, template <typename> class T4,
             int... T5>
   friend class SwizzleOp;
+
+  template <typename SwizzleOpParentT, typename>
+  friend class sycl::detail::SwizzleOpMutatingOperatorBase;
+
+  template <typename SwizzleOpParentT>
+  friend class SwizzleOpDependentAssignmentOperatorBase;
 };
 ///////////////////////// class SwizzleOp /////////////////////////
 } // namespace detail
diff --git a/sycl/test/basic_tests/vectors/const_swizzle_negative.cpp b/sycl/test/basic_tests/vectors/const_swizzle_negative.cpp
new file mode 100644
index 0000000000000..c0c52ce132b7f
--- /dev/null
+++ b/sycl/test/basic_tests/vectors/const_swizzle_negative.cpp
@@ -0,0 +1,98 @@
+// REQUIRES: preview-breaking-changes-supported
+// RUN: %clangxx -fsycl-device-only -ferror-limit=0 -Xclang -fsycl-is-device -fsyntax-only -fpreview-breaking-changes -Xclang -verify -Xclang -verify-ignore-unexpected=note %s
+
+#include <sycl/detail/core.hpp>
+#include <sycl/types.hpp>
+
+int main() {
+  sycl::queue Q;
+  Q.single_task([]() {
+    const sycl::vec<int, 4> X{1};
+
+    // expected-error@+1 {{no viable overloaded '='}}
+    X.swizzle<0>() = 1;
+    // expected-error@+1 {{no viable overloaded '='}}
+    X.swizzle<0>() = sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '='}}
+    X.swizzle<0, 2>() = sycl::vec<int, 2>{1};
+
+    // expected-error@+1 {{no viable overloaded '+='}}
+    X.swizzle<0>() += 1;
+    // expected-error@+1 {{no viable overloaded '-='}}
+    X.swizzle<0>() -= 1;
+    // expected-error@+1 {{no viable overloaded '*='}}
+    X.swizzle<0>() *= 1;
+    // expected-error@+1 {{no viable overloaded '/='}}
+    X.swizzle<0>() /= 1;
+    // expected-error@+1 {{no viable overloaded '%='}}
+    X.swizzle<0>() %= 1;
+    // expected-error@+1 {{no viable overloaded '&='}}
+    X.swizzle<0>() &= 1;
+    // expected-error@+1 {{no viable overloaded '|='}}
+    X.swizzle<0>() |= 1;
+    // expected-error@+1 {{no viable overloaded '^='}}
+    X.swizzle<0>() ^= 1;
+    // expected-error@+1 {{no viable overloaded '>>='}}
+    X.swizzle<0>() >>= 1;
+    // expected-error@+1 {{no viable overloaded '<<='}}
+    X.swizzle<0>() <<= 1;
+
+    // expected-error@+1 {{no viable overloaded '+='}}
+    X.swizzle<0>() += sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '-='}}
+    X.swizzle<0>() -= sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '*='}}
+    X.swizzle<0>() *= sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '/='}}
+    X.swizzle<0>() /= sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '%='}}
+    X.swizzle<0>() %= sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '&='}}
+    X.swizzle<0>() &= sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '|='}}
+    X.swizzle<0>() |= sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '^='}}
+    X.swizzle<0>() ^= sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '>>='}}
+    X.swizzle<0>() >>= sycl::vec<int, 1>{1};
+    // expected-error@+1 {{no viable overloaded '<<='}}
+    X.swizzle<0>() <<= sycl::vec<int, 1>{1};
+
+    // expected-error@+1 {{no viable overloaded '+='}}
+    X.swizzle<0>() += X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '-='}}
+    X.swizzle<0>() -= X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '*='}}
+    X.swizzle<0>() *= X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '/='}}
+    X.swizzle<0>() /= X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '%='}}
+    X.swizzle<0>() %= X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '&='}}
+    X.swizzle<0>() &= X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '|='}}
+    X.swizzle<0>() |= X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '^='}}
+    X.swizzle<0>() ^= X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '>>='}}
+    X.swizzle<0>() >>= X.swizzle<1>();
+    // expected-error@+1 {{no viable overloaded '<<='}}
+    X.swizzle<0>() <<= X.swizzle<1>();
+
+    // expected-error@+1 {{cannot increment value of type}}
+    X.swizzle<0>()++;
+    // expected-error@+1 {{cannot increment value of type}}
+    ++X.swizzle<0>();
+    // expected-error@+1 {{cannot decrement value of type}}
+    X.swizzle<0>()--;
+    // expected-error@+1 {{cannot decrement value of type}}
+    --X.swizzle<0>();
+
+    int I = 1;
+    // expected-error@+1 {{no member named 'load' in}}
+    X.swizzle<0>().load(
+        0, sycl::address_space_cast<sycl::access::address_space::private_space,
+                                    sycl::access::decorated::no>(&I));
+  });
+  return 0;
+}