fix(core): set current tnode in foreign component instruction on reuse

Previously, the `ɵɵforeignComponent` instruction set the `currentTNode`
state during the first template creation pass (via `getOrCreateTNode`),
but failed to do so on subsequent instantiations when the `TNode` was
accessed from cache.

This resulted in the global `currentTNode` state remaining unchanged from
the previous instruction. When closing a parent element (e.g., via
`ɵɵelementEnd`), this mismatched state caused assertion failures
because the framework attempted to close the wrong parent node.
This change fixes the issue by calling `setCurrentTNode(tNode, false)`
when the foreign component's `TNode` is retrieved from the cache.

Author: leonsenft

packages/core/src/render3/instructions/foreign_component.ts

@@ -12,7 +12,7 @@ import {createForeignView} from '../foreign_view';
 import {TContainerNode, TNodeType} from '../interfaces/node';
 import {HEADER_OFFSET, RENDERER} from '../interfaces/view';
 import {appendChild} from '../node_manipulation';
-import {getLView, getTView, setCurrentTNodeAsNotParent} from '../state';
+import {getLView, getTView, setCurrentTNode, setCurrentTNodeAsNotParent} from '../state';
 import {getOrCreateTNode} from '../tnode_manipulation';
 import {addToEndOfViewTree} from '../view/construction';
 import {createLContainer} from '../view/container';
@@ -40,11 +40,12 @@ export function ɵɵforeignComponent(
   let tNode: TContainerNode;
   if (tView.firstCreatePass) {
     tNode = getOrCreateTNode(tView, adjustedIndex, TNodeType.Container, null, null);
+    // `getOrCreateTNode` unconditionally sets the current node as a parent node, which it is not.
+    setCurrentTNodeAsNotParent();
   } else {
     tNode = tView.data[adjustedIndex] as TContainerNode;
+    setCurrentTNode(tNode, false);
   }
-  // `getOrCreateTNode` unconditionally sets the current node as a parent node, which it is not.
-  setCurrentTNodeAsNotParent();
 
   // 2. Create the anchor node in the DOM
   const renderer = lView[RENDERER];

packages/core/test/render3/foreign_component_spec.ts

@@ -14,6 +14,9 @@ import {ɵɵelement, ɵɵelementEnd, ɵɵelementStart} from '../../src/render3/i
 import {inject, InjectionToken} from '../../src/di';
 import {ɵɵdefineDirective} from '../../src/render3/definition';
 import {ɵɵProvidersFeature} from '../../src/render3/features/providers_feature';
+import {createLView} from '../../src/render3/view/construction';
+import {renderView} from '../../src/render3/instructions/render';
+import {LView, LViewFlags, PARENT, RENDERER, T_HOST} from '../../src/render3/interfaces/view';
 
 describe('ɵɵforeignComponent', () => {
   afterEach(ViewFixture.cleanUp);
@@ -171,4 +174,58 @@ describe('ɵɵforeignComponent', () => {
 
     expect(fixture.host.innerHTML).toContain('<div id="foreign-el">templated-value</div>');
   });
+
+  it('should support reusing the same template between multiple view instances', () => {
+    const foreignComp1 = foreignImport(() => {
+      return [[document.createTextNode('foreign content')]];
+    });
+
+    const createFn = () => {
+      ɵɵelementStart(0, 'div');
+      ɵɵforeignComponent(1, foreignComp1);
+      ɵɵelementEnd();
+    };
+    const expectedHtml =
+      '' +
+      '<div>' +
+      '<!--foreign-view-head-->foreign content<!--foreign-view-tail-->' +
+      '<!--foreign-component-->' +
+      '</div>';
+
+    const fixture = new ViewFixture({
+      decls: 2,
+      vars: 0,
+      create: createFn,
+    });
+    expect(fixture.host.innerHTML).toContain(expectedHtml);
+
+    // Create second instance reusing the TView
+    const host2 = renderSecondInstance(fixture);
+    expect(fixture.host.innerHTML).toContain(expectedHtml);
+    expect(host2.innerHTML).toContain(expectedHtml);
+  });
 });
+
+function renderSecondInstance(fixture: ViewFixture): HTMLElement {
+  const hostLView = fixture.lView[PARENT] as LView;
+  const hostTNode = fixture.lView[T_HOST];
+  const hostRenderer = hostLView[RENDERER];
+  const host = hostRenderer.createElement('host-element') as HTMLElement;
+
+  const lView = createLView(
+    hostLView,
+    fixture.tView,
+    {},
+    LViewFlags.CheckAlways,
+    host,
+    hostTNode,
+    null,
+    null,
+    null,
+    null,
+    null,
+  );
+
+  renderView(fixture.tView, lView, {});
+  return host;
+}