refactor RestClientInfo stuff for preparation of non-resource operations in extension classes (#51752)

ArcturusZhang · web-flow · commit b52faafb2284 · 2025-08-06T20:24:46.000+08:00
* refactor

* fix test cases
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementInputLibrary.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementInputLibrary.cs
@@ -59,7 +59,7 @@ private InputNamespace BuildInputNamespaceInternal()
 
         private IReadOnlyDictionary<string, InputServiceMethod> InputMethodsByCrossLanguageDefinitionId => _inputServiceMethodsByCrossLanguageDefinitionId ??= InputNamespace.Clients.SelectMany(c => c.Methods).ToDictionary(m => m.CrossLanguageDefinitionId, m => m);
 
-        private IReadOnlyDictionary<InputServiceMethod, InputClient> IntMethodClientMap => _intMethodClientMap ??= ConstructMethodClientMap();
+        private IReadOnlyDictionary<InputServiceMethod, InputClient> InputMethodClientMap => _intMethodClientMap ??= ConstructMethodClientMap();
 
         private IReadOnlyDictionary<InputModelType, string> ResourceUpdateModelToResourceNameMap => _resourceUpdateModelToResourceNameMap ??= BuildResourceUpdateModelToResourceNameMap();
 
@@ -69,10 +69,10 @@ private IReadOnlyDictionary<InputModelType, string> BuildResourceUpdateModelToRe
 
             foreach (var (resourceModel, metadata) in ResourceMetadata)
             {
-                var id = metadata.Methods.Where(m => m.Kind == ResourceOperationKind.Update).FirstOrDefault()?.Id;
-                if (id != null && InputMethodsByCrossLanguageDefinitionId.GetValueOrDefault(id) is { Operation.HttpMethod: "PATCH" } method)
+                var inputMethod = metadata.Methods.Where(m => m.Kind == ResourceOperationKind.Update).FirstOrDefault()?.InputMethod;
+                if (inputMethod is { Operation.HttpMethod: "PATCH" } patchMethod)
                 {
-                    foreach (var parameter in method.Parameters)
+                    foreach (var parameter in patchMethod.Parameters)
                     {
                         if (parameter.Location == InputRequestLocation.Body && parameter.Type is InputModelType updateModel && updateModel != resourceModel)
                         {
@@ -103,7 +103,7 @@ private IReadOnlyDictionary<InputServiceMethod, InputClient> ConstructMethodClie
             => InputMethodsByCrossLanguageDefinitionId.TryGetValue(crossLanguageDefinitionId, out var method) ? method : null;
 
         internal InputClient? GetClientByMethod(InputServiceMethod method)
-            => IntMethodClientMap.TryGetValue(method, out var client) ? client : null;
+            => InputMethodClientMap.TryGetValue(method, out var client) ? client : null;
 
         internal ResourceMetadata? GetResourceMetadata(InputModelType model)
             => ResourceMetadata.TryGetValue(model, out var metadata) ? metadata : null;
@@ -184,7 +184,13 @@ ResourceMetadata BuildResourceMetadata(InputDecoratorInfo decorator, InputModelT
                                 operationKind = kind;
                             }
                         }
-                        methods.Add(new ResourceMethod(id ?? throw new InvalidOperationException("id cannot be null"), operationKind ?? throw new InvalidOperationException("operationKind cannot be null")));
+                        var inputMethod = GetMethodByCrossLanguageDefinitionId(id ?? throw new InvalidOperationException("id cannot be null"));
+                        var inputClient = GetClientByMethod(inputMethod ?? throw new InvalidOperationException($"cannot find InputServiceMethod {id}"));
+                        methods.Add(
+                            new ResourceMethod(
+                                operationKind ?? throw new InvalidOperationException("operationKind cannot be null"),
+                                inputMethod,
+                                inputClient ?? throw new InvalidOperationException($"cannot find method {inputMethod.CrossLanguageDefinitionId}'s client")));
                     }
                 }
 
@@ -198,16 +204,6 @@ ResourceMetadata BuildResourceMetadata(InputDecoratorInfo decorator, InputModelT
                     resourceName = resourceNameData.ToObjectFromJson<string>();
                 }
 
-                var methodToClientMap = new Dictionary<string, InputClient>();
-                foreach (var method in methods)
-                {
-                    var inputClient = GetClientByMethod(GetMethodByCrossLanguageDefinitionId(method.Id)!);
-                    if (inputClient != null)
-                    {
-                        methodToClientMap[method.Id] = inputClient;
-                    }
-                }
-
                 // TODO -- I know we should never throw the exception, but here we just put it here and refine it later
                 return new(
                     resourceIdPattern ?? throw new InvalidOperationException("resourceIdPattern cannot be null"),
@@ -216,8 +212,7 @@ ResourceMetadata BuildResourceMetadata(InputDecoratorInfo decorator, InputModelT
                     methods,
                     singletonResourceName,
                     parentResource,
-                    resourceName ?? throw new InvalidOperationException("resourceName cannot be null"),
-                    methodToClientMap);
+                    resourceName ?? throw new InvalidOperationException("resourceName cannot be null"));
             }
         }
 
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Models/ResourceMetadata.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Models/ResourceMetadata.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 using System.Collections.Generic;
-using Microsoft.TypeSpec.Generator.Input;
 
 namespace Azure.Generator.Management.Models
 {
@@ -13,6 +12,5 @@ internal record ResourceMetadata(
         IReadOnlyList<ResourceMethod> Methods,
         string? SingletonResourceName,
         string? ParentResourceId,
-        string ResourceName,
-        IReadOnlyDictionary<string, InputClient> MethodToClientMap);
+        string ResourceName);
 }
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Models/ResourceMethod.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Models/ResourceMethod.cs
@@ -1,7 +1,9 @@
 ﻿// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using Microsoft.TypeSpec.Generator.Input;
