feat!: allow blocks to receive their own delete events

blocks/procedures.js

@@ -980,7 +980,7 @@ const PROCEDURE_CALL_COMMON = {
         Xml.domToWorkspace(xml, this.workspace);
         Events.setGroup(false);
       }
-    } else if (event.type === Events.BLOCK_DELETE) {
+    } else if (event.type === Events.BLOCK_DELETE && event.blockId != this.id) {
       // Look for the case where a procedure definition has been deleted,
       // leaving this block (a procedure call) orphaned.  In this case, delete
       // the orphan.

core/block.ts

@@ -316,18 +316,18 @@ export class Block implements IASTNodeLocation, IDeletable {
    */
   dispose(healStack: boolean) {
     if (this.disposed) {
-      // Already deleted.
       return;
     }
-    // Terminate onchange event calls.
-    if (this.onchangeWrapper_) {
-      this.workspace.removeChangeListener(this.onchangeWrapper_);
-    }
 
     this.unplug(healStack);
     if (eventUtils.isEnabled()) {
       eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_DELETE))!(this));
     }
+
+    if (this.onchangeWrapper_) {
+      this.workspace.removeChangeListener(this.onchangeWrapper_);
+    }
+
     eventUtils.disable();
 
     try {

tests/mocha/block_delete_event_test.js

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.declareModuleId('Blockly.test.blockDeleteEvent');
+
+import * as eventUtils from '../../build/src/core/events/utils.js';
+import {sharedTestSetup, sharedTestTeardown} from './test_helpers/setup_teardown.js';
+
+suite('Block Delete Event', function() {
+  setup(function() {
+    sharedTestSetup.call(this);
+    this.workspace = new Blockly.Workspace();
+  });
+
+  teardown(function() {
+    sharedTestTeardown.call(this);
+  });
+
+  suite('Receiving', function() {
+    test('blocks receive their own delete events', function() {
+      Blockly.Blocks['test'] = {
+        onchange: function(e) {},
+      };
+      // Need to stub the definition, because the property on the definition is
+      // what gets registered as an event listener.
+      const spy = sinon.spy(Blockly.Blocks['test'], 'onchange');
+      const testBlock = this.workspace.newBlock('test');
+
+      testBlock.dispose();
+
+      const deleteClass = eventUtils.get(eventUtils.BLOCK_DELETE);
+      chai.assert.isTrue(spy.calledOnce);
+      chai.assert.isTrue(spy.getCall(0).args[0] instanceof deleteClass);
+    });
+  });
+});

tests/mocha/index.html

@@ -51,6 +51,7 @@
 	  // Test modules.
 	  'Blockly.test.astNode',
 	  'Blockly.test.blockChangeEvent',
+    'Blockly.test.blockDeleteEvent',
 	  'Blockly.test.blockCreateEvent',
 	  'Blockly.test.blockJson',
 	  'Blockly.test.blocks',

tests/mocha/blocks/lists_test.js → tests/mocha/lists_test.js

@@ -6,10 +6,10 @@
 
 goog.declareModuleId('Blockly.test.lists');
 
-import {runSerializationTestSuite} from '../test_helpers/serialization.js';
-import {sharedTestSetup, sharedTestTeardown} from '../test_helpers/setup_teardown.js';
+import {runSerializationTestSuite} from './test_helpers/serialization.js';
+import {sharedTestSetup, sharedTestTeardown} from './test_helpers/setup_teardown.js';
 import {ConnectionType} from '../../build/src/core/connection_type.js';
-import {defineStatementBlock} from '../test_helpers/block_definitions.js';
+import {defineStatementBlock} from './test_helpers/block_definitions.js';
 
 
 suite('Lists', function() {

tests/mocha/blocks/logic_ternary_test.js → tests/mocha/logic_ternary_test.js

@@ -7,8 +7,8 @@
 goog.declareModuleId('Blockly.test.logicTernary');
 
 import * as eventUtils from '../../build/src/core/events/utils.js';
-import {runSerializationTestSuite} from '../test_helpers/serialization.js';
-import {sharedTestSetup, sharedTestTeardown} from '../test_helpers/setup_teardown.js';
+import {runSerializationTestSuite} from './test_helpers/serialization.js';
+import {sharedTestSetup, sharedTestTeardown} from './test_helpers/setup_teardown.js';
 
 
 suite('Logic ternary', function() {

tests/mocha/blocks/procedures_test.js → tests/mocha/procedures_test.js

@@ -7,10 +7,9 @@
 goog.declareModuleId('Blockly.test.procedures');
 
 import * as Blockly from '../../build/src/core/blockly.js';
-import {assertCallBlockStructure, assertDefBlockStructure, createProcDefBlock, createProcCallBlock} from '../test_helpers/procedures.js';
-import {runSerializationTestSuite} from '../test_helpers/serialization.js';
-import {createGenUidStubWithReturns, sharedTestSetup, sharedTestTeardown, workspaceTeardown} from '../test_helpers/setup_teardown.js';
-
+import {assertCallBlockStructure, assertDefBlockStructure, createProcDefBlock, createProcCallBlock} from './test_helpers/procedures.js';
+import {runSerializationTestSuite} from './test_helpers/serialization.js';
+import {createGenUidStubWithReturns, sharedTestSetup, sharedTestTeardown, workspaceTeardown} from './test_helpers/setup_teardown.js';
 
 suite('Procedures', function() {
   setup(function() {
@@ -1033,6 +1032,7 @@ suite('Procedures', function() {
           });
         });
       });
+
       /**
        * Test cases for serialization tests.
        * @type {Array<SerializationTestCase>}
@@ -1210,3 +1210,43 @@ suite('Procedures', function() {
     });
   });
 });
+
+suite('Procedures, dont auto fire events', function() {
+  setup(function() {
+    sharedTestSetup.call(this, {fireEventsNow: false});
+    this.workspace = new Blockly.Workspace();
+  });
+  teardown(function() {
+    sharedTestTeardown.call(this);
+  });
+
+  const testSuites = [
+    {title: 'procedures_defreturn', hasReturn: true,
+      defType: 'procedures_defreturn', callType: 'procedures_callreturn'},
+    {title: 'procedures_defnoreturn', hasReturn: false,
+      defType: 'procedures_defnoreturn', callType: 'procedures_callnoreturn'},
+  ];
+
+  testSuites.forEach((testSuite) => {
+    suite(testSuite.title, function() {
+      suite('Disposal', function() {
+        test('callers are disposed when definitions are disposed', function() {
+          this.defBlock = new Blockly.Block(this.workspace, testSuite.defType);
+          this.defBlock.setFieldValue('proc name', 'NAME');
+          this.callerBlock = new Blockly.Block(
+              this.workspace, testSuite.callType);
+          this.callerBlock.setFieldValue('proc name', 'NAME');
+
+          // Run the clock now so that the create events get fired. If we fire
+          // it after disposing, a new procedure def will get created when
+          // the caller create event is heard.
+          this.clock.runAll();
+          this.defBlock.dispose();
+          this.clock.runAll();
+
+          chai.assert.isTrue(this.callerBlock.disposed);
+        });
+      });
+    });
+  });
+});