clean up and implement the same for dictionary

Author: ArcturusZhang

sdk/provisioning/Azure.Provisioning/src/BicepDictionaryOfT.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using Azure.Provisioning.Expressions;
 using Azure.Provisioning.Primitives;
+using Azure.Provisioning.Utilities;
 
 namespace Azure.Provisioning;
 
@@ -58,7 +59,15 @@ internal override void Assign(IBicepValue source)
         {
             _values = typed._values;
         }
+
+        // Everything else is handled by the base Assign
         base.Assign(source);
+
+        // handle self in all the items
+        foreach (var kv in _values)
+        {
+            SetSelfForItem(kv.Value, kv.Key);
+        }
     }
 
     /// <summary>
@@ -68,23 +77,78 @@ internal override void Assign(IBicepValue source)
     public static implicit operator BicepDictionary<T>(ProvisioningVariable reference) =>
         new(new BicepValueReference(reference, "{}"), BicepSyntax.Var(reference.BicepIdentifier)) { _isSecure = reference is ProvisioningParameter p && p.IsSecure };
 
+    private BicepValueReference? GetItemSelf(string key) =>
+        _self is not null
+            ? new BicepDictionaryValueReference(_self.Construct, _self.PropertyName, _self.BicepPath?.ToArray(), key)
+            : null;
+
+    private void SetSelfForItem(BicepValue<T> item, string key)
+    {
+        var itemSelf = GetItemSelf(key);
+        item.SetSelf(itemSelf);
+    }
+
+    private void RemoveSelfForItem(BicepValue<T> item)
+    {
+        item.SetSelf(null);
+    }
+
     /// <summary>
     /// Gets or sets a value in a BicepDictionary.
     /// </summary>
     /// <param name="key">Key of the value.</param>
     /// <returns>The value.</returns>
     public BicepValue<T> this[string key]
     {
-        get => _values[key];
-        set => _values[key] = value;
+        get
+        {
+            if (_values.TryGetValue(key, out var value))
+            {
+                return value;
+            }
+            // the key does not exist, we put a value factory as the literal value of this bicep value
+            // this would blow up when we try to compile it later, but it would be fine if we convert it to an expression
+            return new BicepValue<T>(GetItemSelf(key), () => _values[key].Value);
+        }
+
+        set
+        {
+            _values[key] = value;
+            // update the _self pointing the new item
+            SetSelfForItem(value, key);
+        }
+    }
+
+    public void Add(string key, BicepValue<T> value)
+    {
+        _values.Add(key, value);
+        // update the _self pointing the new item
+        SetSelfForItem(value, key);
+    }
+
+    public void Add(KeyValuePair<string, BicepValue<T>> item)
+    {
+        _values.Add(item.Key, item.Value);
+        // update the _self pointing the new item
+        SetSelfForItem(item.Value, item.Key);
     }
 
-    public void Add(string key, BicepValue<T> value) => _values.Add(key, value);
-    public void Add(KeyValuePair<string, BicepValue<T>> item) => _values.Add(item.Key, item.Value);
+    public bool Remove(string key)
+    {
+        var removedItem = _values[key];
+        // maintain the self reference for the removed item
+        RemoveSelfForItem(removedItem);
+        return _values.Remove(key);
+    }
 
-    // TODO: Decide whether it's important to "unlink" resources on removal
-    public bool Remove(string key) => _values.Remove(key);
-    public void Clear() => _values.Clear();
+    public void Clear()
+    {
+        foreach (var kv in _values)
+        {
+            RemoveSelfForItem(kv.Value);
+        }
+        _values.Clear();
+    }
 
     public ICollection<string> Keys => _values.Keys;
     public ICollection<BicepValue<T>> Values => _values.Values;

sdk/provisioning/Azure.Provisioning/src/BicepListOfT.cs

@@ -110,8 +110,7 @@ public BicepValue<T> this[int index]
                 }
                 // the index is out of range, we put a value factory as the literal value of this bicep value
                 // this would blow up when we try to compile it later, but it would be fine if we convert it to an expression
-                var value = new BicepValue<T>(GetItemSelf(index), () => _values[index].Value);
-                return value;
+                return new BicepValue<T>(GetItemSelf(index), () => _values[index].Value);
             }
         }
         set
@@ -133,11 +132,8 @@ _self is not null
 
     private void SetSelfForItem(BicepValue<T> item, int index)
     {
-        if (_self is not null)
-        {
-            var itemSelf = GetItemSelf(index);
-            item.SetSelf(itemSelf);
-        }
+        var itemSelf = GetItemSelf(index);
+        item.SetSelf(itemSelf);
     }
 
     private void RemoveSelfForItem(BicepValue<T> item)
@@ -188,12 +184,7 @@ public bool Remove(BicepValue<T> item)
         int index = _values.IndexOf(item);
         if (index >= 0)
         {
-            RemoveSelfForItem(item);
             RemoveAt(index);
-            for (int i = index; i < _values.Count; i++)
-            {
-                SetSelfForItem(_values[i], i);
-            }
             return true;
         }
         return false;

sdk/provisioning/Azure.Provisioning/src/BicepValue.cs

@@ -91,10 +91,7 @@ private protected BicepValue(BicepValueReference? self, BicepExpression expressi
     public override string ToString() => Compile().ToString();
 
     /// <inheritdoc />
-    public BicepExpression Compile() => CompileCore();
-
-    private protected virtual BicepExpression CompileCore()
-        => BicepTypeMapping.ToBicep(this, Format);
+    public BicepExpression Compile() => BicepTypeMapping.ToBicep(this, Format);
 
     /// <inheritdoc />
     void IBicepValue.Assign(IBicepValue source) => Assign(source);

sdk/provisioning/Azure.Provisioning/src/Primitives/BicepValueReference.cs

@@ -49,7 +49,8 @@ internal virtual BicepExpression GetReference(bool throwIfNoRoot = true)
     public override string ToString() => GetReference(throwIfNoRoot: false).ToString();
 }
 
-internal class BicepListValueReference(ProvisionableConstruct construct, string propertyName, string[]? path, int index) : BicepValueReference(construct, propertyName, path)
+internal class BicepListValueReference(ProvisionableConstruct construct, string propertyName, string[]? path, int index)
+    : BicepValueReference(construct, propertyName, path)
 {
     public int Index { get; } = index;
 
@@ -58,3 +59,13 @@ internal override BicepExpression GetReference(bool throwIfNoRoot = true)
         return base.GetReference(throwIfNoRoot).Index(new IntLiteralExpression(Index));
     }
 }
+
+internal class BicepDictionaryValueReference(ProvisionableConstruct construct, string propertyName, string[]? path, string key)
+    : BicepValueReference(construct, propertyName, path)
+{
+    public string Key { get; } = key;
+    internal override BicepExpression GetReference(bool throwIfNoRoot = true)
+    {
+        return base.GetReference(throwIfNoRoot).Index(Key);
+    }
+}