+
 namespace Azure.Generator.Management.Models
 {
-    internal record ResourceMethod(string Id, ResourceOperationKind Kind);
+    internal record ResourceMethod(ResourceOperationKind Kind, InputServiceMethod InputMethod, InputClient InputClient);
 }
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Models/RestClientInfo.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Models/RestClientInfo.cs
@@ -9,5 +9,11 @@ namespace Azure.Generator.Management.Models
     /// <summary>
     /// Record to combine client provider and related field providers
     /// </summary>
-    internal record RestClientInfo(ClientProvider RestClientProvider, FieldProvider RestClientField, FieldProvider DiagnosticsField);
+    internal record RestClientInfo(ClientProvider RestClientProvider, FieldProvider RestClientField, PropertyProvider? RestClientProperty, FieldProvider DiagnosticsField, PropertyProvider? DiagnosticProperty)
+    {
+        internal RestClientInfo(ClientProvider restClientProvider, FieldProvider restClientField, FieldProvider diagnosticsField)
+            : this(restClientProvider, restClientField, null, diagnosticsField, null)
+        {
+        }
+    }
 }
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs
@@ -48,7 +48,7 @@ internal static ResourceClientProvider Create(InputModelType model, ResourceMeta
             return resource;
         }
 
-        private IEnumerable<(ResourceOperationKind, InputServiceMethod)> _resourceServiceMethods;
+        private IReadOnlyList<ResourceMethod> _resourceServiceMethods;
 
         private readonly FieldProvider _dataField;
         private readonly FieldProvider _resourceTypeField;
