Add & handle readableScopes + writableScopes properties (#17849)

## Description
The current _bicep-types_ ResourceType scope **legacy properties** are
prone to contradiction. In _bicep-types_ they have now been replaced
with **modern properties** which erases any confusion.

This PR has changes to handle the newest _bicep.types_ `0.6.12` which
contains these new modern properties and a few other changes:
- Added new modern properties to ResourceType called `readableScopes`
and `writableScopes`
- Deserialization will normalize legacy properties: `scopeType`, `flags`
& `readOnly` to the modern properties
- Introduced a constant called `All` which has all bits set to 1
- Renamed `ScopeType.Unknown` to `ScopeType.None`
- Behaviorally deprecated `ScopeType.Unknown` is equivalent to the new
`ScopeType.All`

## Example Usage

Let’s say a resource type has the following:  

```
{ 
  "scopes": ["resourceGroup", "subscription"], 
  "readOnlyScopes": ["tenant"], 
  "flags": "ReadOnly" 
} 
```

This is translated to:  
- scopes: Says the resource can be read from and written to
resourceGroup and subscription levels
- readOnlyScopes: Says the resource can only be read at tenant level 
- flags: ReadOnly: Says the resource type is read only

The contradiction: 
- resourceGroup: can read (from scopes), can write (from scopes) 
- subscription: can read (from scopes), can write (from scopes) 
- tenant: can read (from readOnlyScopes) 

But the flag says `ReadOnly`, which means the resource type can only be
referenced not written to. But scopes says otherwise.

With the changes in this PR we will go from this:  
```
{ 
  "scopes": ["subscription", "resourceGroup"], 
  "readOnlyScopes": ["tenant", "managementGroup"] 
} 
```

To this:  
```
{ 
  "writableScopes": ["subscription", "resourceGroup"], 
  "readableScopes": ["subscription", "resourceGroup", "tenant", "managementGroup"] 
} 
```

With this change, we can also support any resource types that may be
write only.

## Checklist

- [x] I have read and adhere to the [contribution
guide](https://github.com/Azure/bicep/blob/main/CONTRIBUTING.md).

###### Microsoft Reviewers: [Open in
CodeFlow](https://microsoft.github.io/open-pr/?codeflow=https://github.com/Azure/bicep/pull/17849)

Author: harshpatel17

src/Bicep.Core.IntegrationTests/Files/ExtensionRegistryTests/http/types/index.json

@@ -9,6 +9,8 @@
     "name": "http",
     "version": "1.2.3",
     "isSingleton": false,
+    "isPreview": false,
+    "isDeprecated": false,
     "configurationType": null
   },
   "fallbackResourceType": null

src/Bicep.Core.IntegrationTests/Files/ExtensionRegistryTests/http/types/v1/types.json

@@ -79,12 +79,14 @@
   {
     "$type": "ResourceType",
     "name": "request@v1",
-    "scopeType": 0,
-    "readOnlyScopes": null,
     "body": {
       "$ref": "#/6"
     },
-    "flags": 0,
-    "functions": null
+    "functions": null,
+    "readableScopes": 31,
+    "writableScopes": 31,
+    "scopeType": null,
+    "readOnlyScopes": null,
+    "flags": null
   }
-]
+]

src/Bicep.Core.Samples/Files/baselines/Extensions_CRLF/main.json

