Parent property implementation

src/Bicep.Core.IntegrationTests/ParentResourceTests.cs

@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+using System.IO;
+using System.Linq;
+using System.Text;
+using Bicep.Core.Diagnostics;
+using Bicep.Core.Emit;
+using Bicep.Core.Semantics;
+using Bicep.Core.TypeSystem;
+using Bicep.Core.UnitTests;
+using Bicep.Core.UnitTests.Assertions;
+using Bicep.Core.UnitTests.Utils;
+using FluentAssertions;
+using FluentAssertions.Execution;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Bicep.Core.IntegrationTests
+{
+    [TestClass]
+    public class ParentPropertyResourceTests
+    {
+        [TestMethod]
+        public void NestedResources_symbols_are_bound()
+        {
+            var program = @"
+resource vnet 'Microsoft.Network/virtualNetworks@2020-06-01' = {
+  location: resourceGroup().location
+  name: 'myVnet'
+  properties: {
+    addressSpace: {
+      addressPrefixes: [
+        '10.0.0.0/20'
+      ]
+    }
+  }
+}
+
+resource subnet1 'Microsoft.Network/virtualNetworks/subnets@2020-06-01' = {
+  parent: vnet
+  name: 'subnet1'
+  properties: {
+    addressPrefix: '10.0.0.0/24'
+  }
+}
+
+resource subnet2 'Microsoft.Network/virtualNetworks/subnets@2020-06-01' = {
+  parent: vnet
+  name: 'subnet2'
+  properties: {
+    addressPrefix: '10.0.1.0/24'
+  }
+}
+";
+
+            var (template, diags, _) = CompilationHelper.Compile(program);
+
+            using (new AssertionScope())
+            {
+                template!.Should().NotBeNull();
+                diags.Should().BeEmpty();
+
+                template!.SelectToken("$.resources[0].name")!.Should().DeepEqual("myVnet");
+                template!.SelectToken("$.resources[1].name")!.Should().DeepEqual("[format('{0}/{1}', 'myVnet', 'subnet1')]");
+                template!.SelectToken("$.resources[2].name")!.Should().DeepEqual("[format('{0}/{1}', 'myVnet', 'subnet2')]");
+            }
+        }
+    }
+}

src/Bicep.Core.UnitTests/Assertions/JTokenAssertionsExtensions.cs

@@ -57,7 +57,7 @@ public static AndConstraint<JTokenAssertions> DeepEqual(this JTokenAssertions in
             Execute.Assertion
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(JToken.DeepEquals(instance.Subject, expected))
-                .FailWith("Expected '{0}' but got '{1}'", expected?.ToString(), instance.Subject?.ToString());
+                .FailWith("Expected {0} but got {1}", expected?.ToString(), instance.Subject?.ToString());
 
             return new AndConstraint<JTokenAssertions>(instance);
         }

src/Bicep.Core/Diagnostics/DiagnosticBuilder.cs

@@ -918,6 +918,16 @@ public Diagnostic RuntimePropertyNotAllowed(string property, IEnumerable<string>
                 "BCP161",
                 "Parameter modifiers are deprecated and will be removed in a future release. Use decorators instead (see https://aka.ms/BicepSpecParams for examples).",
                 DiagnosticLabel.Deprecated);
+
+            public ErrorDiagnostic ParentResourceTypeHasErrors(string resourceName) => new(
+                TextSpan,
+                "BCP162",
+                $"The resource type cannot be validated due to an error in parent resource \"{resourceName}\".");
+
+            public ErrorDiagnostic ResourceTypeIsNotValidParent(string resourceType, string parentResourceType) => new(
+                TextSpan,
+                "BCP163",
+                $"Resource type \"{resourceType}\" is not a valid child resource of parent \"{parentResourceType}\".");
         }
 
         public static DiagnosticBuilderInternal ForPosition(TextSpan span)

src/Bicep.Core/Emit/ExpressionConverter.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Azure.Deployments.Core.Extensions;
@@ -295,6 +296,32 @@ grandChildArrayAccess.BaseExpression is VariableAccessSyntax grandGrandChildVari
                 new JTokenExpression(propertyAccess.PropertyName.IdentifierName));
         }
 
