Fix mgmt generator: correctly detect extension resources with specific parent types (Azure#57722)

Author: live1206

eng/packages/http-client-csharp-mgmt/emitter/src/resolve-arm-resources-converter.ts

@@ -564,35 +564,27 @@ function convertScopeToResourceScope(
 export function getOperationScopeFromPath(path: string): ResourceScope {
   // Match any path starting with a variable segment followed by /providers/
   // This covers scope-based operations like /{resourceUri}/providers/..., /{scope}/providers/..., /{resourceId}/providers/..., etc.
-  if (/^\/\{[^}]+\}\/providers\//.test(path)) {
-    return ResourceScope.Extension;
-  } else if (
-    /^\/subscriptions\/\{[^}]+\}\/resourceGroups\/\{[^}]+\}\//.test(path)
+  const lastProviderIndex = path.lastIndexOf("/providers/");
+  const scopePath = path.substring(0, lastProviderIndex);
+  if (!scopePath) {
+      return ResourceScope.Tenant;
+  }
+  else if (
+    /^\/subscriptions\/\{[^}]+\}\/resourceGroups\/\{[^}]+\}$/.test(scopePath)
   ) {
     return ResourceScope.ResourceGroup;
-  } else if (/^\/subscriptions\/\{[^}]+\}\//.test(path)) {
+  } else if (/^\/subscriptions\/\{[^}]+\}$/.test(scopePath)) {
     return ResourceScope.Subscription;
   } else if (
-    /^\/providers\/Microsoft\.Management\/managementGroups\/\{[^}]+\}\//.test(
-      path
+    /^\/providers\/Microsoft\.Management\/managementGroups\/\{[^}]+\}$/.test(
+      scopePath
     )
   ) {
     return ResourceScope.ManagementGroup;
-  } else if (hasMultipleProviderSegments(path)) {
-    // Paths with multiple /providers/ segments indicate extension resources
-    // e.g., /providers/Microsoft.Management/serviceGroups/{name}/providers/Microsoft.Edge/sites/{siteName}
+  }
+  else {
     return ResourceScope.Extension;
   }
-  return ResourceScope.Tenant; // all the templates work as if there is a tenant decorator when there is no such decorator
-}
-
-/**
- * Check if a path has multiple /providers/ segments, indicating an extension resource
- * that extends another ARM resource.
- */
-function hasMultipleProviderSegments(path: string): boolean {
-  const providerMatches = path.match(/\/providers\//gi);
-  return providerMatches !== null && providerMatches.length > 1;
 }
 
 /**

eng/packages/http-client-csharp-mgmt/emitter/src/resource-detection.ts

@@ -48,10 +48,7 @@ import {
   builtInResourceOperationName,
   parentResourceName,
   readsResourceName,
-  resourceGroupResource,
   singleton,
-  subscriptionResource,
-  tenantResource
 } from "./sdk-context-options.js";
 import {
   DecoratorApplication,
@@ -422,12 +419,8 @@ export function buildArmProviderSchema(
 
   // Update the model's resourceScope based on resource scope decorator if it exists or based on the Read method's scope.
   // This is specific to legacy resource detection
-  for (const [metadataKey, metadata] of resourcePathToMetadataMap) {
-    const modelId = metadataKey.split("|")[0];
-    const model = resourceModelMap.get(modelId);
-    if (model) {
-      metadata.resourceScope = getResourceScope(model, metadata.methods);
-    }
+  for (const metadata of resourcePathToMetadataMap.values()) {
+      metadata.resourceScope = getResourceScope(metadata.methods);
   }
 
   // Create parent lookup context for legacy resource detection
@@ -1039,31 +1032,25 @@ function getSingletonResource(
   return singletonResource ?? "default";
 }
 function getResourceScope(
-  model: InputModelType,
   methods?: ResourceMethod[]
 ): ResourceScope {
-  // First, check for explicit scope decorators
-  const decorators = model.decorators;
-  if (decorators?.some((d) => d.name == tenantResource)) {
-    return ResourceScope.Tenant;
-  } else if (decorators?.some((d) => d.name == subscriptionResource)) {
-    return ResourceScope.Subscription;
-  } else if (decorators?.some((d) => d.name == resourceGroupResource)) {
-    return ResourceScope.ResourceGroup;
-  }
-
-  // Fall back to Read method's scope only if no scope decorators are found
+  // Determine scope from the Read method's operation path, which is the source of truth.
+  // Scope decorators (@resourceGroupResource, etc.) can be inherited implicitly from base
+  // model types like ProxyResource and may not reflect the actual scope for extension
+  // resources that use Legacy.ExtensionOperations with specific parent types.
   if (methods) {
     const getMethod = methods.find(
       (m) => m.kind === ResourceOperationKind.Read
     );
+    // We have logic to filter out resources without get/read operations later in post-processing,
+    // so it's possible to have a resource with no Read method. In that case, we skip scope detection since the resource will be filtered out anyway.
     if (getMethod) {
       return getMethod.operationScope;
     }
   }
 
   // Final fallback to ResourceGroup
-  return ResourceScope.ResourceGroup; // all the templates work as if there is a resource group decorator when there is no such decorator
+  return ResourceScope.ResourceGroup;
 }
 
 /**

eng/packages/http-client-csharp-mgmt/emitter/src/resource-metadata.ts

@@ -80,6 +80,9 @@ export interface ResourceMetadata {
   parentResourceModelId?: string;
   singletonResourceName?: string;
   resourceName: string;
+  /** The expected parent resource type for extension resources with specific parent types (e.g., "Microsoft.Compute/virtualMachines") */
+  // TODO: consider to calculate this in generator directly within RequestPathPattern instead of carrying it through emitter and post-processing
+  parentResourceType?: string;
   /** The name constraints for the resource, from TypeSpec decorators */
   nameConstraints: NameConstraints;
   /** The API versions that this resource is available in */
@@ -286,6 +289,7 @@ export function convertArmProviderSchemaToArguments(
       })),
       resourceScope: r.metadata.resourceScope,
       parentResourceId: r.metadata.parentResourceId,
