Invoke Created action from HotReloadException constructor

Author: tmat

src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs

@@ -329,11 +329,12 @@ private SynthesizedHotReloadExceptionSymbol GetOrCreateSynthesizedHotReloadExcep
             }
 
             var exceptionType = Compilation.GetWellKnownType(WellKnownType.System_Exception);
+            var actionOfTType = Compilation.GetWellKnownType(WellKnownType.System_Action_T);
             var stringType = Compilation.GetSpecialType(SpecialType.System_String);
             var intType = Compilation.GetSpecialType(SpecialType.System_Int32);
 
             var containingNamespace = GetOrSynthesizeNamespace(SynthesizedHotReloadExceptionSymbol.NamespaceName);
-            symbol = new SynthesizedHotReloadExceptionSymbol(containingNamespace, exceptionType, stringType, intType);
+            symbol = new SynthesizedHotReloadExceptionSymbol(containingNamespace, exceptionType, actionOfTType, stringType, intType);
 
             Interlocked.CompareExchange(ref _lazyHotReloadExceptionType, symbol, comparand: null);
             return _lazyHotReloadExceptionType;

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedHotReloadExceptionConstructorSymbol.cs

@@ -52,15 +52,44 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
                 return;
             }
 
+            var delegateInvoke = (containingType.CreatedActionField.Type as NamedTypeSymbol)?.DelegateInvokeMethod;
+            if (delegateInvoke is null)
+            {
+                diagnostics.Add(ErrorCode.ERR_EncUpdateFailedMissingSymbol,
+                    Location.None,
+                    CodeAnalysisResources.Method,
+                    "System.Delegate.Invoke");
+
+                factory.CloseMethod(factory.Block());
+                return;
+            }
+
+            var actionTemp = factory.StoreToTemp(
+                factory.Field(receiver: null, containingType.CreatedActionField),
+                out var storeAction);
+
             var block = factory.Block(
-                ImmutableArray.Create<BoundStatement>(
-                    factory.ExpressionStatement(factory.Call(
-                        factory.This(),
-                        exceptionConstructor,
-                        factory.Parameter(MessageParameter))),
-                    factory.Assignment(factory.Field(factory.This(), containingType.CodeField), factory.Parameter(CodeParameter)),
-                    factory.Return()
-                ));
+                [actionTemp.LocalSymbol],
+
+                // base(message)
+                factory.ExpressionStatement(factory.Call(
+                    factory.This(),
+                    exceptionConstructor,
+                    factory.Parameter(MessageParameter))),
+
+                // this.CodeField = code;
+                factory.Assignment(factory.Field(factory.This(), containingType.CodeField), factory.Parameter(CodeParameter)),
+
+                // s_created?.Invoke(this);
+                factory.If(
+                    factory.IsNotNullReference(storeAction),
+                    factory.ExpressionStatement(
+                        factory.Call(
+                            actionTemp,
+                            delegateInvoke,
+                            factory.This()))),
+
+                factory.Return());
 
             factory.CloseMethod(block);
         }

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedHotReloadExceptionSymbol.cs

@@ -22,6 +22,12 @@ internal sealed class SynthesizedHotReloadExceptionSymbol : NamedTypeSymbol
         public const string TypeName = "HotReloadException";
         public const string CodeFieldName = "Code";
 
+        /// <summary>
+        /// The Hot Reload agent that's injected into the application needs to intercept creation of a runtime rude edit.
+        /// It uses reflection to set this action field.
+        /// </summary>
+        public const string CreatedActionFieldName = "Created";
+
         private readonly NamedTypeSymbol _baseType;
         private readonly NamespaceSymbol _namespace;
 
@@ -31,6 +37,7 @@ internal sealed class SynthesizedHotReloadExceptionSymbol : NamedTypeSymbol
         public SynthesizedHotReloadExceptionSymbol(
             NamespaceSymbol containingNamespace,
             NamedTypeSymbol exceptionType,
+            NamedTypeSymbol actionOfTType,
             TypeSymbol stringType,
             TypeSymbol intType)
         {
@@ -40,7 +47,8 @@ public SynthesizedHotReloadExceptionSymbol(
             _members =
             [
                 new SynthesizedHotReloadExceptionConstructorSymbol(this, stringType, intType),
-                new SynthesizedFieldSymbol(this, intType, CodeFieldName, isPublic: true, isReadOnly: true, isStatic: false)
+                new SynthesizedFieldSymbol(this, intType, CodeFieldName, isPublic: true, isReadOnly: true, isStatic: false),
+                new SynthesizedFieldSymbol(this, actionOfTType.Construct(exceptionType), CreatedActionFieldName, isPublic: false, isReadOnly: false, isStatic: true)
             ];
         }
 
@@ -50,6 +58,9 @@ public MethodSymbol Constructor
         public FieldSymbol CodeField
             => (FieldSymbol)_members[1];
 
+        public FieldSymbol CreatedActionField
+            => (FieldSymbol)_members[2];
+
         public override ImmutableArray<Symbol> GetMembers()
            => _members;
 
@@ -58,14 +69,15 @@ public override ImmutableArray<Symbol> GetMembers(string name)
             {
                 WellKnownMemberNames.InstanceConstructorName => [Constructor],
                 CodeFieldName => [CodeField],
+                CreatedActionFieldName => [CreatedActionField],
                 _ => []
             };
 
         public override IEnumerable<string> MemberNames
             => _members.Select(static m => m.Name);
 
         internal override IEnumerable<FieldSymbol> GetFieldsToEmit()
-            => [CodeField];
+            => [CodeField, CreatedActionField];
 
         public override ImmutableArray<NamedTypeSymbol> GetTypeMembers() => [];
         public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name) => [];