@@ -69,8 +69,7 @@ private ResourceClientProvider(string resourceName, InputModelType model, Resour
 
             ResourceName = resourceName;
 
-            // We should be able to assume that all operations in the resource client are for the same resource
-            _resourceServiceMethods = resourceMetadata.Methods.Select(m => (m.Kind, ManagementClientGenerator.Instance.InputLibrary.GetMethodByCrossLanguageDefinitionId(m.Id)!));
+            _resourceServiceMethods = resourceMetadata.Methods;
             ResourceData = ManagementClientGenerator.Instance.TypeFactory.CreateModel(model)!;
 
             // Initialize client info dictionary using extension method
@@ -93,7 +92,8 @@ private ResourceClientProvider(string resourceName, InputModelType model, Resour
 
         internal ModelProvider ResourceData { get; }
         internal string ResourceName { get; }
-        internal IEnumerable<(ResourceOperationKind Kind, InputServiceMethod Method)> ResourceServiceMethods => _resourceServiceMethods;
+        // TODO -- we should not need to expose this.
+        internal IEnumerable<ResourceMethod> ResourceServiceMethods => _resourceServiceMethods;
 
         internal string? SingletonResourceName => _resourceMetadata.SingletonResourceName;
 
@@ -233,7 +233,7 @@ private ConstructorProvider BuildResourceIdentifierConstructor()
         // TODO -- this is temporary. We should change this to find the corresponding parameters in ContextualParameters after it is refactored to consume parent resources.
         private CSharpType GetPathParameterType(string parameterName)
         {
-            foreach (var (kind, method) in _resourceServiceMethods)
+            foreach (var (kind, method, _) in _resourceServiceMethods)
             {
                 if (!kind.IsCrudKind())
                 {
@@ -319,7 +319,7 @@ protected override MethodProvider[] BuildMethods()
             var operationMethods = new List<MethodProvider>();
             UpdateOperationMethodProvider? updateMethodProvider = null;
 
-            foreach (var (methodKind, method) in _resourceServiceMethods)
+            foreach (var (methodKind, method, inputClient) in _resourceServiceMethods)
             {
                 // exclude the List operations for resource and Create operations for non-singleton resources (they will be in ResourceCollection)
                 if (methodKind == ResourceOperationKind.List || (!IsSingleton && methodKind == ResourceOperationKind.Create))
@@ -330,7 +330,7 @@ protected override MethodProvider[] BuildMethods()
                 var isFakeLro = ResourceHelpers.ShouldMakeLro(methodKind);
 
                 // Get the appropriate rest client for this specific method
-                var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(method, _clientInfos);
+                var restClientInfo = _clientInfos[inputClient];
 
                 var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(method.Operation, false);
                 var asyncConvenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(method.Operation, true);
@@ -378,8 +378,7 @@ protected override MethodProvider[] BuildMethods()
                 var updateMethod = _resourceMetadata.Methods.FirstOrDefault(m => m.Kind == ResourceOperationKind.Update || m.Kind == ResourceOperationKind.Create);
                 if (updateMethod is not null)
                 {
-                    var updateRestClientInfo = _resourceMetadata.GetRestClientForServiceMethod(
-                        ManagementClientGenerator.Instance.InputLibrary.GetMethodByCrossLanguageDefinitionId(updateMethod.Id)!, _clientInfos);
+                    var updateRestClientInfo = _clientInfos[updateMethod.InputClient];
 
                     methods.AddRange([
                         new AddTagMethodProvider(this, updateMethodProvider, updateRestClientInfo, true),
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceCollectionClientProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceCollectionClientProvider.cs
@@ -20,7 +20,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
-using System.Runtime.CompilerServices;
 using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
 
 namespace Azure.Generator.Management.Providers
@@ -30,9 +29,9 @@ internal sealed class ResourceCollectionClientProvider : TypeProvider
         private readonly ResourceMetadata _resourceMetadata;
 
         private readonly ResourceClientProvider _resource;
-        private readonly InputServiceMethod? _getAll;
-        private readonly InputServiceMethod? _create;
-        private readonly InputServiceMethod? _get;
+        private readonly ResourceMethod? _getAll;
+        private readonly ResourceMethod? _create;
+        private readonly ResourceMethod? _get;
 
         // Support for multiple rest clients
         private readonly Dictionary<InputClient, RestClientInfo> _clientInfos;
@@ -79,9 +78,9 @@ private static RequestPathPattern GetContextualRequestPattern(ResourceMetadata r
 
         private static void InitializeMethods(
             ResourceMetadata resourceMetadata,
-            ref InputServiceMethod? getMethod,
-            ref InputServiceMethod? createMethod,
-            ref InputServiceMethod? getAllMethod)
+            ref ResourceMethod? getMethod,
+            ref ResourceMethod? createMethod,
+            ref ResourceMethod? getAllMethod)
         {
             foreach (var method in resourceMetadata.Methods)
             {
@@ -93,32 +92,16 @@ private static void InitializeMethods(
                 switch (method.Kind)
                 {
                     case ResourceOperationKind.Get:
-                        AssignMethodKind(ref getMethod, resourceMetadata.ResourceIdPattern, method);
+                        getMethod = method;
                         break;
                     case ResourceOperationKind.List:
-                        AssignMethodKind(ref getAllMethod, resourceMetadata.ResourceIdPattern, method);
+                        getAllMethod = method;
                         break;
                     case ResourceOperationKind.Create:
-                        AssignMethodKind(ref createMethod, resourceMetadata.ResourceIdPattern, method);
+                        createMethod = method;
                         break;
                 }
             }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void AssignMethodKind(ref InputServiceMethod? method, string resourceIdPattern, ResourceMethod resourceMethod)
-            {
-                if (method is not null)
-                {
-                    ManagementClientGenerator.Instance.Emitter.ReportDiagnostic(
-                        "general-warning", // TODO -- in the near future, we should have a resource-specific diagnostic ID
-                        $"Resource {resourceIdPattern} has multiple '{resourceMethod.Kind}' methods."
-                        );
-                }
-                else
-                {
-                    method = ManagementClientGenerator.Instance.InputLibrary.GetMethodByCrossLanguageDefinitionId(resourceMethod.Id);
-                }
-            }
         }
 
         public ResourceClientProvider Resource => _resource;
@@ -262,64 +245,64 @@ private MethodProvider[] BuildEnumeratorMethods()
 
         private List<MethodProvider> BuildCreateOrUpdateMethods()
         {
-            var result = new List<MethodProvider>();
             if (_create is null)
             {
-                return result;
+                return [];
             }
 
-            var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_create, _clientInfos);
+            var result = new List<MethodProvider>();
+            var restClientInfo = _clientInfos[_create.InputClient];
             foreach (var isAsync in new List<bool> { true, false })
             {
-                var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_create!.Operation, isAsync);
+                var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_create.InputMethod.Operation, isAsync);
                 var methodName = ResourceHelpers.GetOperationMethodName(ResourceOperationKind.Create, isAsync);
-                result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _create, isAsync, methodName, forceLro: true));
+                result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _create.InputMethod, isAsync, methodName: methodName, forceLro: true));
             }
 
             return result;
         }
 
-        private MethodProvider BuildGetAllMethod(InputServiceMethod getAll, bool isAsync)
+        private MethodProvider BuildGetAllMethod(ResourceMethod getAll, bool isAsync)
         {
-            var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(getAll, _clientInfos);
-            return getAll switch
+            var restClientInfo = _clientInfos[getAll.InputClient];
+            return getAll.InputMethod switch
             {
                 InputPagingServiceMethod pagingGetAll => new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, pagingGetAll, isAsync, ResourceOperationKind.List),
-                _ => new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, getAll, isAsync, ResourceHelpers.GetOperationMethodName(ResourceOperationKind.List, isAsync))
+                _ => new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, getAll.InputMethod, isAsync, ResourceHelpers.GetOperationMethodName(ResourceOperationKind.List, isAsync))
             };
         }
 
         private List<MethodProvider> BuildGetMethods()
         {
-            var result = new List<MethodProvider>();
             if (_get is null)
             {
-                return result;
+                return [];
             }
 
-            var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_get, _clientInfos);
+            var result = new List<MethodProvider>();
+            var restClientInfo = _clientInfos[_get.InputClient];
             foreach (var isAsync in new List<bool> { true, false })
             {
-                var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);
-                result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _get, isAsync));
+                var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get.InputMethod.Operation, isAsync);
+                result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _get.InputMethod, isAsync));
             }
 
             return result;
         }
 
         private List<MethodProvider> BuildExistsMethods()
         {
-            var result = new List<MethodProvider>();
             if (_get is null)
             {
-                return result;
+                return [];
             }
 
-            var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_get, _clientInfos);
+            var result = new List<MethodProvider>();
+            var restClientInfo = _clientInfos[_get.InputClient];
             foreach (var isAsync in new List<bool> { true, false })
             {
-                var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);
-                var existsMethodProvider = new ExistsOperationMethodProvider(this, restClientInfo, _get, isAsync);
+                var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get.InputMethod.Operation, isAsync);
+                var existsMethodProvider = new ExistsOperationMethodProvider(this, restClientInfo, _get.InputMethod, isAsync);
                 result.Add(existsMethodProvider);
             }
 