+      parentResourceType: r.metadata.parentResourceType,
       singletonResourceName: r.metadata.singletonResourceName,
       resourceName: r.metadata.resourceName,
       nameConstraints: r.metadata.nameConstraints,
@@ -525,6 +529,15 @@ export function postProcessArmResources(
     sortResourceMethods(resource.metadata.methods);
   }
 
+  // Step 8: Compute parentResourceType for extension resources with specific parent types
+  for (const resource of filteredResources) {
+    if (countProviderSegments(resource.metadata.resourceIdPattern) > 1) {
+      resource.metadata.parentResourceType = getExpectedParentResourceType(
+        resource.metadata.resourceIdPattern
+      );
+    }
+  }
+
   return filteredResources;
 }
 
@@ -767,3 +780,57 @@ function relocateCrossResourceListActions(
     targetResource.metadata.methods.push(method);
   }
 }
+
+/**
+ * Extracts the expected parent resource type from a resource ID pattern that is
+ * already known to have multiple /providers/ segments. Returns undefined if the
+ * parent segment is not a simple `<namespace>/<type>/{name}` pattern (e.g., for
+ * complex paths with nested types or mixed scopes).
+ *
+ * For example, for a pattern like:
+ * /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Compute/virtualMachines/{vm}/providers/MyService/resources/{name}
+ * This returns "Microsoft.Compute/virtualMachines".
+ */
+function getExpectedParentResourceType(
+  resourceIdPattern: string
+): string | undefined {
+  // Find the last /providers/ segment (the extension resource's own provider)
+  const lastProvidersIndex = resourceIdPattern.lastIndexOf("/providers/");
+
+  // Find the second-to-last /providers/ segment (the parent resource's provider)
+  const parentProvidersIndex = resourceIdPattern.lastIndexOf(
+    "/providers/",
+    lastProvidersIndex - 1
+  );
+
+  if (parentProvidersIndex === -1) {
+    return undefined;
+  }
+
+  // Extract the parent segment between the two /providers/ markers
+  const parentSegment = resourceIdPattern.substring(
+    parentProvidersIndex + "/providers/".length,
+    lastProvidersIndex
+  );
+
+  // Only accept simple parent segments: "<namespace>/<type>/{name}"
+  // Reject complex paths (nested types, mixed scopes) to avoid false positives
+  const segments = parentSegment.split("/");
+  if (segments.length !== 3) {
+    return undefined;
+  }
+
+  const [providerNamespace, resourceType, nameSegment] = segments;
+
+  // All three segments must be well-formed: constants for namespace/type, variable for name
+  if (
+    providerNamespace.includes("{") ||
+    resourceType.includes("{") ||
+    !nameSegment.startsWith("{") ||
+    !nameSegment.endsWith("}")
+  ) {
+    return undefined;
+  }
+
+  return `${providerNamespace}/${resourceType}`;
+}

eng/packages/http-client-csharp-mgmt/emitter/test/resource-type.test.ts

@@ -138,11 +138,11 @@ describe("Operation Scope Detection", () => {
     strictEqual(scope, ResourceScope.Extension);
   });
 