+        public IEnumerable<LanguageExpression> GetResourceNameSegments(ResourceSymbol resourceSymbol, ResourceTypeReference typeReference)
+        {
+            var ancestors = this.context.SemanticModel.ResourceAncestors.GetAncestors(resourceSymbol);
+            if (ancestors.Length > 0)
+            {
+                Debug.Assert(ancestors.Length + 1 == typeReference.Types.Length, "ancestors.Length + 1 == typeReference.Types.Length");
+
+                return ancestors.Concat(resourceSymbol.AsEnumerable())
+                    .Select(x => GetResourceNameSyntax(x))
+                    .Select(x => ConvertExpression(x));
+            }
+
+            var nameSyntax = GetResourceNameSyntax(resourceSymbol);
+            var nameExpression = ConvertExpression(nameSyntax);
+
+            if (typeReference.Types.Length == 1)
+            {
+                return nameExpression.AsEnumerable();
+            }
+
+            return typeReference.Types.Select(
+                (type, i) => AppendProperties(
+                    CreateFunction("split", nameExpression, new JTokenExpression("/")),
+                    new JTokenExpression(i)));
+        }
+
         public LanguageExpression GetResourceNameExpression(ResourceSymbol resourceSymbol)
         {
             var nameValueSyntax = GetResourceNameSyntax(resourceSymbol);
@@ -348,22 +375,6 @@ public static SyntaxBase GetModuleNameSyntax(ModuleSymbol moduleSymbol)
             return moduleSymbol.SafeGetBodyPropertyValue(LanguageConstants.ResourceNamePropertyName) ?? throw new ArgumentException($"Expected module syntax body to contain property 'name'");
         }
 
-        public IEnumerable<LanguageExpression> GetResourceNameSegments(ResourceSymbol resourceSymbol, ResourceTypeReference typeReference)
-        {
-            if (typeReference.Types.Length == 1)
-            {
-                return GetResourceNameExpression(resourceSymbol).AsEnumerable();
-            }
-
-            return typeReference.Types.Select(
-                (type, i) => AppendProperties(
-                    CreateFunction(
-                        "split",
-                        GetResourceNameExpression(resourceSymbol),
-                        new JTokenExpression("/")),
-                    new JTokenExpression(i)));
-        }
-
         public LanguageExpression GetUnqualifiedResourceId(ResourceSymbol resourceSymbol)
         {
             var typeReference = EmitHelpers.GetTypeReference(resourceSymbol);
@@ -499,6 +510,9 @@ private LanguageExpression ConvertVariableAccess(VariableAccessSyntax variableAc
                     return GetReferenceExpression(resourceSymbol, typeReference, true);
 
                 case ModuleSymbol moduleSymbol:
+                    // referencing a module directly should be blocked at an earlier stage - there is nothing great we can codegen here.
+                    Debug.Fail("Found direct module variable access");
+
                     return GetModuleOutputsReferenceExpression(moduleSymbol);
 
                 case LocalVariableSymbol localVariableSymbol:

src/Bicep.Core/Emit/TemplateWriter.cs

@@ -37,6 +37,7 @@ public class TemplateWriter
 
         private static readonly ImmutableHashSet<string> ResourcePropertiesToOmit = new [] {
             LanguageConstants.ResourceScopePropertyName,
+            LanguageConstants.ResourceParentPropertyName,
             LanguageConstants.ResourceDependsOnPropertyName,
             LanguageConstants.ResourceNamePropertyName,
         }.ToImmutableHashSet();

src/Bicep.Core/LanguageConstants.cs

@@ -68,6 +68,7 @@ public static class LanguageConstants
         public const string ResourceTypePropertyName = "type";
         public const string ResourceApiVersionPropertyName = "apiVersion";
         public const string ResourceScopePropertyName = "scope";
+        public const string ResourceParentPropertyName = "parent";
         public const string ResourceDependsOnPropertyName = "dependsOn";
 
         public static readonly StringComparer IdentifierComparer = StringComparer.Ordinal;

src/Bicep.Core/Resources/ResourceTypeReference.cs

@@ -51,6 +51,8 @@ public ResourceTypeReference(string @namespace, IEnumerable<string> types, strin
         public string FormatName()
             => $"{this.FullyQualifiedType}@{this.ApiVersion}";
 
+        public bool IsRootType => Types.Length == 1;
+
         public bool IsParentOf(ResourceTypeReference other)
         {
             return 

src/Bicep.Core/Semantics/ResourceAncestorGraph.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 using Bicep.Core.Diagnostics;
 using Bicep.Core.Syntax;
 
@@ -30,11 +31,26 @@ public ImmutableArray<ResourceSymbol> GetAncestors(ResourceSymbol resource)
             }
         }
 
+        private static IEnumerable<ResourceSymbol> GetAncestorsYoungestToOldest(ImmutableDictionary<ResourceSymbol, ResourceSymbol> hierarchy, ResourceSymbol resource)
+        {
+            while (hierarchy.TryGetValue(resource, out var parentResource))
+            {
+                yield return parentResource;
+
+                resource = parentResource;
+            }
+        }
+
         public static ResourceAncestorGraph Compute(SyntaxTree syntaxTree, IBinder binder)
         {
             var visitor = new ResourceAncestorVisitor(binder);
             visitor.Visit(syntaxTree.ProgramSyntax);
-            return new ResourceAncestorGraph(visitor.Ancestry);
+
+            var ancestry = visitor.Ancestry.Keys.ToImmutableDictionary(
+                child => child,
+                child => GetAncestorsYoungestToOldest(visitor.Ancestry, child).Reverse().ToImmutableArray());
+
+            return new ResourceAncestorGraph(ancestry);
         }
     }
 }

