Handle modern scope properties: readableScopes, writableScopes & new AllExceptExtension enum (#2574)

* all green

* unused ScopeType

* nit

* addressed comments, all green

* fix failing pr build

* updated schema baseline

Author: harshpatel17

bicep-types

@@ -5,20 +5,20 @@ import { ChoiceSchema, CodeModel, ComplexSchema, HttpMethod, HttpParameter, Http
 import { Channel, AutorestExtensionHost } from "@autorest/extension-base";
 import { keys, Dictionary, values, groupBy, uniqBy, chain, flatten } from 'lodash';
 import { success, failure, Result } from './utils';
-import { ScopeType } from "bicep-types";
+import { ScopeType, AllExceptExtension } from "bicep-types";
 
 export interface PutExample {
   description: string;
   body: Record<string, unknown>;
 }
 
 export interface ResourceDescriptor {
-  scopeType: ScopeType;
   namespace: string;
   typeSegments: string[];
   apiVersion: string;
+  readableScopes: ScopeType;
+  writableScopes: ScopeType;
   constantName?: string;
-  readonlyScopes?: ScopeType;
 }
 
 export interface ProviderDefinition {
@@ -639,12 +639,12 @@ export function getProviderDefinitions(codeModel: CodeModel, host: AutorestExten
     const constantName = isPathVariable(resNameParam) ? undefined : resNameParam;
 
     const descriptors: ResourceDescriptor[] = parseResult.value.map(type => ({
-      scopeType,
       namespace,
       typeSegments: type,
       apiVersion,
+      readableScopes: readable ? scopeType : ScopeType.None,
+      writableScopes: writable ? scopeType : ScopeType.None,
       constantName,
-      readonlyScopes: readable && !writable ? scopeType : undefined,
     }));
 
     return success(descriptors);
@@ -754,37 +754,8 @@ export function getProviderDefinitions(codeModel: CodeModel, host: AutorestExten
       return ScopeType.Extension;
     }
 
-    // ambiguous - without any further information, we have to assume 'all'
-    return ScopeType.Unknown;
-  }
-
-  function mergeScopes(scopeA: ScopeType, scopeB: ScopeType) {
-    // We have to assume any (unknown) scope if either scope is unknown
-    // Bitwise OR will not handle this case correctly as 'unknown' is 0.
-    if (scopeA == ScopeType.Unknown || scopeB == ScopeType.Unknown) {
-      return ScopeType.Unknown;
-    }
-
-    return scopeA | scopeB;
-  }
-
-  function mergeReadonlyScopes(
-    currentScopes: ScopeType,
-    currentReadonlyScopes: ScopeType|undefined,
-    newScopes: ScopeType,
-    newReadonlyScopes: ScopeType|undefined
-  ) {
-    function writableScopes(scopes: ScopeType, readonlyScopes: ScopeType|undefined) {
-      return readonlyScopes !== undefined ? scopes ^ readonlyScopes : scopes;
-    }
-    const mergedScopes = mergeScopes(currentScopes, newScopes);
-    if (mergedScopes === ScopeType.Unknown) {
-      const writingPermittedSomewhere = currentScopes !== currentReadonlyScopes || newScopes !== newReadonlyScopes;
-      return writingPermittedSomewhere ? undefined : ScopeType.Unknown;
-    }
-
-    const mergedWritableScopes = writableScopes(currentScopes, currentReadonlyScopes) | writableScopes(newScopes, newReadonlyScopes);
-    return mergedScopes === mergedWritableScopes ? undefined : mergedScopes ^ mergedWritableScopes;
+    // ambiguous - fallback to all standard scopes except extension
+    return AllExceptExtension;
   }
 
   function collapseDefinitionScopes(resources: ResourceDefinition[]) {
@@ -799,8 +770,8 @@ export function getProviderDefinitions(codeModel: CodeModel, host: AutorestExten
           ...definitionsByName[name],
           descriptor: {
             ...curDescriptor,
-            scopeType: mergeScopes(curDescriptor.scopeType, newDescriptor.scopeType),
-            readonlyScopes: mergeReadonlyScopes(curDescriptor.scopeType, curDescriptor.readonlyScopes, newDescriptor.scopeType, newDescriptor.readonlyScopes),
+            readableScopes: curDescriptor.readableScopes | newDescriptor.readableScopes,
+            writableScopes: curDescriptor.writableScopes | newDescriptor.writableScopes,
           },
         };
       } else {
@@ -846,19 +817,19 @@ export function getProviderDefinitions(codeModel: CodeModel, host: AutorestExten
         hasComparableSchemata(atPath, d => d.putOperation?.requestSchema) &&
         hasComparableSchemata(atPath, d => d.getOperation?.responseSchema)
       ) {
-        let scopeType = atPath[0].descriptor.scopeType;
-        let readonlyScopes = atPath[0].descriptor.readonlyScopes;
-        for (let i = 1; i < atPath.length; i++) {
-          const {scopeType: newScopes, readonlyScopes: newReadonlyScopes} = atPath[i].descriptor;
-          scopeType = mergeScopes(scopeType, newScopes);
-          readonlyScopes = mergeReadonlyScopes(scopeType, readonlyScopes, newScopes, newReadonlyScopes);
+        // Merge all scopes from different constant name variants
+        let readableScopes = ScopeType.None;
+        let writableScopes = ScopeType.None;
+        for (const resource of atPath) {
+          readableScopes |= resource.descriptor.readableScopes;
+          writableScopes |= resource.descriptor.writableScopes;
         }
 
         definitionsByNormalizedPath[path] = [{
           descriptor: {
             ...parameterized[0],
-            scopeType,
-            readonlyScopes,
+            readableScopes,
+            writableScopes,
           },
           putOperation: chain(atPath).map(r => r.putOperation).find().value(),
           getOperation: chain(atPath).map(r => r.getOperation).find().value(),

src/autorest.bicep/src/resources.ts

@@ -663,22 +663,25 @@ export function generateSchema(host: AutorestExtensionHost, definition: Provider
       generated[fullyQualifiedType.toLowerCase()] = schema;
       const definitionName = descriptor.typeSegments.join('_');
 
-      if (ScopeType.Tenant === (descriptor.scopeType & ScopeType.Tenant)) {
+      // Use modern writableScopes only
+      const writableScopes = descriptor.writableScopes;
+
+      if (writableScopes & ScopeType.Tenant) {
         schemaData.tenantResources[definitionName] = schema;
       }
-      if (ScopeType.ManagementGroup === (descriptor.scopeType & ScopeType.ManagementGroup)) {
+      if (writableScopes & ScopeType.ManagementGroup) {
         schemaData.mgResources[definitionName] = schema;
       }
-      if (ScopeType.Subscription === (descriptor.scopeType & ScopeType.Subscription)) {
+      if (writableScopes & ScopeType.Subscription) {
         schemaData.subResources[definitionName] = schema;
       }
-      if (ScopeType.ResourceGroup === (descriptor.scopeType & ScopeType.ResourceGroup)) {
+      if (writableScopes & ScopeType.ResourceGroup) {
         schemaData.rgResources[definitionName] = schema;
       }
-      if (ScopeType.Extension === (descriptor.scopeType & ScopeType.Extension)) {
+      if (writableScopes & ScopeType.Extension) {
         schemaData.extensionResources[definitionName] = schema;
       }
-      if (descriptor.scopeType === ScopeType.Unknown) {
+      if (writableScopes === ScopeType.None) {
         schemaData.unknownResources[definitionName] = schema;
       }
 

src/autorest.bicep/src/schema-generator.ts

@@ -21,7 +21,7 @@ import {
   UriSchema,
 } from "@autorest/codemodel";
 import { Channel, AutorestExtensionHost } from "@autorest/extension-base";
-import { DiscriminatedObjectType, ObjectTypeProperty, ObjectTypePropertyFlags, ResourceFlags, TypeBaseKind, TypeFactory, TypeReference } from "bicep-types";
+import { DiscriminatedObjectType, ObjectTypeProperty, ObjectTypePropertyFlags, TypeBaseKind, TypeFactory, TypeReference } from "bicep-types";
 import { uniq, keys, Dictionary, chain } from 'lodash';
 import { getFullyQualifiedType, getNameSchema, getSerializedName, NameSchema, ProviderDefinition, ResourceDefinition, ResourceDescriptor, ResourceOperationDefintion } from "./resources";
 import { failure, success } from "./utils";
@@ -160,6 +160,13 @@ export function generateTypes(host: AutorestExtensionHost, definition: ProviderD
     return resourceDefinition;
   }
 
+  function getScopesFromDefinition(definition: ResourceDefinition) {
+    return {
+      readableScopes: definition.descriptor.readableScopes,
+      writableScopes: definition.descriptor.writableScopes
+    };
+  }  
+  
   function processResource(fullyQualifiedType: string, definitions: ResourceDefinition[]) {
     if (definitions.length > 1) {
       for (const definition of definitions) {
@@ -220,17 +227,13 @@ export function generateTypes(host: AutorestExtensionHost, definition: ProviderD
       }
 
       const { descriptor, bodyType } = output;
-      let flags = ResourceFlags.None;
-      if (descriptor.readonlyScopes === descriptor.scopeType) {
-        flags |= ResourceFlags.ReadOnly;
-      }
-
+      const { readableScopes, writableScopes } = getScopesFromDefinition(definitions[0]);
       factory.addResourceType(
         `${getFullyQualifiedType(descriptor)}@${descriptor.apiVersion}`,
-        descriptor.scopeType,
-        descriptor.readonlyScopes !== descriptor.scopeType ? descriptor.readonlyScopes : undefined,
         bodyType,
-        flags);
+        readableScopes,
+        writableScopes
+      );
     }
 
     for (const action of resourceActions) {