Support excluding resource references from deps

Exclude resource references from "property dependencies" for remote components (i.e. MLCs) and for Calls. This way, component providers creating outputs for component inputs based on property dependencies won't create outputs for properties that only contain resource references.

Author: justinvp

sdk/Pulumi.Tests/Serialization/ResourceRefPropertyTests.cs

@@ -151,6 +151,51 @@ public async Task SerializeCustomResourceDownlevel(bool isPreview)
             Assert.Equal(id, v);
         }
 
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task SerializeCustomResourceDependencies(bool isPreview, bool excludeFromDependencies)
+        {
+            var resources = await RunAsync<MyStack>(isPreview);
+            var res = resources.OfType<MyCustomResource>().Single();
+
+            async Task Test<T>(T value)
+            {
+                var serializer = new Serializer(excessiveDebugOutput: false);
+                Serializer.CreateValue(await serializer.SerializeAsync("", value, true,
+                    excludeResourceReferencesFromDependencies: excludeFromDependencies));
+
+                if (excludeFromDependencies)
+                {
+                    Assert.Empty(serializer.DependentResources);
+                }
+                else
+                {
+                    Assert.Equal(new HashSet<Resource> { res }, serializer.DependentResources);
+                }
+            }
+
+            // Single resource.
+            await Test(res);
+
+            // Resource in list.
+            await Test(new List<Resource> { res });
+
+            // Resource in dictionary.
+            await Test(new Dictionary<string, Resource> { { "resource", res } });
+
+            // Single resource Input.
+            await Test((Input<Resource>)res);
+
+            // Resource in list of Inputs.
+            await Test(new List<Input<Resource>> { res });
+
+            // Resource in dictionary of Inputs.
+            await Test(new Dictionary<string, Input<Resource>> { { "resource", res } });
+        }
+
         public class DeserializeCustomResourceStack : Stack
         {
             [Output("values")]

sdk/Pulumi/Deployment/Deployment_Call.cs

@@ -88,7 +88,8 @@ private async Task<OutputData<T>> CallAsync<T>(
                     $"call:{token}",
                     argsDict, _ => true,
                     keepResources: true,
-                    keepOutputValues: await MonitorSupportsOutputValues().ConfigureAwait(false)).ConfigureAwait(false);
+                    keepOutputValues: await MonitorSupportsOutputValues().ConfigureAwait(false),
+                    excludeResourceReferencesFromDependencies: true).ConfigureAwait(false);
             Log.Debug($"Call RPC prepared: token={token}" +
                 (_excessiveDebugOutput ? $", obj={serialized}" : ""));
 

sdk/Pulumi/Deployment/Deployment_Prepare.cs

@@ -37,12 +37,20 @@ private async Task<PrepareResult> PrepareResourceAsync(
             // the Resources pointed to by any Dependency objects we encounter, adding them to 'propertyDependencies'.
             LogExcessive($"Serializing properties: t={type}, name={name}, custom={custom}, remote={remote}");
             var dictionary = await args.ToDictionaryAsync().ConfigureAwait(false);
+            var keepResources = await MonitorSupportsResourceReferences().ConfigureAwait(false);
+            var keepOutputValues = remote && await MonitorSupportsOutputValues().ConfigureAwait(false);
+            // When remote is true (and the monitor supports resource references), exclude resource references
+            // from `propertyToDirectDependencies`. This way, component providers creating outputs for component
+            // inputs based on "propertyDependencies" won't create outputs for properties that only contain
+            // resource references.
+            var excludeResourceReferencesFromDependencies = remote && keepResources;
             var (serializedProps, propertyToDirectDependencies) =
                 await SerializeResourcePropertiesAsync(
                         label,
                         dictionary,
-                        await this.MonitorSupportsResourceReferences().ConfigureAwait(false),
-                        keepOutputValues: remote && await MonitorSupportsOutputValues().ConfigureAwait(false)).ConfigureAwait(false);
+                        keepResources,
+                        keepOutputValues,
+                        excludeResourceReferencesFromDependencies).ConfigureAwait(false);
             LogExcessive($"Serialized properties: t={type}, name={name}, custom={custom}, remote={remote}");
 
             // Wait for the parent to complete.

