DYN-10693: Keep the FunctionNotFound warning across Code Block Node edits

[RobertGlobant20]

Purpose

Follow-up fix for DYN-10693, reported by Neal Burnham during testing of #17224 on 4.3.0.5770:

In preliminary testing with 4.3.0.5770 the fix is validated for a "first time in" case, however if the cbn is edited and re-executed the warning state vanishes: INCORRECT. The nature of the edit is un-important: any edit will cause the flaw.

#17224 only covered the graph-open path. Opening a graph runs the two-pass compile (ReCompileCodeBlockNodesForFunctionDefinitions), and the deferred re-check in RecompileCodeBlockAST emits the warning correctly. Editing a Code Block Node recompiles it in a single pass, where the warning was lost for a different — and older — reason that #17224 made visible.

Root cause

A Code Block Node's previously compiled def is still active in the shared precompilation core when the node is recompiled after an edit:

1. ProcedureTable.Append finds an active duplicate and returns kInvalidIndex.
2. Code generation logs FunctionAlreadyDefined and sets funcDef.skipMe = true (ProtoAssociative/CodeGen.cs:3785).
3. FunctionAlreadyDefined is deliberately filtered out of Code Block Node warnings (CodeBlockNode.cs:870), so nothing is surfaced.
4. DfsTraverse returns early on skipMe (ProtoAssociative/CodeGen.cs:6050), so the function body is never traversed — the unresolved call inside it is never visited and no FunctionNotFound is raised.
5. ProcessCodeDirect has already called ClearErrorsAndWarnings(), so the warning shown at graph open simply disappears.

This is not specific to FunctionNotFound: any diagnostic inside a redefined function body was being dropped on recompile.

Fix

Deactivate the node's own definitions in ProcessCode before recompiling, so ProcedureTable.Append takes its !existingProcNode.IsActive branch and replaces the stale entry in place. The body is compiled again and its warnings are reported. This mirrors what LiveRunner.UndefineFunctions already does for redefined subtrees.

Also guards UndefineFunctionDefinitions against a null ParseParam, which is the state on a node's first compile.

Behavior change worth a look during review: a Code Block Node that renames or deletes a def now leaves the old name genuinely undefined, instead of leaving a permanently-registered definition behind. That is more correct, but it does change what other Code Block Nodes resolve when they next recompile.

Declarations

Check these if you believe they are true

• Is documented according to the standards
• The level of testing this PR includes is appropriate
• Changes to the API follow Semantic Versioning and are documented in the API Changes document.

No public API surface changes — UndefineFunctionDefinitions is internal and already existed.

Release Notes

Fixed an issue where the "Method not found" warning on a Code Block Node disappeared after the node was edited and the graph re-executed, leaving broken code silently returning null.

Reviewers

@jasonstratton (reviewed and merged #17224)

@edwin-vasquez-ucaldas

Notes for testers — the repro is the same as DYN-10693, with an extra step:

1. Open a graph containing a Code Block Node with an unresolved call inside a def body, e.g. def tostr(x) { return = ToString(x); }; tostr(3.1415);
2. Confirm the "Method 'ToString()' not found" warning appears.
3. Make any edit to the Code Block Node (changing the argument value is enough) and re-run.
4. The warning must still be shown. Before this fix it disappeared.

Also worth confirming that valid forward references still do not warn after an edit, both within one Code Block Node and across two.

Testing performed

• New regression tests in CodeBlockNodeTests: FunctionCall_KeepsWarning_WhenCodeBlockIsEditedAfterUnresolvedCallInBody and FunctionCall_NoWarning_WhenForwardReferenceInSameCodeBlockIsEdited.
• All 11 FunctionCall_* / ImperativeFunctionCall_* tests pass, plus the full CodeBlockNodeTests fixture (79 tests) and CodeBlockNodeTests2 / DynamoDefects / CallsiteTests / CoreTests (109 tests).
• A wider Name~Function|Cbn|CodeBlock sweep surfaced 4 failures (UsingFunctionObject01, UsingFunctionObject02, TestMigration_Core_Functions, ImperativeArrayIndexingInCodeBlockToCode). These were verified to fail identically on clean master with this change stashed, so they are pre-existing and unrelated.

FYIs

Neal Burnham (reported the regression in testing)

🤖 Generated with Claude Code

[github-actions]

See the ticket for this pull request: https://jira.autodesk.com/browse/DYN-10693

[RobertGlobant20]

GIF showing the expected behavior

[Copilot]

Pull request overview

This PR fixes a long-standing Code Block Node (CBN) recompilation issue where diagnostics inside redefined function bodies (notably FunctionNotFound) could disappear after editing the CBN, due to the node’s prior function definitions remaining active in the shared precompilation core.

Changes:

• Deactivate a CBN’s previously registered function definitions before recompiling its edited code, so function bodies are traversed again and their diagnostics are preserved.
• Add a null-guard in UndefineFunctionDefinitions for first-compile scenarios where ParseParam/ParsedNodes may not be available.
• Add regression tests ensuring warnings persist across edits and valid forward references do not start warning after edits.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
test/DynamoCoreTests/CodeBlockNodeTests.cs	Adds regression coverage for warning persistence across CBN edits and for forward-reference non-warning behavior after edits.
src/DynamoCore/Graph/Nodes/CodeBlockNode.cs	Ensures prior CBN function definitions are deactivated before recompilation to avoid “skipMe” codegen paths dropping diagnostics; adds null guard for ParseParam.

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud