Guard optional path parameters before formatting

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/RestClientProvider.cs

@@ -908,6 +908,9 @@ private void AddUriSegments(
                  */
                 var isClientParameter = ClientProvider.ClientParameters.Any(p => string.Equals(p.Name, paramName, StringComparison.OrdinalIgnoreCase))
                     || _inputClient.Parameters.Any(p => p is InputMethodParameter { ParamAlias: string alias } && string.Equals(alias, paramName, StringComparison.OrdinalIgnoreCase));
+                bool willEmitNullGuard = inputParamMap.TryGetValue(paramName, out var pathParamForGuard)
+                    && pathParamForGuard.IsRequired == false
+                    && (pathParamForGuard is InputPathParameter || pathParamForGuard is InputEndpointParameter);
                 CSharpType? type;
                 SerializationFormat? serializationFormat;
                 ValueExpression? valueExpression;
@@ -942,19 +945,40 @@ private void AddUriSegments(
                 }
                 else
                 {
-                    valueExpression = type?.Equals(typeof(string)) == true
+                    // The null check must always be performed against the raw, still-nullable value:
+                    // for enums, GetParamInfo has already serialized valueExpression (e.g. via a
+                    // null-conditional ToString call), so capture the check subject before any further
+                    // unwrapping below could make it unconditionally dereference a null value.
+                    var nullCheckExpression = valueExpression;
+                    if (type is { IsNullable: true, IsValueType: true, IsEnum: false })
+                    {
+                        valueExpression = willEmitNullGuard
+                            ? valueExpression.Property(nameof(Nullable<int>.Value))
+                            : valueExpression.NullConditional();
+                    }
+                    else if (type is { IsNullable: true, IsEnum: true } && willEmitNullGuard && paramMap.TryGetValue(paramName, out var enumParamProvider))
+                    {
+                        // Already inside a null guard: check the raw nullable field directly (instead of
+                        // repeating the null-conditional serialized expression) and unwrap it via .Value
+                        // before serializing, avoiding both a redundant guard invocation and a duplicate
+                        // ToString call.
+                        ValueExpression rawEnumVariable = enumParamProvider.Field is null ? enumParamProvider : enumParamProvider.Field;
+                        nullCheckExpression = rawEnumVariable;
+                        valueExpression = type.ToSerial(rawEnumVariable.Property(nameof(Nullable<int>.Value)));
+                    }
+                    valueExpression = type?.Equals(typeof(string)) == true || type?.IsEnum == true
                         ? valueExpression
                         : valueExpression.Invoke(nameof(ToString), toStringParams);
                     MethodBodyStatement statement;
-                    if (inputParam?.IsRequired == false)
+                    if (willEmitNullGuard)
                     {
                         bool shouldPrependWithPathSeparator = separatorDeferred || (path.Length > 0 && path[^1] != '/');
                         List<MethodBodyStatement> appendPathStatements = shouldPrependWithPathSeparator
                             ? [uri.AppendPath(Literal("/"), false).Terminate(), uri.AppendPath(valueExpression, escape).Terminate()]
                             : [uri.AppendPath(valueExpression, escape).Terminate()];
                         statement = BuildQueryOrHeaderOrPathParameterNullCheck(
                             type,
-                            valueExpression,
+                            nullCheckExpression,
                             appendPathStatements);
                     }
                     else

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/RestClientProviderTests.cs

@@ -1164,6 +1164,58 @@ public void TestBuildCreateRequestMethodWithPathParameters()
             Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
         }
 
+        [TestCase(true)]
+        [TestCase(false)]
+        public void NullableDatePathParameterIsGuardedBeforeFormatting(bool isRequired)
+        {
+            var dateType = new InputDateTimeType(
+                DateTimeKnownEncoding.Rfc7231,
+                "utcDateTime",
+                "TypeSpec.utcDateTime",
+                InputPrimitiveType.String);
+            var operation = InputFactory.Operation(
+                "GetThing",
+                parameters: [InputFactory.PathParameter("requestOn", dateType, isRequired: isRequired)],
+                path: "/things/{requestOn}");
+            var serviceMethod = InputFactory.BasicServiceMethod(
+                "GetThing",
+                operation,
+                parameters:
+                [
+                    InputFactory.MethodParameter(
+                        "requestOn",
+                        dateType,
+                        isRequired: isRequired,
+                        location: InputRequestLocation.Path)
+                ]);
+            var client = InputFactory.Client("TestClient", methods: [serviceMethod]);
+            var restClient = new ClientProvider(client).RestClient;
+
+            var file = new TypeProviderWriter(restClient).Write();
+            Assert.AreEqual(Helpers.GetExpectedFromFile(parameters: isRequired.ToString()), file.Content);
+        }
+
+        [Test]
+        public void OptionalEnumPathParameterIsNotUnwrapped()
+        {
+            var enumType = InputFactory.StringEnum(
+                "Color",
+                [("Red", "red"), ("Blue", "blue")],
+                isExtensible: true);
+            var operation = InputFactory.Operation(
+                "GetThing",
+                parameters: [InputFactory.PathParameter("color", enumType, isRequired: false, scope: InputParameterScope.Client)],
+                path: "/things/{color}");
+            var serviceMethod = InputFactory.BasicServiceMethod(
+                "GetThing",
+                operation);
+            var client = InputFactory.Client("TestClient", methods: [serviceMethod]);
+            var restClient = new ClientProvider(client).RestClient;
+
+            var file = new TypeProviderWriter(restClient).Write();
+            Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
+        }
+
         // An optional trailing path parameter must not emit a dangling separator when null.
         // e.g. "/certificates/{certificateName}/{certificateVersion}" with a null version
         // should produce "/certificates/{name}", not "/certificates/{name}/".

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/TestData/RestClientProviderTests/NullableDatePathParameterIsGuardedBeforeFormatting(False).cs

@@ -0,0 +1,32 @@
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.ClientModel.Primitives;
+
+namespace Sample
+{
+    public partial class TestClient
+    {
+        private static global::System.ClientModel.Primitives.PipelineMessageClassifier _pipelineMessageClassifier200;
+
+        private static global::System.ClientModel.Primitives.PipelineMessageClassifier PipelineMessageClassifier200 => _pipelineMessageClassifier200 ??= global::System.ClientModel.Primitives.PipelineMessageClassifier.Create(stackalloc ushort[] { 200 });
+
+        internal global::System.ClientModel.Primitives.PipelineMessage CreateGetThingRequest(global::System.DateTimeOffset? requestOn, global::System.ClientModel.Primitives.RequestOptions options)
+        {
+            global::Sample.ClientUriBuilder uri = new global::Sample.ClientUriBuilder();
+            uri.Reset(_endpoint);
+            uri.AppendPath("/things", false);
+            if ((requestOn != null))
+            {
+                uri.AppendPath("/", false);
+                uri.AppendPath(requestOn.Value.ToString("R"), true);
+            }
+            global::System.ClientModel.Primitives.PipelineMessage message = Pipeline.CreateMessage(uri.ToUri(), "GET", PipelineMessageClassifier200);
+            global::System.ClientModel.Primitives.PipelineRequest request = message.Request;
+            message.Apply(options);
+            return message;
+        }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/TestData/RestClientProviderTests/NullableDatePathParameterIsGuardedBeforeFormatting(True).cs

@@ -0,0 +1,28 @@
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.ClientModel.Primitives;
+
+namespace Sample
+{
+    public partial class TestClient
+    {
+        private static global::System.ClientModel.Primitives.PipelineMessageClassifier _pipelineMessageClassifier200;
+
+        private static global::System.ClientModel.Primitives.PipelineMessageClassifier PipelineMessageClassifier200 => _pipelineMessageClassifier200 ??= global::System.ClientModel.Primitives.PipelineMessageClassifier.Create(stackalloc ushort[] { 200 });
+
+        internal global::System.ClientModel.Primitives.PipelineMessage CreateGetThingRequest(global::System.DateTimeOffset requestOn, global::System.ClientModel.Primitives.RequestOptions options)
+        {
+            global::Sample.ClientUriBuilder uri = new global::Sample.ClientUriBuilder();
+            uri.Reset(_endpoint);
+            uri.AppendPath("/things/", false);
+            uri.AppendPath(requestOn.ToString("R"), true);
+            global::System.ClientModel.Primitives.PipelineMessage message = Pipeline.CreateMessage(uri.ToUri(), "GET", PipelineMessageClassifier200);
+            global::System.ClientModel.Primitives.PipelineRequest request = message.Request;
+            message.Apply(options);
+            return message;
+        }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/TestData/RestClientProviderTests/OptionalEnumPathParameterIsNotUnwrapped.cs

@@ -0,0 +1,31 @@
+// <auto-generated/>
+
+#nullable disable
+
+using System.ClientModel.Primitives;
+
+namespace Sample
+{
+    public partial class TestClient
+    {
+        private static global::System.ClientModel.Primitives.PipelineMessageClassifier _pipelineMessageClassifier200;
+
+        private static global::System.ClientModel.Primitives.PipelineMessageClassifier PipelineMessageClassifier200 => _pipelineMessageClassifier200 ??= global::System.ClientModel.Primitives.PipelineMessageClassifier.Create(stackalloc ushort[] { 200 });
+
+        internal global::System.ClientModel.Primitives.PipelineMessage CreateGetThingRequest(global::System.ClientModel.Primitives.RequestOptions options)
+        {
+            global::Sample.ClientUriBuilder uri = new global::Sample.ClientUriBuilder();
+            uri.Reset(_endpoint);
+            uri.AppendPath("/things", false);
+            if ((_color != null))
+            {
+                uri.AppendPath("/", false);
+                uri.AppendPath(_color.Value.ToString(), true);
+            }
+            global::System.ClientModel.Primitives.PipelineMessage message = Pipeline.CreateMessage(uri.ToUri(), "GET", PipelineMessageClassifier200);
+            global::System.ClientModel.Primitives.PipelineRequest request = message.Request;
+            message.Apply(options);
+            return message;
+        }
+    }
+}