diff --git a/sycl/include/sycl/detail/array.hpp b/sycl/include/sycl/detail/array.hpp
index 2b723a2ebf73e..be6ba7a73d37b 100644
--- a/sycl/include/sycl/detail/array.hpp
+++ b/sycl/include/sycl/detail/array.hpp
@@ -61,17 +61,17 @@ template <int dimensions = 1> class array {
     return result;
   }
 
-  size_t get(int dimension) const {
+  size_t get(int dimension) const noexcept {
     check_dimension(dimension);
     return common_array[dimension];
   }
 
-  size_t &operator[](int dimension) {
+  size_t &operator[](int dimension) noexcept {
     check_dimension(dimension);
     return common_array[dimension];
   }
 
-  size_t operator[](int dimension) const {
+  size_t operator[](int dimension) const noexcept {
     check_dimension(dimension);
     return common_array[dimension];
   }
diff --git a/sycl/include/sycl/range.hpp b/sycl/include/sycl/range.hpp
index cb1abe36e1f03..15c8d1d3836aa 100644
--- a/sycl/include/sycl/range.hpp
+++ b/sycl/include/sycl/range.hpp
@@ -39,22 +39,23 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
   /* The following constructor is only available in the range class
   specialization where: Dimensions==1 */
   template <int N = Dimensions>
-  range(typename std::enable_if_t<(N == 1), size_t> dim0) : base(dim0) {}
+  range(typename std::enable_if_t<(N == 1), size_t> dim0) noexcept
+      : base(dim0) {}
 
   /* The following constructor is only available in the range class
   specialization where: Dimensions==2 */
   template <int N = Dimensions>
-  range(typename std::enable_if_t<(N == 2), size_t> dim0, size_t dim1)
+  range(typename std::enable_if_t<(N == 2), size_t> dim0, size_t dim1) noexcept
       : base(dim0, dim1) {}
 
   /* The following constructor is only available in the range class
   specialization where: Dimensions==3 */
   template <int N = Dimensions>
   range(typename std::enable_if_t<(N == 3), size_t> dim0, size_t dim1,
-        size_t dim2)
+        size_t dim2) noexcept
       : base(dim0, dim1, dim2) {}
 
-  size_t size() const {
+  size_t size() const noexcept {
     size_t size = 1;
     for (int i = 0; i < Dimensions; ++i) {
       size *= this->common_array[i];
@@ -68,10 +69,12 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
   range<Dimensions> &operator=(range<Dimensions> &&rhs) = default;
   range() = default;
 
+  ~range() = default;
+
 // OP is: +, -, *, /, %, <<, >>, &, |, ^, &&, ||, <, >, <=, >=
 #define __SYCL_GEN_OPT_BASE(op)                                                \
-  friend range<Dimensions> operator op(const range<Dimensions> &lhs,           \
-                                       const range<Dimensions> &rhs) {         \
+  friend range<Dimensions> operator op(                                        \
+      const range<Dimensions> &lhs, const range<Dimensions> &rhs) noexcept {   \
     range<Dimensions> result(lhs);                                             \
     for (int i = 0; i < Dimensions; ++i) {                                     \
       result.common_array[i] = lhs.common_array[i] op rhs.common_array[i];     \
@@ -85,7 +88,7 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
   __SYCL_GEN_OPT_BASE(op)                                                      \
   template <typename T>                                                        \
   friend IntegralType<T, range<Dimensions>> operator op(                       \
-      const range<Dimensions> &lhs, const T &rhs) {                            \
+      const range<Dimensions> &lhs, const T &rhs) noexcept {                   \
     range<Dimensions> result(lhs);                                             \
     for (int i = 0; i < Dimensions; ++i) {                                     \
       result.common_array[i] = lhs.common_array[i] op rhs;                     \
@@ -94,7 +97,7 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
   }                                                                            \
   template <typename T>                                                        \
   friend IntegralType<T, range<Dimensions>> operator op(                       \
-      const T &lhs, const range<Dimensions> &rhs) {                            \
+      const T &lhs, const range<Dimensions> &rhs) noexcept {                   \
     range<Dimensions> result(rhs);                                             \
     for (int i = 0; i < Dimensions; ++i) {                                     \
       result.common_array[i] = lhs op rhs.common_array[i];                     \
@@ -102,6 +105,7 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
     return result;                                                             \
   }
 #else
+// RFC: remove these as well?
 #define __SYCL_GEN_OPT(op)                                                     \
   __SYCL_GEN_OPT_BASE(op)                                                      \
   friend range<Dimensions> operator op(const range<Dimensions> &lhs,           \
@@ -144,15 +148,16 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
 
 // OP is: +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=
 #define __SYCL_GEN_OPT(op)                                                     \
-  friend range<Dimensions> &operator op(range<Dimensions> &lhs,                \
-                                        const range<Dimensions> &rhs) {        \
+  friend range<Dimensions> &operator op(                                       \
+      range<Dimensions> &lhs, const range<Dimensions> &rhs) noexcept {         \
     for (int i = 0; i < Dimensions; ++i) {                                     \
       lhs.common_array[i] op rhs[i];                                           \
     }                                                                          \
     return lhs;                                                                \
   }                                                                            \
-  friend range<Dimensions> &operator op(range<Dimensions> &lhs,                \
-                                        const size_t &rhs) {                   \
+  template <typename T>                                                        \
+  friend IntegralType<T, range<Dimensions>> operator op(                       \
+      range<Dimensions> &lhs, const T &rhs) noexcept {                         \
     for (int i = 0; i < Dimensions; ++i) {                                     \
       lhs.common_array[i] op rhs;                                              \
     }                                                                          \
@@ -174,7 +179,8 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
 
 // OP is unary +, -
 #define __SYCL_GEN_OPT(op)                                                     \
-  friend range<Dimensions> operator op(const range<Dimensions> &rhs) {         \
+  friend range<Dimensions> operator op(                                        \
+      const range<Dimensions> &rhs) noexcept {                                 \
     range<Dimensions> result(rhs);                                             \
     for (int i = 0; i < Dimensions; ++i) {                                     \
       result.common_array[i] = (op rhs.common_array[i]);                       \
@@ -189,7 +195,7 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
 
 // OP is prefix ++, --
 #define __SYCL_GEN_OPT(op)                                                     \
-  friend range<Dimensions> &operator op(range<Dimensions> &rhs) {              \
+  friend range<Dimensions> &operator op(range<Dimensions> &rhs) noexcept {     \
     for (int i = 0; i < Dimensions; ++i) {                                     \
       op rhs.common_array[i];                                                  \
     }                                                                          \
@@ -203,7 +209,7 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
 
 // OP is postfix ++, --
 #define __SYCL_GEN_OPT(op)                                                     \
-  friend range<Dimensions> operator op(range<Dimensions> &lhs, int) {          \
+  friend range<Dimensions> operator op(range<Dimensions> &lhs, int) noexcept { \
     range<Dimensions> old_lhs(lhs);                                            \
     for (int i = 0; i < Dimensions; ++i) {                                     \
       op lhs.common_array[i];                                                  \
@@ -225,9 +231,9 @@ template <int Dimensions = 1> class range : public detail::array<Dimensions> {
 };
 
 #ifdef __cpp_deduction_guides
-range(size_t)->range<1>;
-range(size_t, size_t)->range<2>;
-range(size_t, size_t, size_t)->range<3>;
+range(size_t) -> range<1>;
+range(size_t, size_t) -> range<2>;
+range(size_t, size_t, size_t) -> range<3>;
 #endif
 
 } // namespace _V1