update the way we get singleton resource suffix (#3119)

* update the way we get singleton resource suffix

* regenerate

* regenerate

* add a more complicated test case

Author: ArcturusZhang

samples/Azure.Management.Storage/Generated/BlobContainerResource.cs

@@ -6,31 +6,49 @@
 using System.Linq;
 using AutoRest.CSharp.Input;
 using AutoRest.CSharp.Mgmt.Models;
+using AutoRest.CSharp.Utilities;
 
 namespace AutoRest.CSharp.Mgmt.Decorator;
 
 internal static class SingletonDetection
 {
     private static string[] SingletonKeywords = { "default", "latest", "current" };
 
-    private static ConcurrentDictionary<OperationSet, string?> _singletonResourceCache = new ConcurrentDictionary<OperationSet, string?>();
+    private static ConcurrentDictionary<OperationSet, SingletonResourceSuffix?> _singletonResourceCache = new ConcurrentDictionary<OperationSet, SingletonResourceSuffix?>();
 
     public static bool IsSingletonResource(this OperationSet operationSet)
     {
         return operationSet.TryGetSingletonResourceSuffix(out _);
     }
 
-    public static bool TryGetSingletonResourceSuffix(this OperationSet operationSet, [MaybeNullWhen(false)] out string singletonIdSuffix)
+    public static bool TryGetSingletonResourceSuffix(this OperationSet operationSet, [MaybeNullWhen(false)] out SingletonResourceSuffix suffix)
     {
-        singletonIdSuffix = null;
-        if (_singletonResourceCache.TryGetValue(operationSet, out singletonIdSuffix))
-            return singletonIdSuffix != null;
+        suffix = null;
+        if (_singletonResourceCache.TryGetValue(operationSet, out suffix))
+            return suffix != null;
 
-        bool result = IsSingleton(operationSet, out singletonIdSuffix);
-        _singletonResourceCache.TryAdd(operationSet, singletonIdSuffix);
+        bool result = IsSingleton(operationSet, out var singletonIdSuffix);
+        suffix = ParseSingletonIdSuffix(operationSet, singletonIdSuffix);
+        _singletonResourceCache.TryAdd(operationSet, suffix);
         return result;
     }
 
+    private static SingletonResourceSuffix? ParseSingletonIdSuffix(OperationSet operationSet, string? singletonIdSuffix)
+    {
+        if (singletonIdSuffix == null)
+            return null;
+
+        var segments = singletonIdSuffix.Split('/', System.StringSplitOptions.RemoveEmptyEntries);
+
+        // check if even segments
+        if (segments.Length % 2 != 0)
+        {
+            throw new ErrorHelpers.ErrorException($"the singleton suffix set for operation set {operationSet.RequestPath} must have even segments, but got {singletonIdSuffix}");
+        }
+
+        return SingletonResourceSuffix.Parse(segments);
+    }
+
     private static bool IsSingleton(OperationSet operationSet, [MaybeNullWhen(false)] out string singletonIdSuffix)
     {
         // we should first check the configuration for the singleton settings

samples/Azure.Management.Storage/Generated/StorageAccountResource.cs

@@ -342,11 +342,12 @@ protected string GetResourceCollectionMethodArgumentList(ResourceCollection reso
             return string.Join(", ", GetParametersForCollectionEntry(resourceCollection).Select(p => p.Name));
         }
 
-        protected virtual void WriteSingletonResourceEntry(Resource resource, string singletonResourceIdSuffix, MethodSignature signature)
+        protected virtual void WriteSingletonResourceEntry(Resource resource, SingletonResourceSuffix singletonResourceIdSuffix, MethodSignature signature)
         {
             // we cannot guarantee that the singleResourceSuffix can only have two segments (it has many different cases),
             // therefore instead of using the extension method of ResourceIdentifier, we are just concatting this as a string
-            _writer.Line($"return new {resource.Type.Name}({ArmClientReference}, new {typeof(ResourceIdentifier)}(Id.ToString() + \"/{singletonResourceIdSuffix}\"));");
+            _writer.UseNamespace(typeof(ResourceIdentifier).Namespace!);
+            _writer.Line($"return new {resource.Type.Name}({ArmClientReference}, {singletonResourceIdSuffix.BuildResourceIdentifier($"Id")});");
         }
 
         protected virtual MethodSignatureModifiers GetMethodModifiers() => Public | Virtual;

samples/Azure.ResourceManager.Sample/Generated/VirtualMachineScaleSetResource.cs

@@ -11,6 +11,7 @@
 using AutoRest.CSharp.Utilities;
 using AutoRest.CSharp.Output.Models.Requests;
 using static AutoRest.CSharp.Output.Models.MethodSignatureModifiers;
+using Azure.Core;
 
 namespace AutoRest.CSharp.Mgmt.Generation
 {
@@ -89,8 +90,9 @@ protected override void WriteResourceCollectionEntry(ResourceCollection resource
             }
         }
 
-        protected override void WriteSingletonResourceEntry(Resource resource, string singletonResourceSuffix, MethodSignature signature)
+        protected override void WriteSingletonResourceEntry(Resource resource, SingletonResourceSuffix singletonResourceSuffix, MethodSignature signature)
         {
+            _writer.UseNamespace(typeof(ResourceIdentifier).Namespace!);
             if (IsArmCore)
             {
                 base.WriteSingletonResourceEntry(resource, singletonResourceSuffix, signature);

src/AutoRest.CSharp/Mgmt/Decorator/SingletonDetection.cs

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AutoRest.CSharp.Generation.Writers;
+using Azure.Core;
+
+namespace AutoRest.CSharp.Mgmt.Models
+{
+    internal class SingletonResourceSuffix
+    {
+        public static SingletonResourceSuffix Parse(string[] segments)
+        {
+            // put the segments in pairs
+            var pairs = new List<(string Key, string Value)>();
+            for (int i = 0; i < segments.Length; i += 2)
+            {
+                pairs.Add((segments[i], segments[i + 1]));
+            }
+
+            return new SingletonResourceSuffix(pairs);
+        }
+
+        private IReadOnlyList<(string Key, string Value)> _pairs;
+
+        private SingletonResourceSuffix(IReadOnlyList<(string Key, string Value)> pairs)
+        {
+            _pairs = pairs;
+        }
+
+        public FormattableString BuildResourceIdentifier(FormattableString originalId)
+        {
+            var list = new List<FormattableString>() { originalId };
+            for (int i = 0; i < _pairs.Count; i++)
+            {
+                var key = _pairs[i].Key;
+                var value = _pairs[i].Value;
+                if (key == Segment.Providers)
+                {
+                    // when we have a providers, we must have a next pair
+                    i++;
+                    var nextKey = _pairs[i].Key;
+                    var nextValue = _pairs[i].Value;
+                    list.Add($"{nameof(ResourceIdentifier.AppendProviderResource)}({value:L}, {nextKey:L}, {nextValue:L})");
+                }
+                else
+                {
+                    // if not, we just call the method to append this pair
+                    list.Add($"{nameof(ResourceIdentifier.AppendChildResource)}({key:L}, {value:L})");
+                }
+            }
+
+            return list.Join(".");
+        }
+    }
+}

src/AutoRest.CSharp/Mgmt/Generation/MgmtClientBaseWriter.cs

@@ -170,7 +170,7 @@ private static IEnumerable<Operation> GetClientOperations(OperationSet operation
 
         public bool IsSingleton => SingletonResourceIdSuffix != null;
 
-        public string? SingletonResourceIdSuffix { get; }
+        public SingletonResourceSuffix? SingletonResourceIdSuffix { get; }
 
         private bool? _isTaggable;
         public bool IsTaggable => GetIsTaggable();

src/AutoRest.CSharp/Mgmt/Generation/MgmtExtensionWriter.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License
+
+using System;
+using AutoRest.CSharp.Generation.Writers;
+using AutoRest.CSharp.Mgmt.Models;
+using NUnit.Framework;
+
+namespace AutoRest.TestServer.Tests.Mgmt.Unit
+{
+    public class SingletonResourceSuffixTests
+    {
+        [TestCase("test/default", @"Id.AppendChildResource(""test"", ""default"")")]
+        [TestCase("providers/Microsoft.Compute/test/default", @"Id.AppendProviderResource(""Microsoft.Compute"", ""test"", ""default"")")]
+        [TestCase("providers/Microsoft.Compute/test1/name/test2/default", @"Id.AppendProviderResource(""Microsoft.Compute"", ""test1"", ""name"").AppendChildResource(""test2"", ""default"")")]
+        [TestCase("providers/Microsoft.Compute/test1/name/test2/name2/test3/default", @"Id.AppendProviderResource(""Microsoft.Compute"", ""test1"", ""name"").AppendChildResource(""test2"", ""name2"").AppendChildResource(""test3"", ""default"")")]
+        public void ValidateBuildResourceIdentifier(string suffixString, string expected)
+        {
+            var segments = suffixString.Split('/', StringSplitOptions.RemoveEmptyEntries);
+            var suffix = SingletonResourceSuffix.Parse(segments);
+            var result = suffix.BuildResourceIdentifier($"Id");
+            var writer = new CodeWriter();
+            Assert.AreEqual(expected, writer.Append(result).ToString(false).Trim());
+        }
+    }
+}

src/AutoRest.CSharp/Mgmt/Models/SingletonResourceSuffix.cs

@@ -9,7 +9,6 @@ namespace AutoRest.TestServer.Tests.Mgmt
 {
     public class StringExtensionsTests
     {
-
         [TestCase("MetadataRole", "MetadataRoles")]
         [TestCase("KeyInformation", "AllKeyInformation")]
         [TestCase("RoleMetadata", "AllRoleMetadata")]