sdk/Pulumi/Deployment/Deployment_Serialization.cs

@@ -20,20 +20,22 @@ public partial class Deployment
         /// to registerResource.
         /// </summary>
         private static Task<SerializationResult> SerializeResourcePropertiesAsync(
-            string label, IDictionary<string, object?> args, bool keepResources, bool keepOutputValues)
+            string label, IDictionary<string, object?> args, bool keepResources, bool keepOutputValues,
+            bool excludeResourceReferencesFromDependencies = false)
         {
             return SerializeFilteredPropertiesAsync(
                 label, args,
                 key => key != Constants.IdPropertyName && key != Constants.UrnPropertyName,
-                keepResources, keepOutputValues: keepOutputValues);
+                keepResources, keepOutputValues, excludeResourceReferencesFromDependencies);
         }
 
         private static async Task<Struct> SerializeAllPropertiesAsync(
-            string label, IDictionary<string, object?> args, bool keepResources, bool keepOutputValues = false)
+            string label, IDictionary<string, object?> args, bool keepResources, bool keepOutputValues = false,
+            bool excludeResourceReferencesFromDependencies = false)
         {
             var result = await SerializeFilteredPropertiesAsync(
                 label, args, _ => true,
-                keepResources, keepOutputValues).ConfigureAwait(false);
+                keepResources, keepOutputValues, excludeResourceReferencesFromDependencies).ConfigureAwait(false);
             return result.Serialized;
         }
 
@@ -52,10 +54,18 @@ private static async Task<Struct> SerializeAllPropertiesAsync(
         /// responsibility to ensure that the monitor supports the OutputValues
         /// feature.
         /// </param>
+        /// <param name="excludeResourceReferencesFromDependencies">
+        /// Specifies if we should exclude resource references from the resulting
+        /// <see cref="SerializationResult.PropertyToDependentResources"/>. This is useful for remote
+        /// components (i.e. multi-lang components, or MLCs) where we want property dependencies to be
+        /// empty for a property that only contains resource references.
+        /// </param>
         private static async Task<SerializationResult> SerializeFilteredPropertiesAsync(
-            string label, IDictionary<string, object?> args, Predicate<string> acceptKey, bool keepResources, bool keepOutputValues)
+            string label, IDictionary<string, object?> args, Predicate<string> acceptKey, bool keepResources, bool keepOutputValues,
+            bool excludeResourceReferencesFromDependencies = false)
         {
-            var result = await SerializeFilteredPropertiesRawAsync(label, args, acceptKey, keepResources, keepOutputValues);
+            var result = await SerializeFilteredPropertiesRawAsync(label, args, acceptKey, keepResources, keepOutputValues,
+                excludeResourceReferencesFromDependencies);
             return result.ToSerializationResult();
         }
 
@@ -64,7 +74,8 @@ private static async Task<SerializationResult> SerializeFilteredPropertiesAsync(
         /// last step of encoding the value into a Protobuf form.
         /// </summary>
         private static async Task<RawSerializationResult> SerializeFilteredPropertiesRawAsync(
-            string label, IDictionary<string, object?> args, Predicate<string> acceptKey, bool keepResources, bool keepOutputValues)
+            string label, IDictionary<string, object?> args, Predicate<string> acceptKey, bool keepResources, bool keepOutputValues,
+            bool excludeResourceReferencesFromDependencies = false)
         {
             var propertyToDependentResources = ImmutableDictionary.CreateBuilder<string, HashSet<Resource>>();
             var result = ImmutableDictionary.CreateBuilder<string, object>();
@@ -75,7 +86,8 @@ private static async Task<RawSerializationResult> SerializeFilteredPropertiesRaw
                 {
                     // We treat properties with null values as if they do not exist.
                     var serializer = new Serializer(_excessiveDebugOutput);
-                    var v = await serializer.SerializeAsync($"{label}.{key}", val, keepResources, keepOutputValues).ConfigureAwait(false);
+                    var v = await serializer.SerializeAsync($"{label}.{key}", val, keepResources, keepOutputValues,
+                        excludeResourceReferencesFromDependencies).ConfigureAwait(false);
                     if (v != null)
                     {
                         result[key] = v;