@@ -334,11 +317,11 @@ private List<MethodProvider> BuildGetIfExistsMethods()
                 return result;
             }
 
-            var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_get, _clientInfos);
+            var restClientInfo = _clientInfos[_get.InputClient];
             foreach (var isAsync in new List<bool> { true, false })
             {
-                var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);
-                var getIfExistsMethodProvider = new GetIfExistsOperationMethodProvider(this, restClientInfo, _get, isAsync);
+                var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get.InputMethod.Operation, isAsync);
+                var getIfExistsMethodProvider = new GetIfExistsOperationMethodProvider(this, restClientInfo, _get.InputMethod, isAsync);
                 result.Add(getIfExistsMethodProvider);
             }
 
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/TagMethodProviders/BaseTagMethodProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/TagMethodProviders/BaseTagMethodProvider.cs
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Utilities/ResourceMetadataExtensions.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Utilities/ResourceMetadataExtensions.cs
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/test/Common/InputResourceData.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/test/Common/InputResourceData.cs

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ private InputNamespace BuildInputNamespaceInternal()`
`59`	`59`
`60`	`60`	`private IReadOnlyDictionary<string, InputServiceMethod> InputMethodsByCrossLanguageDefinitionId => _inputServiceMethodsByCrossLanguageDefinitionId ??= InputNamespace.Clients.SelectMany(c => c.Methods).ToDictionary(m => m.CrossLanguageDefinitionId, m => m);`
`61`	`61`
`62`		`- private IReadOnlyDictionary<InputServiceMethod, InputClient> IntMethodClientMap => _intMethodClientMap ??= ConstructMethodClientMap();`
	`62`	`+ private IReadOnlyDictionary<InputServiceMethod, InputClient> InputMethodClientMap => _intMethodClientMap ??= ConstructMethodClientMap();`
`63`	`63`
`64`	`64`	`private IReadOnlyDictionary<InputModelType, string> ResourceUpdateModelToResourceNameMap => _resourceUpdateModelToResourceNameMap ??= BuildResourceUpdateModelToResourceNameMap();`
`65`	`65`
`@@ -69,10 +69,10 @@ private IReadOnlyDictionary<InputModelType, string> BuildResourceUpdateModelToRe`
`69`	`69`
`70`	`70`	`foreach (var (resourceModel, metadata) in ResourceMetadata)`
`71`	`71`	`{`
`72`		`- var id = metadata.Methods.Where(m => m.Kind == ResourceOperationKind.Update).FirstOrDefault()?.Id;`
`73`		`- if (id != null && InputMethodsByCrossLanguageDefinitionId.GetValueOrDefault(id) is { Operation.HttpMethod: "PATCH" } method)`
	`72`	`+ var inputMethod = metadata.Methods.Where(m => m.Kind == ResourceOperationKind.Update).FirstOrDefault()?.InputMethod;`
	`73`	`+ if (inputMethod is { Operation.HttpMethod: "PATCH" } patchMethod)`
`74`	`74`	`{`
`75`		`- foreach (var parameter in method.Parameters)`
	`75`	`+ foreach (var parameter in patchMethod.Parameters)`
`76`	`76`	`{`
`77`	`77`	`if (parameter.Location == InputRequestLocation.Body && parameter.Type is InputModelType updateModel && updateModel != resourceModel)`
`78`	`78`	`{`
`@@ -103,7 +103,7 @@ private IReadOnlyDictionary<InputServiceMethod, InputClient> ConstructMethodClie`
`103`	`103`	`=> InputMethodsByCrossLanguageDefinitionId.TryGetValue(crossLanguageDefinitionId, out var method) ? method : null;`
`104`	`104`
`105`	`105`	`internal InputClient? GetClientByMethod(InputServiceMethod method)`
`106`		`- => IntMethodClientMap.TryGetValue(method, out var client) ? client : null;`
	`106`	`+ => InputMethodClientMap.TryGetValue(method, out var client) ? client : null;`
`107`	`107`
`108`	`108`	`internal ResourceMetadata? GetResourceMetadata(InputModelType model)`
`109`	`109`	`=> ResourceMetadata.TryGetValue(model, out var metadata) ? metadata : null;`
`@@ -184,7 +184,13 @@ ResourceMetadata BuildResourceMetadata(InputDecoratorInfo decorator, InputModelT`
`184`	`184`	`operationKind = kind;`
`185`	`185`	`}`
`186`	`186`	`}`
`187`		`- methods.Add(new ResourceMethod(id ?? throw new InvalidOperationException("id cannot be null"), operationKind ?? throw new InvalidOperationException("operationKind cannot be null")));`
	`187`	`+ var inputMethod = GetMethodByCrossLanguageDefinitionId(id ?? throw new InvalidOperationException("id cannot be null"));`
	`188`	`+ var inputClient = GetClientByMethod(inputMethod ?? throw new InvalidOperationException($"cannot find InputServiceMethod {id}"));`
	`189`	`+ methods.Add(`
	`190`	`+ new ResourceMethod(`
	`191`	`+ operationKind ?? throw new InvalidOperationException("operationKind cannot be null"),`
	`192`	`+ inputMethod,`
	`193`	`+ inputClient ?? throw new InvalidOperationException($"cannot find method {inputMethod.CrossLanguageDefinitionId}'s client")));`
`188`	`194`	`}`
`189`	`195`	`}`
`190`	`196`
`@@ -198,16 +204,6 @@ ResourceMetadata BuildResourceMetadata(InputDecoratorInfo decorator, InputModelT`
`198`	`204`	`resourceName = resourceNameData.ToObjectFromJson<string>();`
`199`	`205`	`}`
`200`	`206`
`201`		`- var methodToClientMap = new Dictionary<string, InputClient>();`
`202`		`- foreach (var method in methods)`
`203`		`- {`
`204`		`- var inputClient = GetClientByMethod(GetMethodByCrossLanguageDefinitionId(method.Id)!);`
`205`		`- if (inputClient != null)`
`206`		`- {`
`207`		`- methodToClientMap[method.Id] = inputClient;`
`208`		`- }`
`209`		`- }`
`210`		`-`
`211`	`207`	`// TODO -- I know we should never throw the exception, but here we just put it here and refine it later`
`212`	`208`	`return new(`
`213`	`209`	`resourceIdPattern ?? throw new InvalidOperationException("resourceIdPattern cannot be null"),`
`@@ -216,8 +212,7 @@ ResourceMetadata BuildResourceMetadata(InputDecoratorInfo decorator, InputModelT`
`216`	`212`	`methods,`
`217`	`213`	`singletonResourceName,`
`218`	`214`	`parentResource,`
`219`		`- resourceName ?? throw new InvalidOperationException("resourceName cannot be null"),`
`220`		`- methodToClientMap);`
	`215`	`+ resourceName ?? throw new InvalidOperationException("resourceName cannot be null"));`
`221`	`216`	`}`
`222`	`217`	`}`
`223`	`218`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`// Licensed under the MIT License.`
`3`	`3`
`4`	`4`	`using System.Collections.Generic;`
`5`		`-using Microsoft.TypeSpec.Generator.Input;`
`6`	`5`
`7`	`6`	`namespace Azure.Generator.Management.Models`
`8`	`7`	`{`
`@@ -13,6 +12,5 @@ internal record ResourceMetadata(`
`13`	`12`	`IReadOnlyList<ResourceMethod> Methods,`
`14`	`13`	`string? SingletonResourceName,`
`15`	`14`	`string? ParentResourceId,`
`16`		`- string ResourceName,`
`17`		`- IReadOnlyDictionary<string, InputClient> MethodToClientMap);`
	`15`	`+ string ResourceName);`
`18`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,9 @@`
`1`	`1`	`// Copyright (c) Microsoft Corporation. All rights reserved.`
`2`	`2`	`// Licensed under the MIT License.`
`3`	`3`
	`4`	`+using Microsoft.TypeSpec.Generator.Input;`
	`5`	`+`
`4`	`6`	`namespace Azure.Generator.Management.Models`
`5`	`7`	`{`
`6`		`- internal record ResourceMethod(string Id, ResourceOperationKind Kind);`
	`8`	`+ internal record ResourceMethod(ResourceOperationKind Kind, InputServiceMethod InputMethod, InputClient InputClient);`
`7`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@`
`20`	`20`	`using System.Collections;`
`21`	`21`	`using System.Collections.Generic;`
`22`	`22`	`using System.IO;`
`23`		`-using System.Runtime.CompilerServices;`
`24`	`23`	`using static Microsoft.TypeSpec.Generator.Snippets.Snippet;`
`25`	`24`
`26`	`25`	`namespace Azure.Generator.Management.Providers`
`@@ -30,9 +29,9 @@ internal sealed class ResourceCollectionClientProvider : TypeProvider`
`30`	`29`	`private readonly ResourceMetadata _resourceMetadata;`
`31`	`30`
`32`	`31`	`private readonly ResourceClientProvider _resource;`
`33`		`- private readonly InputServiceMethod? _getAll;`
`34`		`- private readonly InputServiceMethod? _create;`
`35`		`- private readonly InputServiceMethod? _get;`
	`32`	`+ private readonly ResourceMethod? _getAll;`
	`33`	`+ private readonly ResourceMethod? _create;`
	`34`	`+ private readonly ResourceMethod? _get;`
`36`	`35`
`37`	`36`	`// Support for multiple rest clients`
`38`	`37`	`private readonly Dictionary<InputClient, RestClientInfo> _clientInfos;`
`@@ -79,9 +78,9 @@ private static RequestPathPattern GetContextualRequestPattern(ResourceMetadata r`
`79`	`78`
`80`	`79`	`private static void InitializeMethods(`
`81`	`80`	`ResourceMetadata resourceMetadata,`
`82`		`- ref InputServiceMethod? getMethod,`
`83`		`- ref InputServiceMethod? createMethod,`
`84`		`- ref InputServiceMethod? getAllMethod)`
	`81`	`+ ref ResourceMethod? getMethod,`
	`82`	`+ ref ResourceMethod? createMethod,`
	`83`	`+ ref ResourceMethod? getAllMethod)`
`85`	`84`	`{`
`86`	`85`	`foreach (var method in resourceMetadata.Methods)`
`87`	`86`	`{`
`@@ -93,32 +92,16 @@ private static void InitializeMethods(`
`93`	`92`	`switch (method.Kind)`
`94`	`93`	`{`
`95`	`94`	`case ResourceOperationKind.Get:`
`96`		`- AssignMethodKind(ref getMethod, resourceMetadata.ResourceIdPattern, method);`
	`95`	`+ getMethod = method;`
`97`	`96`	`break;`
`98`	`97`	`case ResourceOperationKind.List:`
`99`		`- AssignMethodKind(ref getAllMethod, resourceMetadata.ResourceIdPattern, method);`
	`98`	`+ getAllMethod = method;`
`100`	`99`	`break;`
`101`	`100`	`case ResourceOperationKind.Create:`
`102`		`- AssignMethodKind(ref createMethod, resourceMetadata.ResourceIdPattern, method);`
	`101`	`+ createMethod = method;`
`103`	`102`	`break;`
`104`	`103`	`}`
`105`	`104`	`}`
`106`		`-`
`107`		`- [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`108`		`- static void AssignMethodKind(ref InputServiceMethod? method, string resourceIdPattern, ResourceMethod resourceMethod)`
`109`		`- {`
`110`		`- if (method is not null)`
`111`		`- {`
`112`		`- ManagementClientGenerator.Instance.Emitter.ReportDiagnostic(`
`113`		`- "general-warning", // TODO -- in the near future, we should have a resource-specific diagnostic ID`
`114`		`- $"Resource {resourceIdPattern} has multiple '{resourceMethod.Kind}' methods."`
`115`		`- );`
`116`		`- }`
`117`		`- else`
`118`		`- {`
`119`		`- method = ManagementClientGenerator.Instance.InputLibrary.GetMethodByCrossLanguageDefinitionId(resourceMethod.Id);`
`120`		`- }`
`121`		`- }`
`122`	`105`	`}`
`123`	`106`
`124`	`107`	`public ResourceClientProvider Resource => _resource;`
`@@ -262,64 +245,64 @@ private MethodProvider[] BuildEnumeratorMethods()`
`262`	`245`
`263`	`246`	`private List<MethodProvider> BuildCreateOrUpdateMethods()`
`264`	`247`	`{`
`265`		`- var result = new List<MethodProvider>();`
`266`	`248`	`if (_create is null)`
`267`	`249`	`{`
`268`		`- return result;`
	`250`	`+ return [];`
`269`	`251`	`}`
`270`	`252`
`271`		`- var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_create, _clientInfos);`
	`253`	`+ var result = new List<MethodProvider>();`
	`254`	`+ var restClientInfo = _clientInfos[_create.InputClient];`
`272`	`255`	`foreach (var isAsync in new List<bool> { true, false })`
`273`	`256`	`{`
`274`		`- var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_create!.Operation, isAsync);`
	`257`	`+ var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_create.InputMethod.Operation, isAsync);`
`275`	`258`	`var methodName = ResourceHelpers.GetOperationMethodName(ResourceOperationKind.Create, isAsync);`
`276`		`- result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _create, isAsync, methodName, forceLro: true));`
	`259`	`+ result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _create.InputMethod, isAsync, methodName: methodName, forceLro: true));`
`277`	`260`	`}`
`278`	`261`
`279`	`262`	`return result;`
`280`	`263`	`}`
`281`	`264`
`282`		`- private MethodProvider BuildGetAllMethod(InputServiceMethod getAll, bool isAsync)`
	`265`	`+ private MethodProvider BuildGetAllMethod(ResourceMethod getAll, bool isAsync)`
`283`	`266`	`{`
`284`		`- var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(getAll, _clientInfos);`
`285`		`- return getAll switch`
	`267`	`+ var restClientInfo = _clientInfos[getAll.InputClient];`
	`268`	`+ return getAll.InputMethod switch`
`286`	`269`	`{`
`287`	`270`	`InputPagingServiceMethod pagingGetAll => new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, pagingGetAll, isAsync, ResourceOperationKind.List),`
`288`		`- _ => new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, getAll, isAsync, ResourceHelpers.GetOperationMethodName(ResourceOperationKind.List, isAsync))`
	`271`	`+ _ => new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, getAll.InputMethod, isAsync, ResourceHelpers.GetOperationMethodName(ResourceOperationKind.List, isAsync))`
`289`	`272`	`};`
`290`	`273`	`}`
`291`	`274`
`292`	`275`	`private List<MethodProvider> BuildGetMethods()`
`293`	`276`	`{`
`294`		`- var result = new List<MethodProvider>();`
`295`	`277`	`if (_get is null)`
`296`	`278`	`{`
`297`		`- return result;`
	`279`	`+ return [];`
`298`	`280`	`}`
`299`	`281`
`300`		`- var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_get, _clientInfos);`
	`282`	`+ var result = new List<MethodProvider>();`
	`283`	`+ var restClientInfo = _clientInfos[_get.InputClient];`
`301`	`284`	`foreach (var isAsync in new List<bool> { true, false })`
`302`	`285`	`{`
`303`		`- var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);`
`304`		`- result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _get, isAsync));`
	`286`	`+ var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get.InputMethod.Operation, isAsync);`
	`287`	`+ result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _get.InputMethod, isAsync));`
`305`	`288`	`}`
`306`	`289`
`307`	`290`	`return result;`
`308`	`291`	`}`
`309`	`292`
`310`	`293`	`private List<MethodProvider> BuildExistsMethods()`
`311`	`294`	`{`
`312`		`- var result = new List<MethodProvider>();`
`313`	`295`	`if (_get is null)`
`314`	`296`	`{`
`315`		`- return result;`
	`297`	`+ return [];`
`316`	`298`	`}`
`317`	`299`
`318`		`- var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_get, _clientInfos);`
	`300`	`+ var result = new List<MethodProvider>();`
	`301`	`+ var restClientInfo = _clientInfos[_get.InputClient];`
`319`	`302`	`foreach (var isAsync in new List<bool> { true, false })`
`320`	`303`	`{`
`321`		`- var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);`
`322`		`- var existsMethodProvider = new ExistsOperationMethodProvider(this, restClientInfo, _get, isAsync);`
	`304`	`+ var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get.InputMethod.Operation, isAsync);`
	`305`	`+ var existsMethodProvider = new ExistsOperationMethodProvider(this, restClientInfo, _get.InputMethod, isAsync);`
`323`	`306`	`result.Add(existsMethodProvider);`
`324`	`307`	`}`
`325`	`308`
`@@ -334,11 +317,11 @@ private List<MethodProvider> BuildGetIfExistsMethods()`
`334`	`317`	`return result;`
`335`	`318`	`}`
`336`	`319`
`337`		`- var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_get, _clientInfos);`
	`320`	`+ var restClientInfo = _clientInfos[_get.InputClient];`
`338`	`321`	`foreach (var isAsync in new List<bool> { true, false })`
`339`	`322`	`{`
`340`		`- var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);`
`341`		`- var getIfExistsMethodProvider = new GetIfExistsOperationMethodProvider(this, restClientInfo, _get, isAsync);`
	`323`	`+ var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get.InputMethod.Operation, isAsync);`
	`324`	`+ var getIfExistsMethodProvider = new GetIfExistsOperationMethodProvider(this, restClientInfo, _get.InputMethod, isAsync);`
`342`	`325`	`result.Add(getIfExistsMethodProvider);`
`343`	`326`	`}`
`344`	`327`