fix: Detect if deleting shadow block affects selection highlight

core/block.ts

@@ -319,6 +319,20 @@ export class Block implements IASTNodeLocation {
     }
   }
 
+  /**
+   * Returns true if this block is the same block as the given block or contains
+   * the provided block as a descendent.
+   *
+   * @param other the other block to compare to.
+   */
+  contains(other: Block | null): boolean {
+    while (other !== null) {
+      if (other === this) return true;
+      other = other.parentBlock_;
+    }
+    return false;
+  }
+
   /**
    * Dispose of this block.
    *

core/block_svg.ts

@@ -278,7 +278,7 @@ export class BlockSvg
     this.addSelect();
   }
 
-  /** Unselects this block. Unhighlights the blockv visually.   */
+  /** Unselects this block. Unhighlights the block visually. */
   unselect() {
     if (this.isShadow()) {
       this.getParent()?.unselect();
@@ -798,6 +798,16 @@ export class BlockSvg
       blockAnimations.disposeUiEffect(this);
     }
 
+    // Selecting a shadow block highlights an ancestor block, but that highlight
+    // should be removed if the shadow block will be deleted. So, before
+    // deleting blocks and severing the connections between them, check whether
+    // doing so would delete a selected block and make sure that any associated
+    // parent is updated.
+    const selection = common.getSelected();
+    if (selection instanceof Block && this.contains(selection)) {
+      selection.unselect();
+    }
+
     super.dispose(!!healStack);
     dom.removeNode(this.svgGroup_);
   }

tests/mocha/block_test.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as common from '../../build/src/core/common.js';
 import {ConnectionType} from '../../build/src/core/connection_type.js';
 import * as eventUtils from '../../build/src/core/events/utils.js';
 import {EndRowInput} from '../../build/src/core/inputs/end_row_input.js';
@@ -208,6 +209,44 @@ suite('Blocks', function () {
     });
   });
 
+  suite('Contains', function () {
+    setup(function () {
+      this.blocks = createTestBlocks(this.workspace, true);
+    });
+
+    test('contains parent is false', function () {
+      const blocks = this.blocks;
+      assert.isFalse(
+        blocks.B.contains(blocks.A),
+        'Expected child to not contain parent.',
+      );
+    });
+
+    test('contains self is true', function () {
+      const blocks = this.blocks;
+      assert.isTrue(
+        blocks.A.contains(blocks.A),
+        'Expected block to contain self.',
+      );
+    });
+
+    test('contains child is true', function () {
+      const blocks = this.blocks;
+      assert.isTrue(
+        blocks.A.contains(blocks.B),
+        'Expected block to contain child.',
+      );
+    });
+
+    test('contains grand child is true', function () {
+      const blocks = this.blocks;
+      assert.isTrue(
+        blocks.A.contains(blocks.C),
+        'Expected block to contain grandchild.',
+      );
+    });
+  });
+
   suite('Disposal', function () {
     suite('calling destroy', function () {
       setup(function () {
@@ -443,6 +482,39 @@ suite('Blocks', function () {
         });
       });
     });
+
+    suite('Disposing selected shadow block', function () {
+      setup(function () {
+        this.workspace = Blockly.inject('blocklyDiv');
+        this.parentBlock = this.workspace.newBlock('row_block');
+        this.parentBlock.initSvg();
+        this.parentBlock.render();
+        this.parentBlock.inputList[0].connection.setShadowState({
+          'type': 'row_block',
+          'id': 'shadow_child',
+        });
+        this.shadowChild =
+          this.parentBlock.inputList[0].connection.targetConnection.getSourceBlock();
+      });
+
+      teardown(function () {
+        workspaceTeardown.call(this, this.workspace);
+      });
+
+      test('Disposing selected shadow unhighlights parent', function () {
+        const parentBlock = this.parentBlock;
+        common.setSelected(this.shadowChild);
+        assert.isTrue(
+          parentBlock.pathObject.svgRoot.classList.contains('blocklySelected'),
+          'Expected parent to be highlighted after selecting shadow child',
+        );
+        this.shadowChild.dispose();
+        assert.isFalse(
+          parentBlock.pathObject.svgRoot.classList.contains('blocklySelected'),
+          'Expected parent to be unhighlighted after deleting shadow child',
+        );
+      });
+    });
   });
 
   suite('Remove Input', function () {