src/Bicep.Core/Semantics/ResourceAncestorVisitor.cs

@@ -11,17 +11,15 @@ namespace Bicep.Core.Semantics
     public sealed class ResourceAncestorVisitor : SyntaxVisitor
     {
         private readonly IBinder binder;
-        private readonly Stack<ResourceSymbol> ancestorResources;
-        private readonly ImmutableDictionary<ResourceSymbol, ImmutableArray<ResourceSymbol>>.Builder ancestry;
+        private readonly ImmutableDictionary<ResourceSymbol, ResourceSymbol>.Builder ancestry;
 
         public ResourceAncestorVisitor(IBinder binder)
         {
             this.binder = binder;
-            this.ancestorResources = new Stack<ResourceSymbol>();
-            this.ancestry = ImmutableDictionary.CreateBuilder<ResourceSymbol, ImmutableArray<ResourceSymbol>>();
+            this.ancestry = ImmutableDictionary.CreateBuilder<ResourceSymbol, ResourceSymbol>();
         }
 
-        public ImmutableDictionary<ResourceSymbol, ImmutableArray<ResourceSymbol>> Ancestry 
+        public ImmutableDictionary<ResourceSymbol, ResourceSymbol> Ancestry 
             => this.ancestry.ToImmutableDictionary();
 
         public override void VisitResourceDeclarationSyntax(ResourceDeclarationSyntax syntax)
@@ -33,21 +31,26 @@ public override void VisitResourceDeclarationSyntax(ResourceDeclarationSyntax sy
                 base.VisitResourceDeclarationSyntax(syntax);
                 return;
             }
-
-            // We don't need to do anything here to validate types and their relationships, that was handled during type assignment.
-            this.ancestry.Add(symbol, ImmutableArray.CreateRange(this.ancestorResources.Reverse()));
-
-            try
+
+            if (this.binder.GetNearestAncestor<ResourceDeclarationSyntax>(syntax) is {} nestedParentSyntax)
             {
-                // This will recursively process the resource body - capture the 'current' declaration's declared resource
-                // type so we can validate nesting.
-                this.ancestorResources.Push(symbol);
-                base.VisitResourceDeclarationSyntax(syntax);
+                // nested resource parent syntax
+                if (this.binder.GetSymbolInfo(nestedParentSyntax) is ResourceSymbol parentSymbol)
+                {
+                    this.ancestry.Add(symbol, parentSymbol);
+                }
             }
-            finally
+            else if (symbol.SafeGetBodyPropertyValue(LanguageConstants.ResourceParentPropertyName) is {} referenceParentSyntax)
             {
-                this.ancestorResources.Pop();
+                // parent property reference syntax
+                if (this.binder.GetSymbolInfo(referenceParentSyntax) is ResourceSymbol parentSymbol)
+                {
+                    this.ancestry.Add(symbol, parentSymbol);
+                }
             }
+
+            base.VisitResourceDeclarationSyntax(syntax);
+            return;
         }
     }
 }

src/Bicep.Core/Syntax/ResourceDeclarationSyntax.cs

