Exclude resource refs from property dependencies for packaged components

sdk/Pulumi.Tests/Serialization/ResourceRefPropertyTests.cs

@@ -151,6 +151,42 @@ 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 } });
+        }
+
         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;