[SYCL] Consistent is_device_copyable for sycl::accessor by inteltdelisle · Pull Request #23250 · intel/llvm

inteltdelisle · 2026-09-23T18:21:02Z

sycl::is_device_copyable_v (and std::is_trivially_copyable_v) evaluated differently in host and device compilation, because the accessor special members are implemented differently under SYCL_DEVICE_ONLY.

For example, this compiled for the device but not for the host:

    static_assert(sycl::is_device_copyable_v<sycl::accessor<int, 1, sycl::access_mode::read_write>>);
    static_assert(sycl::is_device_copyable_v<sycl::local_accessor<int, 1>>);

Traits that differ between compilation passes can make constexpr/SFINAE results diverge between host and device.

Fix (behind -fpreview-breaking-changes, since it changes trivial copyability and is ABI-breaking):

Accessor types (accessor, local_accessor/local_accessor_base, host_accessor, and the image accessors) get a user-provided empty destructor, so they are consistently not trivially copyable and, per SYCL 2020, not implicitly device copyable. The copy/move constructors and assignment operators are explicitly defaulted to avoid issues with implicit functions.

Kernel parameter legality is now separate from device copyability (Not ABI-breaking):

New sycl::detail::is_legal_kernel_parameter trait that follows the SYCL 2020 "legal kernel parameter" rules: device copyable types, device-target accessors, arrays of legal types, and structs whose fields and bases are all legal and that contain a special SYCL type. Host-target accessors are rejected.

CheckDeviceCopyable is replaced by legal_kernel_parameters::validate_functor, which checks kernel captures against this trait. handler::set_arg has also been updated for consistency, reusing the trait were possible.
The integration header now specializes detail::is_legal_kernel_parameter instead of is_device_copyable for free-function structs that contain special types.

Compiler changes needed because accessors now have a non-trivial destructor:

SemaSYCL: finalize the destructor of special-object clones (FinalizeVarWithDestructor). Without this change, no definition is created for the dtor, since this is an inlined template, and calls to the destructor may fail to link.

CGDeclCXX: don't register a destructor for SYCL work-group-scope variables (e.g. the parallel_for_work_group kernel object). SYCL requires these destructors to have no effect and platforms are not required to declared/implement __cxx_atexit.

ESIMDVerifier: allow the local_accessor and local_accessor_base destructors.

Other: the accessor property-list conversion constructor is now constrained with enable_if instead of a static_assert, so CTAD and same-type copies pick the copy constructor.

Known limitation:

A struct that contains only legal members but has an illegal user-defined copy constructor or destructor is not detected.

Follow-up on the work-group scope attribute handling: #23461.

Tests:

New/updated tests for accessor special members, implicitly device copyable SYCL types, is_device_copyable (positive and negative), and set_arg. Each has RUN lines with and without -fpreview-breaking-changes.

Previously, is_device_copyable_v evaluated to different values for device and host code. Added explicit instantiation to consistently return false. Also added tests for other basic sycl types. Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

koparasy

A high level comment. What makes accessors change their behavior depending on host|device compilation?

inteltdelisle · 2026-09-24T12:26:28Z

A high level comment. What makes accessors change their behavior depending on host|device compilation?

By default is_device_copyable simply falls back on std::is_trivially_copyable, which in parts look at what the ctors are doing. sycl::accessor ctors are implemented differently depending on whether ___SYCL_DEVICE_ONLY__ is defined and that is what was causing the difference.

slawekptak · 2026-09-24T15:31:25Z

@inteltdelisle thanks for the fix. Could you please describe a bit of a background for this change - was some specific test failing? Thanks!
Adding @gmlueck

inteltdelisle · 2026-09-24T15:54:10Z

This fix was of result of a bug report submitted by @koparasy, who noted that the following code was inconsistent between device and host compilation:

#include <sycl/sycl.hpp>

using AccT = sycl::accessor<int, 1, sycl::access_mode::read_write>;
using LAccT = sycl::local_accessor<int, 1>;

static_assert(
   sycl::is_device_copyable_v<AccT>,
   "DEVICE pass: accessor IS device-copyable (trivially copyable here)");