-  it("resource group scope takes priority over nested extension resources", async () => {
+  it("extension scope for resources extending a specific ARM resource within a resource group", async () => {
     const path =
       "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Something/parentResource/{parentName}/providers/Microsoft.Edge/sites/{siteName}";
     const scope = getOperationScopeFromPath(path);
-    strictEqual(scope, ResourceScope.ResourceGroup);
+    strictEqual(scope, ResourceScope.Extension);
   });
 });
 

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

@@ -17,6 +17,7 @@ namespace Azure.Generator.Management.Models;
 /// <param name="Methods"> The list of methods associated with the resource. </param>
 /// <param name="SingletonResourceName"> The singleton resource name, if applicable. </param>
 /// <param name="ParentResourceId"> The parent resource ID pattern, if applicable. </param>
+/// <param name="ParentResourceType"> The expected parent resource type for extension resources with specific parent types (e.g., "Microsoft.Compute/virtualMachines"), if applicable. </param>
 /// <param name="ChildResourceIds"> The list of child resource ID patterns. </param>
 /// <param name="NameConstraints"> The name constraints for the resource. </param>
 /// <param name="ApiVersions"> The API versions that this resource is available in. </param>
@@ -30,6 +31,7 @@ public record ArmResourceMetadata(
     IReadOnlyList<ResourceMethod> Methods,
     string? SingletonResourceName,
     string? ParentResourceId,
+    string? ParentResourceType,
     IReadOnlyList<string> ChildResourceIds,
     ArmResourceNameConstraints NameConstraints,
     IReadOnlyList<string> ApiVersions,
@@ -83,6 +85,11 @@ internal static ArmResourceMetadata DeserializeResourceMetadata(JsonElement elem
         {
             parentResource = parentResourceElement.GetString();
         }
+        string? parentResourceType = null;
+        if (element.TryGetProperty("parentResourceType", out var parentResourceTypeElement))
+        {
+            parentResourceType = parentResourceTypeElement.GetString();
+        }
         if (element.TryGetProperty("resourceName", out var resourceNameElement))
         {
             resourceName = resourceNameElement.GetString();
@@ -125,6 +132,7 @@ internal static ArmResourceMetadata DeserializeResourceMetadata(JsonElement elem
             methods,
             singletonResourceName,
             parentResource,
+            parentResourceType,
             childResourceIds,
             nameConstraints,
             apiVersions,

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

@@ -83,6 +83,8 @@ private ResourceClientProvider(string resourceName, InputModelType model, IReadO
 
         internal ResourceScope ResourceScope => _resourceMetadata.ResourceScope;
         internal string? ParentResourceIdPattern => _resourceMetadata.ParentResourceId;
+        internal string ResourceIdPattern => _resourceMetadata.ResourceIdPattern;
+        internal string? ParentResourceType => _resourceMetadata.ParentResourceType;
 
         internal bool IsExtensionResource => ResourceScope == ResourceScope.Extension;
 
@@ -130,16 +132,18 @@ private IReadOnlyList<ResourceClientProvider> BuildChildResources()
 
         private CSharpType BuildTypeOfParentResource()
         {
-            if (_resourceMetadata.ResourceScope == ResourceScope.Extension)
-            {
-                return typeof(ArmResource);
-            }
-
             // if the resource has a parent resource id, we can find it in the output library
             if (_resourceMetadata.ParentResourceId is not null)
             {
                 return ManagementClientGenerator.Instance.OutputLibrary.GetResourceById(_resourceMetadata.ParentResourceId).Type;
             }
+
+            // if not and this is an extension resource, we return ArmResource as the parent type as fallback
+            if (_resourceMetadata.ResourceScope == ResourceScope.Extension)
+            {
+                return typeof(ArmResource);
+            }
+
             // if it does not, this resource's parent must be one of the MockableResource
             return ManagementClientGenerator.Instance.OutputLibrary.GetMockableResourceByScope(_resourceMetadata.ResourceScope).ArmCoreType;
         }

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

@@ -126,8 +126,6 @@ private static RequestPathPattern GetContextualPath(ArmResourceMetadata resource
                 // For example, for path /providers/Microsoft.Management/serviceGroups/{servicegroupName}/providers/Microsoft.Edge/sites/{siteName}
                 // the contextual path is /providers/Microsoft.Management/serviceGroups/{servicegroupName}
                 // This ensures that servicegroupName is derived from the scope Id (id.Name) rather than being an extra constructor parameter.
-                // For specific extension resources (those targeting a known parent type like Microsoft.Compute/virtualMachines),
-                // the ParentResourceType property contains the explicit parent type for method name disambiguation.
                 return new RequestPathPattern(resourceMetadata.ResourceIdPattern).GetParent();
             }
 
@@ -199,7 +197,7 @@ private static void InitializeMethods(
 
         protected override FormattableString BuildDescription()
         {
-            var parentResourceType = GetParentResourceType(_resourceMetadata, _resource);
+            var parentResourceType = GetParentResourceType(_resourceMetadata, _resource) ?? typeof(ArmResource); // TODO: will update this with actual external resource type
             return $"A class representing a collection of {_resource.Type:C} and their operations.\nEach {_resource.Type:C} in the collection will belong to the same instance of {parentResourceType:C}.\nTo get a {Type:C} instance call the Get{ResourceName.Pluralize()} method from an instance of {parentResourceType:C}.";
         }
 
@@ -292,16 +290,16 @@ private ConstructorProvider BuildResourceIdentifierConstructor()
                 bodyStatements.Add(clientInfo.RestClientField.Assign(New.Instance(clientInfo.RestClientProvider.Type, clientInfo.DiagnosticsField, thisCollection.Pipeline(), thisCollection.Endpoint(), effectiveApiVersion)).Terminate());
             }
 
-            // Do not call ValidateResourceId for Extension resources
-            if (_resourceMetadata.ResourceScope != ResourceScope.Extension)
+            // skip resource Id validation for extension resource without parent resource type, since we don't have enough information to validate the resource Id. For example, for an extension resource with resource scope of extension and no parent resource type specified, the resource Id pattern could be something like /{scope}/providers/Microsoft.ABC/def/{defName}, in this case we don't know what the {scope} is, it could be subscription, resource group, or even a management group, so we can't validate the resource Id.
+            if (_resourceMetadata.ResourceScope != ResourceScope.Extension || !string.IsNullOrEmpty(_resourceMetadata.ParentResourceType))
             {
                 bodyStatements.Add(Static(Type).As<ArmCollection>().ValidateResourceId(idParameter).Terminate());
             }
 
             return new ConstructorProvider(signature, bodyStatements, this);
         }
 
-        private static CSharpType GetParentResourceType(ArmResourceMetadata resourceMetadata, ResourceClientProvider resource)
+        private static CSharpType? GetParentResourceType(ArmResourceMetadata resourceMetadata, ResourceClientProvider resource)
         {
             // First check if the resource has a parent resource
             if (resourceMetadata.ParentResourceId is not null)
@@ -318,10 +316,12 @@ private static CSharpType GetParentResourceType(ArmResourceMetadata resourceMeta
                     return typeof(SubscriptionResource);
                 case ResourceScope.Tenant:
                     return typeof(TenantResource);
-                case ResourceScope.Extension:
-                    return typeof(ArmResource);
                 case ResourceScope.ManagementGroup:
                     return typeof(ManagementGroupResource);
+                case ResourceScope.Extension:
+                    // Generic-scope extension resources (e.g., /{scope}/providers/...) have no
+                    // specific parent type. Return null so callers fall back to ArmResource.
+                    return null;
                 default:
                     // TODO -- this is incorrect, but we put it here as a placeholder.
                     return resource.Type;
@@ -331,11 +331,16 @@ private static CSharpType GetParentResourceType(ArmResourceMetadata resourceMeta
         protected override MethodProvider[] BuildMethods()
         {
             var methods = new List<MethodProvider>();
-
-            // Do not build ValidateResourceIdMethod for Extension resources
+            var parentResourceCsharpType = GetParentResourceType(_resourceMetadata, _resource);
             if (_resourceMetadata.ResourceScope != ResourceScope.Extension)
             {
-                methods.Add(ResourceMethodSnippets.BuildValidateResourceIdMethod(this, Static(GetParentResourceType(_resourceMetadata, _resource)).As<ArmResource>().ResourceType()));
+                methods.Add(ResourceMethodSnippets.BuildValidateResourceIdMethod(this,Static(parentResourceCsharpType!).As<ArmResource>().ResourceType()));
+            }
+            // For extension resource with parent resource type specified, we can also generate a ValidateResourceId method with parent resource type, which will be used in the Get{ResourceName} method in the parent resource's collection client.
+            // This is needed to ensure the resource Id passed in is valid and belongs to the correct parent resource type.
+            else if (!string.IsNullOrEmpty(_resourceMetadata.ParentResourceType))
+            {
+                methods.Add(ResourceMethodSnippets.BuildValidateResourceIdMethod(this, Literal(_resourceMetadata.ParentResourceType!)));
             }
 
             methods.AddRange(BuildCreateOrUpdateMethods());