Build CreateResourceIdentifierMethod. (Azure#51071)

* Build CreateResourceIdentifierMethod.

* refine.

* address review comments.

* address review comments.

Author: haiyuazhang

eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Models/RequestPath.cs

@@ -149,9 +149,14 @@ public static implicit operator string(RequestPath requestPath)
 
         public static bool IsSegmentConstant(string segment)
         {
-            var trimmed = segment.TrimStart('{').TrimEnd('}');
+            var trimmed = TrimSegment(segment);
             var isScope = trimmed == "scope";
             return !isScope && !segment.StartsWith('{');
         }
+
+        public static string TrimSegment(string segment)
+        {
+            return segment.TrimStart('{').TrimEnd('}');
+        }
     }
 }

eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs

@@ -24,6 +24,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Text;
 using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
 using OperationKind = Azure.Generator.Management.Models.OperationKind;
 
@@ -53,13 +54,19 @@ public static ResourceClientProvider Create(InputModelType model, ResourceMetada
         private bool _hasGetMethod = false;
         private bool _shouldGenerateTagMethods = false;
 
+        private RequestPath _requestPath;
+        private ResourceMetadata _resourceMetadata;
+        private InputOperation _inputOperationForRequestPath;
+
         protected ClientProvider _restClientProvider;
         protected FieldProvider _clientDiagnosticsField;
         protected FieldProvider _clientField;
 
         private protected ResourceClientProvider(InputModelType model, ResourceMetadata resourceMetadata)
         {
             IsSingleton = resourceMetadata.IsSingleton;
+            _resourceMetadata = resourceMetadata;
+            _inputOperationForRequestPath = ManagementClientGenerator.Instance.InputLibrary.GetMethodByCrossLanguageDefinitionId(_resourceMetadata.Methods.First().Id)!.Operation;
             ResourceScope = resourceMetadata.ResourceScope;
             var resourceType = resourceMetadata.ResourceType;
             _hasGetMethod = resourceMetadata.Methods.Any(m => m.Kind == OperationKind.Get);
@@ -70,15 +77,15 @@ private protected ResourceClientProvider(InputModelType model, ResourceMetadata
             SpecName = model.Name.ToIdentifierName();
 
             // We should be able to assume that all operations in the resource client are for the same resource
-            var requestPath = new RequestPath(ManagementClientGenerator.Instance.InputLibrary.GetMethodByCrossLanguageDefinitionId(resourceMetadata.Methods.First().Id)!.Operation.Path);
+            _requestPath = new RequestPath(_inputOperationForRequestPath.Path);
             _resourceServiceMethods = resourceMetadata.Methods.Select(m => (m.Kind, ManagementClientGenerator.Instance.InputLibrary.GetMethodByCrossLanguageDefinitionId(m.Id)!));
             ResourceData = ManagementClientGenerator.Instance.TypeFactory.CreateModel(model)!;
 
             // TODO: handle multiple clients in the future, for now we assume that there is only one client for the resource.
             var inputClients = resourceMetadata.Methods.Select(m => ManagementClientGenerator.Instance.InputLibrary.GetClientByMethod(ManagementClientGenerator.Instance.InputLibrary.GetMethodByCrossLanguageDefinitionId(m.Id)!)!).Distinct();
             _restClientProvider = ManagementClientGenerator.Instance.TypeFactory.CreateClient(inputClients.First())!;
 
-            ContextualParameters = GetContextualParameters(requestPath);
+            ContextualParameters = GetContextualParameters(_requestPath);
 
             _dataField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, ResourceData.Type, "_data", this);
             _clientDiagnosticsField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, typeof(ClientDiagnostics), $"_{SpecName.ToLower()}ClientDiagnostics", this);
@@ -89,6 +96,8 @@ private protected ResourceClientProvider(InputModelType model, ResourceMetadata
 
         internal ResourceCollectionClientProvider? ResourceCollection { get; private set; }
 
+        private InputOperation InputOperationForRequestPath => _inputOperationForRequestPath;
+
         private IReadOnlyList<string> GetContextualParameters(string contextualRequestPath)
         {
             var contextualParametersList = new List<string>();
@@ -225,6 +234,65 @@ protected MethodProvider BuildValidateResourceIdMethod()
             return new MethodProvider(signature, bodyStatements, this);
         }
 
+        private CSharpType GetPathParameterType(string parameterName)
+        {
+            var operation = InputOperationForRequestPath;
+
+            var operationParameter = operation.Parameters.First(p => p.Name.Equals(parameterName, StringComparison.OrdinalIgnoreCase));
+
+            var csharpType = ManagementClientGenerator.Instance.TypeFactory.CreateCSharpType(operationParameter.Type) ?? throw new InvalidOperationException($"Could not create C# type for parameter '{parameterName}' with type '{operationParameter.Type}' in operation '{operation.Name}'.");
+            return parameterName switch
+            {
+                "subscriptionId" when csharpType.Equals(typeof(Guid)) => typeof(string),
+                // Cases will be added later
+                _ => csharpType
+            };
+        }
+
+        private MethodProvider BuildCreateResourceIdentifierMethod()
+        {
+            var parameters = new List<ParameterProvider>();
+            var formatBuilder = new StringBuilder();
+            var refCount = 0;
+
+            foreach (var segment in _requestPath)
+            {
+                bool isConstant = RequestPath.IsSegmentConstant(segment);
+
+                if (isConstant)
+                {
+                    formatBuilder.Append($"/{segment}");
+                }
+                else
+                {
+                    if (formatBuilder.Length > 0)
+                    {
+                        formatBuilder.Append('/');
+                    }
+                    var trimmed = RequestPath.TrimSegment(segment);
+                    var parameter = new ParameterProvider(trimmed, $"The {trimmed}", GetPathParameterType(trimmed));
+                    parameters.Add(parameter);
+                    formatBuilder.Append($"{{{refCount++}}}");
+                }
+            }
+
+            var signature = new MethodSignature(
+                "CreateResourceIdentifier",
+                $"Generate the resource identifier for this resource.",
+                MethodSignatureModifiers.Public | MethodSignatureModifiers.Static,
+                typeof(ResourceIdentifier),
+                null,
+                parameters);
+
+            var bodyStatements = new MethodBodyStatement[]
+            {
+                Declare("resourceId", typeof(string), new FormattableStringExpression(formatBuilder.ToString(), parameters.Select(p => p.AsExpression()).ToArray()), out var resourceIdVar),
+                Return(New.Instance(typeof(ResourceIdentifier), resourceIdVar))
+            };
+
+            return new MethodProvider(signature, bodyStatements, this);
+        }
+
         protected virtual ScopedApi<ResourceType> ResourceTypeExpression => _resourceTypeField.As<ResourceType>();
 
         protected internal virtual CSharpType ResourceClientCSharpType => Type;
@@ -283,6 +351,7 @@ protected override MethodProvider[] BuildMethods()
 
             var methods = new List<MethodProvider>
             {
+                BuildCreateResourceIdentifierMethod(),
                 BuildValidateResourceIdMethod()
             };
             methods.AddRange(operationMethods);

eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/test/Providers/ResourceClientProviderTests.cs

@@ -132,5 +132,34 @@ public void Verify_ConstructorWithId()
             var exptected = Helpers.GetExpectedFromFile();
             Assert.AreEqual(exptected, bodyStatements);
         }
+
+        [TestCase]
+        public void Verify_CreateResourceIdentifierMethod()
+        {
+            MethodProvider createResourceIdentifierMethod = GetResourceClientProviderMethodByName("CreateResourceIdentifier");
+
+            var signature = createResourceIdentifierMethod.Signature;
+            Assert.AreEqual(MethodSignatureModifiers.Public | MethodSignatureModifiers.Static, signature.Modifiers);
+            Assert.AreEqual(typeof(ResourceIdentifier), signature.ReturnType?.FrameworkType);
+
+            Assert.AreEqual(3, signature.Parameters.Count);
+
+            var subscriptionIdParam = signature.Parameters.FirstOrDefault(p => p.Name == "subscriptionId");
+            Assert.NotNull(subscriptionIdParam);
+            Assert.AreEqual(typeof(string), subscriptionIdParam!.Type.FrameworkType);
+
+            var resourceGroupParam = signature.Parameters.FirstOrDefault(p => p.Name == "resourceGroupName");
+            Assert.NotNull(resourceGroupParam);
+            Assert.AreEqual(typeof(string), resourceGroupParam!.Type.FrameworkType);
+
+            var testNameParam = signature.Parameters.FirstOrDefault(p => p.Name == "testName");
+            Assert.NotNull(testNameParam);
+            Assert.AreEqual(typeof(string), testNameParam!.Type.FrameworkType);
+
+            var bodyStatements = createResourceIdentifierMethod.BodyStatements?.ToDisplayString();
+            Assert.NotNull(bodyStatements);
+            var exptected = Helpers.GetExpectedFromFile();
+            Assert.AreEqual(exptected, bodyStatements);
+        }
     }
 }

eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/test/Providers/TestData/ResourceClientProviderTests/Verify_CreateResourceIdentifierMethod.cs

@@ -0,0 +1,2 @@
+string resourceId = $"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/a/test/{testName}";
+return new global::Azure.Core.ResourceIdentifier(resourceId);