@@ -10,7 +10,7 @@
     "_generator": {
       "name": "bicep",
       "version": "dev",
-      "templateHash": "14300936452791949961"
+      "templateHash": "12920343705566664077"
     }
   },
   "parameters": {
@@ -30,7 +30,7 @@
   "extensions": {
     "az": {
       "name": "AzureResourceManager",
-      "version": "0.2.789"
+      "version": "0.2.802"
     },
     "k8s": {
       "name": "Kubernetes",

src/Bicep.Core.Samples/Files/baselines/Extensions_CRLF/main.sourcemap.bicep

@@ -30,7 +30,7 @@ var strVar1 = 'strVar1Value'
 extension az
 //@    "az": {
 //@      "name": "AzureResourceManager",
-//@      "version": "0.2.789"
+//@      "version": "0.2.802"
 //@    },
 extension kubernetes as k8s
 //@    "k8s": {

src/Bicep.Core.Samples/Files/baselines/Extensions_CRLF/main.symbolicnames.json

@@ -10,7 +10,7 @@
     "_generator": {
       "name": "bicep",
       "version": "dev",
-      "templateHash": "14300936452791949961"
+      "templateHash": "12920343705566664077"
     }
   },
   "parameters": {
@@ -30,7 +30,7 @@
   "extensions": {
     "az": {
       "name": "AzureResourceManager",
-      "version": "0.2.789"
+      "version": "0.2.802"
     },
     "k8s": {
       "name": "Kubernetes",

src/Bicep.Core.UnitTests/TypeSystem/Az/AzResourceTypeProviderTests.cs

@@ -8,11 +8,14 @@
 using Bicep.Core.Semantics;
 using Bicep.Core.TypeSystem;
 using Bicep.Core.TypeSystem.Providers.Az;
+using Bicep.Core.TypeSystem.Providers.Extensibility;
 using Bicep.Core.TypeSystem.Types;
 using Bicep.Core.UnitTests.Assertions;
 using Bicep.Core.UnitTests.Utils;
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using AzTypes = Azure.Bicep.Types;
+using AzConcreteTypes = Azure.Bicep.Types.Concrete;
 
 namespace Bicep.Core.UnitTests.TypeSystem.Az
 {
@@ -258,6 +261,111 @@ Compilation createCompilation(string program) => Services
             _ => []
         };
 
+
+        [TestMethod]
+        public void AzResourceTypeFactory_ScopeTypeAll_ShouldReturnAllScopes()
+        {
+            // Test the ScopeType.All handling
+            var factory = new AzResourceTypeFactory();
+            var resourceType = CreateMockResourceType(
+                readableScopes: AzConcreteTypes.ScopeType.All,
+                writableScopes: AzConcreteTypes.ScopeType.All);
+
+            var result = factory.GetResourceType(resourceType, []);
+
+            // ScopeType.All should map to all deployment scopes including Resource/Extension
+            result.ValidParentScopes.Should().Be(
+                ResourceScope.Tenant | ResourceScope.ManagementGroup |
+                ResourceScope.Subscription | ResourceScope.ResourceGroup | ResourceScope.Resource);
+        }
+
+        [TestMethod]
+        public void AzResourceTypeFactory_DifferentReadableAndwritableScopes_ShouldNotSetReadOnlyFlag()
+        {
+            // Test that ReadOnly flag is NOT set when there are some writable scopes
+            var factory = new AzResourceTypeFactory();
+            var resourceType = CreateMockResourceType(
+                readableScopes: AzConcreteTypes.ScopeType.Tenant | AzConcreteTypes.ScopeType.Subscription | AzConcreteTypes.ScopeType.ResourceGroup,
+                writableScopes: AzConcreteTypes.ScopeType.Subscription | AzConcreteTypes.ScopeType.ResourceGroup);
+
+            var result = factory.GetResourceType(resourceType, []);
+
+            // Should NOT be marked as ReadOnly because there are writable scopes available
+            result.Flags.Should().NotHaveFlag(ResourceFlags.ReadOnly);
+            // ReadOnlyScopes should be readable scopes minus writable scopes (tenant only)
+            result.ReadOnlyScopes.Should().Be(ResourceScope.Tenant);
+            // ValidParentScopes should be the writable scopes
+            result.ValidParentScopes.Should().Be(ResourceScope.Subscription | ResourceScope.ResourceGroup);
+        }
+
+        [TestMethod]
+        public void AzResourceTypeFactory_SameReadableAndwritableScopes_ShouldNotSetReadOnlyFlag()
+        {
+            // Test when readable and writable scopes are identical
+            var factory = new AzResourceTypeFactory();
+            var resourceType = CreateMockResourceType(
+                readableScopes: AzConcreteTypes.ScopeType.Subscription | AzConcreteTypes.ScopeType.ResourceGroup,
+                writableScopes: AzConcreteTypes.ScopeType.Subscription | AzConcreteTypes.ScopeType.ResourceGroup);
+
+            var result = factory.GetResourceType(resourceType, []);
+
+            // Should NOT be marked as ReadOnly when readable and writable scopes are the same
+            result.Flags.Should().NotHaveFlag(ResourceFlags.ReadOnly);
+            result.ReadOnlyScopes.Should().Be(ResourceScope.None);
+        }
+
+        [TestMethod]
+        public void AzResourceTypeFactory_NowritableScopes_WithReadableScopes_ShouldSetReadOnlyFlag()
+        {
+            // Test resources that have readable scopes but no writable scopes (fully read-only)
+            var factory = new AzResourceTypeFactory();
+            var resourceType = CreateMockResourceType(
+                readableScopes: AzConcreteTypes.ScopeType.Tenant | AzConcreteTypes.ScopeType.Subscription,
+                writableScopes: (AzConcreteTypes.ScopeType)0);
+
+            var result = factory.GetResourceType(resourceType, []);
+
+            // Should be marked as ReadOnly because there are no writable scopes
+            result.Flags.Should().HaveFlag(ResourceFlags.ReadOnly);
+            result.ReadOnlyScopes.Should().Be(ResourceScope.Tenant | ResourceScope.Subscription);
+            result.ValidParentScopes.Should().Be(ResourceScope.None); // No writable scopes
+        }
+
+        [TestMethod]
+        public void AzResourceTypeFactory_ReadableNone_WithSpecificWritableScopes_ShouldUseWritableScopes()
+        {
+            var factory = new AzResourceTypeFactory();
+            var resourceType = CreateMockResourceType(
+                readableScopes: AzConcreteTypes.ScopeType.None,
+                writableScopes: AzConcreteTypes.ScopeType.Tenant | AzConcreteTypes.ScopeType.ManagementGroup |
+                               AzConcreteTypes.ScopeType.Subscription | AzConcreteTypes.ScopeType.ResourceGroup);
+
+            var result = factory.GetResourceType(resourceType, []);
+
+            // Should NOT be marked as ReadOnly because there are writable scopes
+            result.Flags.Should().NotHaveFlag(ResourceFlags.ReadOnly);
+            result.ValidParentScopes.Should().Be(
+                ResourceScope.Tenant | ResourceScope.ManagementGroup |
+                ResourceScope.Subscription | ResourceScope.ResourceGroup);
+            result.ReadOnlyScopes.Should().Be(ResourceScope.None);
+        }
+
+        private static AzConcreteTypes.ResourceType CreateMockResourceType(
+            AzConcreteTypes.ScopeType readableScopes,
+            AzConcreteTypes.ScopeType writableScopes,
+            string name = "Test.Provider/testResource@2021-01-01")
+        {
+            var factory = new AzConcreteTypes.TypeFactory([]);
+            var bodyType = factory.Create(() => new AzConcreteTypes.ObjectType("body", new Dictionary<string, AzConcreteTypes.ObjectTypeProperty>(), null));
+
+            return factory.Create(() => new AzConcreteTypes.ResourceType(
+                name,
+                factory.GetReference(bodyType),
+                null,
+                writableScopes_in: writableScopes,
+                readableScopes_in: readableScopes));
+        }
+
         private static void VisitAllReachableTypes(TypeSymbol typeSymbol, HashSet<TypeSymbol> visited)
         {
             if (visited.Contains(typeSymbol))

src/Bicep.Core.UnitTests/Utils/ExtensionResourceTypeHelper.cs

@@ -38,11 +38,10 @@ public static IReadOnlyDictionary<string, string> GetHttpExtensionTypes()
 
         var requestType = factory.Create(() => new ResourceType(
             "request@v1",
-            ScopeType.Unknown,
-            null,
             factory.GetReference(requestBodyType),
-            ResourceFlags.None,
-            null));
+            null,
+            writableScopes_in: ScopeType.All,
+            readableScopes_in: ScopeType.All));
 
         var settings = new TypeSettings(
             name: "http",
@@ -99,14 +98,13 @@ public static BinaryData GetTestTypesTgz()
 
         var fooType = factory.Create(() => new ResourceType(
             "fooType@v1",
-            ScopeType.Unknown,
-            null,
             factory.GetReference(fooBodyType),
-            ResourceFlags.None,
             new Dictionary<string, ResourceTypeFunction>
             {
                 ["convertBarToBaz"] = new(factory.GetReference(barFunctionType), "Converts a bar into a baz!")
-            }));
+            },
+            writableScopes_in: ScopeType.All,
+            readableScopes_in: ScopeType.All));
 
         var settings = new TypeSettings(name: "ThirdPartyExtension", version: "1.0.0", isSingleton: false, configurationType: null!);
 
@@ -142,14 +140,13 @@ public static BinaryData GetTestTypesTgzWithFallbackAndConfiguration(bool allCon
 
         var fooType = factory.Create(() => new ResourceType(
             "fooType@v1",
-            ScopeType.Unknown,
-            null,
             factory.GetReference(fooBodyType),
-            ResourceFlags.None,
             new Dictionary<string, ResourceTypeFunction>
             {
                 ["convertBarToBaz"] = new(factory.GetReference(barFunctionType), "Converts a bar into a baz!")
-            }));
+            },
+            writableScopes_in: ScopeType.All,
+            readableScopes_in: ScopeType.All));
 
         //setup fallback resource
         var fallbackBodyType = rootFactory.Create(() => new ObjectType("fallback body", new Dictionary<string, ObjectTypeProperty>
@@ -159,11 +156,10 @@ public static BinaryData GetTestTypesTgzWithFallbackAndConfiguration(bool allCon
 
         var fallbackType = rootFactory.Create(() => new ResourceType(
             "fallback",
-            ScopeType.Unknown,
-            null,
             rootFactory.GetReference(fallbackBodyType),
-            ResourceFlags.None,
-            null));
+            null,
+            writableScopes_in: ScopeType.All,
+            readableScopes_in: ScopeType.All));
 
         var fallbackResource = new CrossFileTypeReference("types.json", rootFactory.GetIndex(fallbackType));
 
@@ -210,11 +206,10 @@ public static BinaryData GetMockRadiusTypesTgz()
 
         var awsBucketsType = factory.Create(() => new ResourceType(
             "AWS.S3/Bucket@default",
-            ScopeType.Unknown,
-            null,
             factory.GetReference(awsBucketsBodyType),
-            ResourceFlags.None,
-            null));
+            null,
+            writableScopes_in: ScopeType.All,
+            readableScopes_in: ScopeType.All));
 
         var environmentsBodyType = factory.Create(() => new ObjectType("body", new Dictionary<string, ObjectTypeProperty>
         {
@@ -224,11 +219,10 @@ public static BinaryData GetMockRadiusTypesTgz()
 
         var environmentsType = factory.Create(() => new ResourceType(
             "Applications.Core/environments@2023-10-01-preview",
-            ScopeType.Unknown,
-            null,
             factory.GetReference(environmentsBodyType),
-            ResourceFlags.None,
-            null));
+            null,
+            writableScopes_in: ScopeType.All,
+            readableScopes_in: ScopeType.All));
 
         var applicationsBodyType = factory.Create(() => new ObjectType("body", new Dictionary<string, ObjectTypeProperty>
         {
@@ -238,11 +232,10 @@ public static BinaryData GetMockRadiusTypesTgz()
 
         var applicationsType = factory.Create(() => new ResourceType(
             "Applications.Core/applications@2023-10-01-preview",
-            ScopeType.Unknown,
-            null,
             factory.GetReference(applicationsBodyType),
-            ResourceFlags.None,
-            null));
+            null,
+            writableScopes_in: ScopeType.All,
+            readableScopes_in: ScopeType.All));
 
         var recipeType = factory.Create(() => new ObjectType("recipe", new Dictionary<string, ObjectTypeProperty>
         {
@@ -264,11 +257,10 @@ public static BinaryData GetMockRadiusTypesTgz()
 
         var extendersType = factory.Create(() => new ResourceType(
             "Applications.Core/extenders@2023-10-01-preview",
-            ScopeType.Unknown,
-            null,
             factory.GetReference(extendersBodyType),
-            ResourceFlags.None,
-            null));
+            null,
+            writableScopes_in: ScopeType.All,
+            readableScopes_in: ScopeType.All));
 
         var settings = new TypeSettings(name: "Radius", version: "1.0.0", isSingleton: false, configurationType: null!);
 

src/Bicep.Core/TypeSystem/Providers/Az/AzResourceTypeFactory.cs

@@ -35,7 +35,10 @@ public ResourceTypeComponents GetResourceType(Azure.Bicep.Types.Concrete.Resourc
                 }
             }
 
-            return new ResourceTypeComponents(resourceTypeReference, ToResourceScope(resourceType.ScopeType), ToResourceScope(resourceType.ReadOnlyScopes), ToResourceFlags(resourceType.Flags), bodyType);
+            var (readableScopes, writableScopes) = GetScopeInfo(resourceType);
+            var readOnlyScopes = readableScopes & ~writableScopes;
+
+            return new ResourceTypeComponents(resourceTypeReference, writableScopes, readOnlyScopes, ToResourceFlags(resourceType), bodyType);
         }
 
         public IEnumerable<FunctionOverload> GetResourceFunctionOverloads(Azure.Bicep.Types.Concrete.ResourceFunctionType resourceFunctionType)
@@ -234,20 +237,35 @@ private static TypeSymbolValidationFlags GetValidationFlags(bool isResourceBodyT
             return flags;
         }
 
-        private static ResourceFlags ToResourceFlags(Azure.Bicep.Types.Concrete.ResourceFlags input)
+        private static ResourceFlags ToResourceFlags(Azure.Bicep.Types.Concrete.ResourceType input)
         {
             var output = ResourceFlags.None;
-            if (input.HasFlag(Azure.Bicep.Types.Concrete.ResourceFlags.ReadOnly))
+
+            // Resource is ReadOnly if there are no writable scopes
+            if (input.WritableScopes == Azure.Bicep.Types.Concrete.ScopeType.None)
             {
                 output |= ResourceFlags.ReadOnly;
             }
 
             return output;
         }
 
+        private static (ResourceScope readableScopes, ResourceScope writableScopes) GetScopeInfo(Azure.Bicep.Types.Concrete.ResourceType resourceType)
+        {
+            var readableScopes = ToResourceScope(resourceType.ReadableScopes);
+            var writableScopes = ToResourceScope(resourceType.WritableScopes);
+            return (readableScopes, writableScopes);
+        }
+
         private static ResourceScope ToResourceScope(Azure.Bicep.Types.Concrete.ScopeType input)
         {
-            if (input == Azure.Bicep.Types.Concrete.ScopeType.Unknown)
+            if (input == Azure.Bicep.Types.Concrete.ScopeType.None)
+            {
+                // ScopeType.None means no valid scopes
+                return ResourceScope.None;
+            }
+
+            if (input == Azure.Bicep.Types.Concrete.ScopeType.All)
             {
                 return ResourceScope.Tenant | ResourceScope.ManagementGroup | ResourceScope.Subscription | ResourceScope.ResourceGroup | ResourceScope.Resource;
             }
@@ -260,8 +278,5 @@ private static ResourceScope ToResourceScope(Azure.Bicep.Types.Concrete.ScopeTyp
             output |= input.HasFlag(Azure.Bicep.Types.Concrete.ScopeType.ResourceGroup) ? ResourceScope.ResourceGroup : ResourceScope.None;
             return output;
         }
-
-        private static ResourceScope ToResourceScope(Azure.Bicep.Types.Concrete.ScopeType? input)
-            => input.HasValue ? ToResourceScope(input.Value) : ResourceScope.None;
     }
 }