static_assert(sycl::is_device_copyable_v<LAccT>,
             "DEVICE pass: local_accessor IS device-copyable here");
void f() {}

This code compiled for the device but not the host. The additional tests are simply there to verify the behavior of other basic sycl types.

Worth noting that I did not add a test to verify the behavior of is_device_copyable<buffer<...>>, I am not sure what the desired behavior is for that type.

gmlueck · 2026-09-24T19:22:29Z

+template <typename DataT, int Dimensions, access_mode AccessMode>
+struct is_device_copyable<host_accessor<DataT, Dimensions, AccessMode>>
+    : std::false_type {};
+


I wonder if we should change the implementation of the accessor instead of specializing is_device_copyable. For example, adding an empty user-provided destructor will cause the types to be non-trivially copyable.

This seems better than specializing the trait because it also makes is_trivially_copyable consistent between host and device.

I'll confirm locally whether that works. I was hesitant do change the accessor type itself, since that will have a less targeted impact. On the other hand the spec does state "Any type that is trivially copyable (as defined by the C++ core language) is implicitly device copyable." so that solution match the spec more closely.

@gmlueck Adding the dtors instead works locally. I can push that change if it's a preferred solution.

Spec-wise, I think it's better. Maybe @intel/llvm-reviewers-runtime can weigh in from the implementation side.

@inteltdelisle Changing a type's trivial-copyability is an ABI breaking change. I am on board with @gmlueck's suggestion, but I think we should add the user-provided destructor under PREVIEW_BREAKING_CHANGES flag.

@gmlueck Does SYCL require std::is_trivially_copyable_v<accessor> itself to evaluate consistently with sycl::is_device_copyable_v<accessor>? If not, wouldn't an explicit specialization of is_device_copyable be preferable to deliberately making the destructor non-trivial, since the latter changes additional C++ type properties unrelated to device copyability?

I am also wondering whether we actually want to break code that may rely on std::is_trivially_copyable_v<accessor>, even if the current behavior is somewhat obscure and differs between host and device compilation.

In general, I think it's bad for traits to evaluate differently in the host vs. the device compilation passes because this can lead to constexpr expressions having different values in the two passes. I think this could lead to quite confusing behavior (e.g. SFINAE constraints evaluating different in the two passes). Therefore, I think std::is_trivially_copyable_v<accessor> should evaluate the same in both passes.

TBH, I think the SYCL spec should be changed to guarantee that all standard traits and all SYCL traits evaluate the same in all compiler passes. This is a battle for another day, though.