@@ -81,13 +81,32 @@ public TypeSymbol GetDeclaredType(IBinder binder, IResourceTypeProvider resource
             ResourceTypeReference? typeReference;
             var ancestors = binder.GetAllAncestors<ResourceDeclarationSyntax>(this);
             if (ancestors.Length == 0)
-            {
+            {                
                 // This is a top level resource - the type is a fully-qualified type.
                 typeReference = ResourceTypeReference.TryParse(stringContent);
                 if (typeReference == null)
                 {
                     return ErrorType.Create(DiagnosticBuilder.ForPosition(this.Type).InvalidResourceType());
                 }
+
+                if (binder.GetSymbolInfo(this) is ResourceSymbol resourceSymbol &&
+                    resourceSymbol.SafeGetBodyPropertyValue(LanguageConstants.ResourceParentPropertyName) is {} referenceParentSyntax &&
+                    binder.GetSymbolInfo(referenceParentSyntax) is ResourceSymbol parentResourceSymbol)
+                {
+                    var parentType = parentResourceSymbol.DeclaringResource.GetDeclaredType(binder, resourceTypeProvider);
+                    if (parentType is not ResourceType parentResourceType)
+                    {
+                        // TODO should we raise an error, or just rely on the error on the parent?
+                        return ErrorType.Create(DiagnosticBuilder.ForPosition(referenceParentSyntax).ParentResourceTypeHasErrors(parentResourceSymbol.DeclaringResource.Name.IdentifierName));
+                    }
+
+                    if (!parentResourceType.TypeReference.IsParentOf(typeReference))
+                    {
+                        return ErrorType.Create(DiagnosticBuilder.ForPosition(referenceParentSyntax).ResourceTypeIsNotValidParent(
+                            typeReference.FullyQualifiedType,
+                            parentResourceType.TypeReference.FullyQualifiedType));
+                    }
+                }
             }
             else
             {

src/Bicep.Core/TypeSystem/Az/AzResourceTypeProvider.cs

@@ -69,12 +69,12 @@ public static ResourceType SetBicepResourceProperties(ResourceType resourceType,
             switch (bodyType)
             {
                 case ObjectType bodyObjectType:
-                    bodyType = SetBicepResourceProperties(bodyObjectType, resourceType.ValidParentScopes, isExistingResource);
+                    bodyType = SetBicepResourceProperties(bodyObjectType, resourceType.ValidParentScopes, resourceType.TypeReference, isExistingResource);
                     break;
                 case DiscriminatedObjectType bodyDiscriminatedType:
                     var bodyTypes = bodyDiscriminatedType.UnionMembersByKey.Values.ToList()
                         .Select(x => x.Type as ObjectType ?? throw new ArgumentException($"Resource {resourceType.Name} has unexpected body type {bodyType.GetType()}"));
-                    bodyTypes = bodyTypes.Select(x => SetBicepResourceProperties(x, resourceType.ValidParentScopes, isExistingResource));
+                    bodyTypes = bodyTypes.Select(x => SetBicepResourceProperties(x, resourceType.ValidParentScopes, resourceType.TypeReference, isExistingResource));
                     bodyType = new DiscriminatedObjectType(
                         bodyDiscriminatedType.Name,
                         bodyDiscriminatedType.ValidationFlags,
@@ -90,7 +90,7 @@ public static ResourceType SetBicepResourceProperties(ResourceType resourceType,
             return new ResourceType(resourceType.TypeReference, resourceType.ValidParentScopes, bodyType);
         }
 
-        private static ObjectType SetBicepResourceProperties(ObjectType objectType, ResourceScope validParentScopes, bool isExistingResource)
+        private static ObjectType SetBicepResourceProperties(ObjectType objectType, ResourceScope validParentScopes, ResourceTypeReference typeReference, bool isExistingResource)
         {
             var properties = objectType.Properties;
 
@@ -119,6 +119,16 @@ private static ObjectType SetBicepResourceProperties(ObjectType objectType, Reso
                     properties = properties.SetItem(LanguageConstants.ResourceScopePropertyName, new TypeProperty(LanguageConstants.ResourceScopePropertyName, scopeReference, scopePropertyFlags));
                 }
             }
+
+            // add the 'parent' property for child resource types
+            if (!typeReference.IsRootType)
+            {
+                var parentType = LanguageConstants.CreateResourceScopeReference(ResourceScope.Resource);
+                var parentFlags = TypePropertyFlags.WriteOnly | TypePropertyFlags.DeployTimeConstant;
+
+                properties = properties.SetItem(LanguageConstants.ResourceParentPropertyName, new TypeProperty(LanguageConstants.ResourceParentPropertyName, parentType, parentFlags));
+            }
+
             // Deployments RP
             if (StringComparer.OrdinalIgnoreCase.Equals(objectType.Name, ResourceTypeDeployments))
             {