Fix smithyFormat classpath serialization error (#161)

When smithyFormat fails on invalid syntax, the ModelSyntaxException
thrown inside the isolated URLClassLoader cannot be serialized by
Gradle's daemon (ShapeId is not visible to the daemon classloader).
Strip the cause chain at the worker boundary and rethrow as a plain
GradleException with only the root cause message.

Author: yasmewad

examples/base-plugin/failure-cases/syntax-error-format/build.gradle.kts

@@ -0,0 +1,14 @@
+// This example fails because smithyFormat is run on a model with a syntax error.
+// format is intentionally left enabled (the default) to exercise the smithyFormat task path.
+// the build must fail with the real syntax error message, not a secondary NoClassDefFoundError 
+// caused by smithy-model types escaping the isolated classloader.
+
+plugins {
+    id("java-library")
+    id("software.amazon.smithy.gradle.smithy-base").version("1.3.0")
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}

examples/base-plugin/failure-cases/syntax-error-format/model/main.smithy

@@ -0,0 +1,7 @@
+namespace smithy.example
+
+// Intentional syntax error: bare keyword with no identifier following it.
+// The smithyFormat task must fail with a clear "Cannot format invalid models" message,
+// not a secondary NoClassDefFoundError (regression for SMITHY-3541).
+structure
+

examples/base-plugin/failure-cases/syntax-error-format/settings.gradle.kts

@@ -0,0 +1,8 @@
+rootProject.name = "syntax-error-format"
+
+pluginManagement {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+    }
+}

examples/base-plugin/failure-cases/syntax-error-format/smithy-build.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0"
+}

smithy-base/src/it/java/software/amazon/smithy/gradle/SyntaxErrorFormatTest.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.gradle;
+
+import org.gradle.testkit.runner.BuildResult;
+import org.gradle.testkit.runner.GradleRunner;
+import org.gradle.testkit.runner.TaskOutcome;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Regression test for case when smithyFormat runs on a model with a syntax error,
+ * the build must fail with the real "Cannot format invalid models" message rather than a
+ * secondary NoClassDefFoundError caused by smithy-model types (e.g. ShapeId) escaping the
+ * isolated URLClassLoader and failing Gradle's daemon exception serializer.
+ */
+public class SyntaxErrorFormatTest {
+    @Test
+    public void formatTaskFailsWithReadableMessageOnSyntaxError() {
+        Utils.withCopy("base-plugin/failure-cases/syntax-error-format", buildDir -> {
+            BuildResult result = GradleRunner.create()
+                    .forwardOutput()
+                    .withProjectDir(buildDir)
+                    .withArguments("smithyFormat", "--stacktrace")
+                    .buildAndFail();
+
+            // The real error from the Smithy formatter must be present.
+            Assertions.assertTrue(
+                    result.getOutput().contains("Cannot format invalid models"),
+                    "Expected 'Cannot format invalid models' in :smithyFormat output but got:\n" + result.getOutput());
+
+            // A NoClassDefFoundError for ShapeId would indicate the classloader isolation bug has regressed.
+            Assertions.assertFalse(
+                    result.getOutput().contains("NoClassDefFoundError"),
+                    "Unexpected NoClassDefFoundError in output -- classloader isolation regression:\n"
+                            + result.getOutput());
+
+            // The smithyFormat task itself must be the one that failed, not some other task.
+            Assertions.assertEquals(TaskOutcome.FAILED, result.task(":smithyFormat").getOutcome());
+        });
+    }
+}

smithy-base/src/main/java/software/amazon/smithy/gradle/SmithyUtils.java

@@ -164,7 +164,20 @@ public void execute() {
                         smithyCliClass.getDeclaredMethod("run", List.class)
                                 .invoke(cli, getParameters().getArguments().get());
                     } catch (ReflectiveOperationException e) {
-                        throw new RuntimeException(e);
+                        // Unwrap to the root cause message. We intentionally do NOT reuse
+                        // unwrapException() here and do NOT attach the cause to GradleException:
+                        // smithy-model types (e.g. ModelSyntaxException, which references ShapeId)
+                        // are loaded only in the isolated URLClassLoader, so Gradle's daemon
+                        // serializer cannot see them. Attaching the cause chain would produce a
+                        // secondary NoClassDefFoundError that obscures the real error.
+                        Throwable cause = e;
+                        while (cause.getCause() != null) {
+                            cause = cause.getCause();
+                        }
+                        String message = cause.getMessage() != null
+                                ? cause.getMessage()
+                                : cause.getClass().getName();
+                        throw new GradleException(message);
                     }
                 });
             });