I agree that changing the trait in the device compiler could potentially break an application (thought I think it's pretty unlikely). Therefore, I agree that it's better to make this change at the next major release.

@gmlueck I'm not super familiar with the release procedure yet, what does making this change at the next major release entail precisely? Do we merge this change in behind the PREVIEW_BREAKING_CHANGES?

Yes, that's right. You would merge the change as it is now in this PR behind the PREVIEW_BREAKING_CHANGES macro. At the next major release, we search for all these macros and enable the code they protect by default. Merging the changes now under the macro provides two benefits:

It allows user to see what potential breaking changes might be coming in the next major release by compiling with -fpreview-breaking-changes.

It lets us address issues like this early, rather than waiting until right before the next major release.

Accessors are no longer trivially copyable to match the sycl spec more closely. Change is behind PREVIEW_BREAKING_CHANGES. Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

Previous definition of CheckDeviceCopyable was relying on is_device_copyable as a shortcut for checking kernel parameter legality. Renamed to CheckKernelParametersAreLegal and re-wrote implementation to match the sycl 2020 spec more closely. Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

Since sycl::accessor is not trivially copyable, special types require the normal destructor machinery. Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

Copilot

🟡 Changes recommended

Kernel legality predicates currently admit invalid host accessors, host-target accessors, and arbitrary non-device-copyable arguments.

4 open findings

Reject host-target accessors as device kernel parameters · New
Reject host_accessor as an illegal kernel parameter · New
Restrict set_arg fallback to device-copyable kernel arguments · New
Enable preview-mode RUN coverage for accessor trait assertions · New

What changed in this PR

Makes accessor device-copyability consistent while preserving legal kernel captures.

Changes:

Adds non-trivial accessor destructors and explicit copy/move operations.
Reworks kernel-parameter legality checks.
Updates compiler lowering, ESIMD verification, and type-trait tests.

File	Description
`sycl/test/basic_tests/implicit_device_copyable_types.cpp`	Adds device-copyability assertions.
`sycl/include/sycl/handler.hpp`	Broadens `set_arg` eligibility.
`sycl/include/sycl/detail/kernel_launch_helper.hpp`	Invokes the renamed legality check.
`sycl/include/sycl/detail/is_device_copyable.hpp`	Implements recursive kernel-parameter legality checks.
`sycl/include/sycl/accessor.hpp`	Adds accessor destructors, special members, and legality traits.
`llvm/lib/SYCLLowerIR/ESIMD/ESIMDVerifier.cpp`	Allows local-accessor destructors in ESIMD.
`clang/lib/Sema/SemaSYCL.cpp`	Finalizes generated variables with destructors.
`clang/lib/CodeGen/CGDeclCXX.cpp`	Skips work-group-scope destructor registration.

🧠 Review effort: Balanced

Give feedback about Copilot approvals in this survey to enter a drawing for a $150 gift card.

+template <typename DataT, int Dimensions, access::mode AccessMode,
+          access::target AccessTarget, access::placeholder IsPlaceholder,
+          typename PropertyListT>
+struct is_sycl_accessor<accessor<DataT, Dimensions, AccessMode, AccessTarget,
+                                 IsPlaceholder, PropertyListT>>
+    : std::true_type {};


+template <typename DataT, int Dimensions, access_mode AccessMode>
+struct is_sycl_accessor<host_accessor<DataT, Dimensions, AccessMode>>
+    : std::true_type {};


+        || (!std::is_abstract_v<remove_cv_ref_t<T>> &&
+            !std::is_polymorphic_v<remove_cv_ref_t<T>> &&
+            std::is_destructible_v<remove_cv_ref_t<T>> &&
+            std::is_copy_constructible_v<remove_cv_ref_t<T>>);


+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  static_assert(!sycl::is_device_copyable_v<
+                sycl::accessor<int, 1, sycl::access_mode::read_write>>);
+  static_assert(!sycl::is_device_copyable_v<sycl::local_accessor<int, 1>>);
+  static_assert(!sycl::is_device_copyable_v<sycl::host_accessor<int, 1>>);
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES


elizabethandrews

Please add a FE test.

Updated is_legal_kernel_parameter to no longer accept any types composed of legal types. Changes to is device copyable extended to accessors. Added tests to cover new changes. Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

inteltdelisle · 2026-10-16T18:17:41Z

@gmlueck @koparasy Now that the tests are passing, I believe this is the set of changes that are needed to get is_device_copyable to be consistent for accessors across host and device. I made accessors no-longer trivially copyable by making the destructors non-trivial. I did not investigate the alternative solution of making the copy/move constructors non trivial. (Claude Code assumes that alternative isn't simpler).

Any thoughts on this approach?

koparasy · 2026-10-16T23:45:24Z

@gmlueck @koparasy Now that the tests are passing, I believe this is the set of changes that are needed to get is_device_copyable to be consistent for accessors across host and device. I made accessors no-longer trivially copyable by making the destructors non-trivial. I did not investigate the alternative solution of making the copy/move constructors non trivial. (Claude Code assumes that alternative isn't simpler).

Any thoughts on this approach?

I will come back monday about this. Initially I imagined this will be a trivial direction. I got that wrong. I need to reason about this PR a little deeper.

koparasy

With is_legal_kernel_parameter_v in ShouldEnableSetArg, the generic set_arg(int, T&&) is now enabled on host for every type is_sycl_accessor matches. Accessors with the default property list still reach the accessor-specific setArgHelper, but an accessor with a non-empty accessor_property_list, and unsampled_image_accessor / sampled_image_accessor, have no matching overload. IIUC they fall into the generic setArgHelper(T&&), which copies the host object bytes as kind_std_layout. Previously these failed to compile; now they compile and pass a wrong argument. Could you verify how those are resolved with some tests, and act accordingly?

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

inteltdelisle · 2026-10-19T20:31:55Z

With is_legal_kernel_parameter_v in ShouldEnableSetArg, the generic set_arg(int, T&&) is now enabled on host for every type is_sycl_accessor matches. Accessors with the default property list still reach the accessor-specific setArgHelper, but an accessor with a non-empty accessor_property_list, and unsampled_image_accessor / sampled_image_accessor, have no matching overload. IIUC they fall into the generic setArgHelper(T&&), which copies the host object bytes as kind_std_layout. Previously these failed to compile; now they compile and pass a wrong argument. Could you verify how those are resolved with some tests, and act accordingly?

I refined the condition so that it bahaviour is unchanged and added tests to confirm this. I also added a static assert to make sure the std layour is not used incorrectly.

koparasy · 2026-10-27T15:29:49Z

@inteltdelisle thanks. This is way more complex, invasive than what I had initially imagined. Saying this does not mean you are doing anything wrong. Friday I will try to spend some time to think if we can simplify this. But overall this looks correct to me now.

koparasy · 2026-11-02T14:46:18Z

@inteltdelisle a type is trivially copyable only if all of its copy/move operations are trivial, assignment included. An = default written outside the class counts as user-provided, so the operator is non-trivial but behaves exactly like the default. So if you have something like this:

// in class
accessor(const accessor &) = default;
accessor(accessor &&) = default;
accessor &operator=(const accessor &);
accessor &operator=(accessor &&);
// out of line
template <...> accessor<...> &accessor<...>::operator=(const accessor &) noexcept  = default;
template <...> accessor<...> &accessor<...>::operator=(accessor &&) noexcept  = default;

It should mark the accessors non copyable on both sides. By doing this, you no longer need the compiler changes (I guess).

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

inteltdelisle · 2026-11-02T20:04:21Z

@inteltdelisle a type is trivially copyable only if all of its copy/move operations are trivial, assignment included. An = default written outside the class counts as user-provided, so the operator is non-trivial but behaves exactly like the default. So if you have something like this:
// in class
accessor(const accessor &) = default;
accessor(accessor &&) = default;
accessor &operator=(const accessor &);
accessor &operator=(accessor &&);
// out of line
template <...> accessor<...> &accessor<...>::operator=(const accessor &) noexcept  = default;
template <...> accessor<...> &accessor<...>::operator=(accessor &&) noexcept  = default;
It should mark the accessors non copyable on both sides. By doing this, you no longer need the compiler changes (I guess).

I pushed a commit to switch to this approach. One side effect to note here is that std::is_trivially_destructible will now return different results for accessors on the host and device side.

koparasy · 2026-11-02T20:12:34Z

 /// static storage duration.
 static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
                            ConstantAddress Addr) {
+


Remove this.

koparasy · 2026-11-02T20:14:37Z

@inteltdelisle a type is trivially copyable only if all of its copy/move operations are trivial, assignment included. An = default written outside the class counts as user-provided, so the operator is non-trivial but behaves exactly like the default. So if you have something like this:
// in class
accessor(const accessor &) = default;
accessor(accessor &&) = default;
accessor &operator=(const accessor &);
accessor &operator=(accessor &&);
// out of line
template <...> accessor<...> &accessor<...>::operator=(const accessor &) noexcept  = default;
template <...> accessor<...> &accessor<...>::operator=(accessor &&) noexcept  = default;
It should mark the accessors non copyable on both sides. By doing this, you no longer need the compiler changes (I guess).
I pushed a commit to switch to this approach. One side effect to note here is that std::is_trivially_destructible will no return different results for accessors on the host and device side.

Do you mean "will NOT return .." or "will now return". If it is the later, we probably don't want that. Your previous solution in that case would be better.

inteltdelisle · 2026-11-02T20:17:35Z

Do you mean "will NOT return .." or "will now return". If it is the later, we probably don't want that. Your previous solution in that case would be better.

"Will now return". Although it's more accurate to say, will revert to destructors only being trivially destructible on the device, which is the current status before this PR.

This reverts commit 9da10c4.

…//github.com/inteltdelisle/llvm into tdelisle/runtime/accessor_is_device_copyable

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

elizabethandrews

@tahonermann can you also take a look please. The code changes look ok to me but I am not sure if the functional change has consequences I am not thinking off.

elizabethandrews · 2026-11-06T14:48:25Z

+  // work-group local memory. There is no program exit on the device to run
+  // their destructor at, and SYCL 2020 requires the destructors of device
+  // copyable types to have no effect on the device, so don't register one.
+  if (CGF.getLangOpts().SYCLIsDevice) {


The comment does not fully cover the actual code changes. All locals are affected IIUC. The SYCL 2020 rule refers to only kernel captures but this change affects a variable declared in the kernel bocy as well right?.

In any case is this code even hit after after #23702 ?

I believe you are correct that the changes to this file can be reverted once #23702 is in. But I'm not sure whether #23702 should go in until #23700 is fixed. So I'm not entirely sure how to proceed here.

I think you can just update the comment to describe the status as well. Maybe add a FIXME so we can keep track of its removal.

elizabethandrews · 2026-11-06T14:56:14Z

+// Special type with a non-trivial destructor, like the device accessors. The
+// destructor of the object created in the kernel to pass to the free function
+// must be instantiated and defined, not just declared.
+template <typename DataT>


I'm not sure if we should update the mock headers to include the destructor under some macro for now? @tahonermann can you weigh in?

elizabethandrews · 2026-11-06T15:31:46Z

@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -fsycl-is-device -triple spir64-unknown-unknown -disable-llvm-passes -Wno-sycl-work-group-dtor -emit-llvm %s -o - | FileCheck %s


I see you passed -Wno-sycl-work-group-dtor. This PR adds a destructor to accessors, so wouldn't that mean that this warning would fire for every parallel_for_work_group kernel capturing an accessor ? Is this expected behavior?

elizabethandrews · 2026-11-06T15:32:46Z

+  q.submit([&](handler &h) {
+    NonTrivial Captured;
+    h.parallel_for_work_group<class kernel>(
+        range<1>{1}, range<1>{1}, [=](group<1> G) { (void)Captured; });


Could you also add a local declared inside the parallel_for_work_group body with a non-trivial destructor (not captured).

elizabethandrews · 2026-11-06T15:34:08Z

 // CHECK-NEXT:  %0 = load ptr addrspace(4), ptr addrspace(4) %__arg__obj.addr.ascast, align 8
 // CHECK-NEXT:  call spir_func void @{{.*}}annotated_ptr{{.*}}__init{{.*}}
+
+// Special type with a non-trivial destructor, like the device accessors. The


Nit: Comment says "the device accessors". Test is for __SYCL_TYPE(work_group_memory)

inteltdelisle requested a review from a team as a code owner September 23, 2026 18:21

inteltdelisle requested review from 0x12CC, koparasy and slawekptak September 23, 2026 18:21

koparasy reviewed Sep 23, 2026

View reviewed changes

gmlueck reviewed Sep 24, 2026

View reviewed changes

inteltdelisle added 6 commits September 25, 2026 09:45

[SYCL] added user-defined destructors to accessors

4771df0

Accessors are no longer trivially copyable to match the sycl spec more closely. Change is behind PREVIEW_BREAKING_CHANGES. Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

Fixed formatting missed by git clang-format

4bc0a59

added exception for accessor to is_device_copyable

74cbd87

formatting

3b87544

[SYCL] update handling of sycl special types to finalize destructor

8d933d1

Since sycl::accessor is not trivially copyable, special types require the normal destructor machinery. Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

inteltdelisle requested a review from a team as a code owner October 5, 2026 18:57

inteltdelisle added 2 commits October 6, 2026 17:31

[SYCL] Do not emit destructors for device work groups.

faecfa9

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

[SYCL] Add local accessor dtor to verified esimd functions.

37e133a

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

inteltdelisle requested a review from a team as a code owner October 7, 2026 13:50

inteltdelisle added 3 commits October 7, 2026 12:40

Merge branch 'sycl' into tdelisle/runtime/accessor_is_device_copyable

82c5e91

[SYCL] Add explicit copy and move ctor declarations.

47f7932

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

[SYCL] Relax deduction rules for sycl::handler::set_arg.

e966767

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

inteltdelisle requested a balanced review from Copilot October 8, 2026 14:29

Copilot started reviewing on behalf of inteltdelisle October 8, 2026 14:44

View session

Copilot AI reviewed Oct 8, 2026

View reviewed changes

elizabethandrews reviewed Oct 10, 2026

View reviewed changes

Comment thread clang/lib/CodeGen/CGDeclCXX.cpp Resolved

Comment thread clang/lib/CodeGen/CGDeclCXX.cpp Resolved

inteltdelisle mentioned this pull request Oct 13, 2026

[SYCL] Destructors in work-group-scope causing issues. #23461

Open

inteltdelisle added 2 commits October 13, 2026 15:36

Merge branch 'sycl' into tdelisle/runtime/accessor_is_device_copyable

7b15c7c

inteltdelisle mentioned this pull request Oct 16, 2026

[SYCL][E2E] Failures in unrelated tests on Intel Arc GPUs (Level Zero) with parallel E2E runs on Linux (B580) and Windows (A770) #23521

Open

koparasy reviewed Oct 19, 2026

View reviewed changes

Address review comments.

0adb720

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

Merge branch 'sycl' into tdelisle/runtime/accessor_is_device_copyable

f5b64c5

inteltdelisle mentioned this pull request Oct 26, 2026

[SYCL] Add helper to check variable work group scope. #23626

Closed

Alternative solution using operator= instead of destructor.

9da10c4

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

koparasy approved these changes Nov 2, 2026

View reviewed changes

inteltdelisle added 5 commits November 3, 2026 08:41

Revert "Alternative solution using operator= instead of destructor."

6c63dd6

This reverts commit 9da10c4.

Merge branch 'tdelisle/runtime/accessor_is_device_copyable' of https:…

0bcf79c

…//github.com/inteltdelisle/llvm into tdelisle/runtime/accessor_is_device_copyable

Merge branch 'sycl' into tdelisle/runtime/accessor_is_device_copyable

9ab98ad

New code now also uses CGSYCLRuntime::getWorkGroupVarKind.

a70516d

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

[SYCL] added some FE testing.

1ad3ee2

Signed-off-by: Delisle, Thierry <thierry.delisle@intel.com>

elizabethandrews reviewed Nov 6, 2026

View reviewed changes

		@@ -0,0 +1,29 @@
		// RUN: %clang_cc1 -fsycl-is-device -triple spir64-unknown-unknown -disable-llvm-passes -Wno-sycl-work-group-dtor -emit-llvm %s -o - \| FileCheck %s

Conversation

inteltdelisle commented Sep 23, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Fix (behind -fpreview-breaking-changes, since it changes trivial copyability and is ABI-breaking):

Kernel parameter legality is now separate from device copyability (Not ABI-breaking):

Compiler changes needed because accessors now have a non-trivial destructor:

Known limitation:

Tests:

Uh oh!

koparasy left a comment

Choose a reason for hiding this comment

Uh oh!

inteltdelisle commented Sep 24, 2026

Uh oh!

slawekptak commented Sep 24, 2026

Uh oh!

inteltdelisle commented Sep 24, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

🟡 Changes recommended

Uh oh!

elizabethandrews left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

inteltdelisle commented Oct 16, 2026

Uh oh!

koparasy commented Oct 16, 2026

Uh oh!

koparasy left a comment

Choose a reason for hiding this comment

Uh oh!

inteltdelisle commented Oct 19, 2026

Uh oh!

koparasy commented Oct 27, 2026

Uh oh!

koparasy commented Nov 2, 2026

Uh oh!

inteltdelisle commented Nov 2, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

koparasy commented Nov 2, 2026

Uh oh!

inteltdelisle commented Nov 2, 2026

Uh oh!

elizabethandrews left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

inteltdelisle commented Sep 23, 2026 •

edited

Loading

inteltdelisle commented Nov 2, 2026 •

edited

Loading