Fix parser logic for `__ctrlFlow.enable` and `Dialog.enable` annotations

[AntoineGautier]

The elements annotated with __ctrlFlow(enable=false) (deadEnd property) or enable=false with literal boolean assignments are not parsed in server/src/parser/parser.ts.

let childInputs =
  this.enable === false || this.deadEnd
    ? []
    : typeInputs[this.type]?.inputs || [];

This must be changed because these elements (such as cfg in Buildings.Templates.AirHandlersFans.Interfaces.PartialAirHandler) may contain parameters used in bindings for, e.g, enable annotations.

The dead end logic should be moved to the client interpreter.
If any parent in the instance tree is disabled, the declaration must not be displayed.

⚠️ This change is expected to significantly increase the runtime of npm run parseTemplateJSON (e.g., medium elements are currently not parsed due to this annotation). The impact must be evaluated when addressing the issue.

[EDIT]

1. "Elements annotated __ctrlFlow(enable=false) are not parsed" is imprecise: the type of a dead-ended component is still loaded and recursively walked. Likewise LongClass.getInputs() calls getInputs on every element including dead-ended ones. So all entries land in the options; what gets pruned is only the reference lists, which means that these entries are all included but not reachable (any reference to it will fail to resolve).
2. Medium classes are currently not parsed for another reason. First, the __ctrlFlow(enable=false) annotation logic is not implemented for short classes. So the aliased medium package should be parsed. The reason it's not is a gap in modelica-json that doesn't create JSON files for the classes aliased by short classes.

[AntoineGautier]

Summary of implemented behavior as of 030f8a1

__ctrlFlow(enable=false) → sets deadEnd = true

Implemented for LongClass, Component, and Extend (the internal representation of an extends clause) via getLinkageKeywordValue() (parser.ts:474-489), wired in at parser.ts:652 (LongClass), 879 (Component), 1050 (Enumeration).

⚠️ Not implemented for ShortClass or Enumeration (package X = Y short-class definitions) — a no-op there. That's a bug.

Two distinct placements, two distinct effects:

• On a component/class declaration itself (e.g. parameter Foo cfg annotation(__ctrlFlow(enable=false));): cfg.deadEnd = true. This:

  • forces cfg's own childInputs = [] — the compositional elements declared inside cfg's type are blanked out of cfg's emitted entry (parser.ts:897-899, 927);
  • removes cfg from its containing class's list of compositional elements via .filter(el => !el.deadEnd) in LongClass.getInputs() (parser.ts:698) — cfg itself becomes unreachable from its parent, whether cfg was declared directly in that parent or arrived there via extends;
  • skips cfg entirely (continue) when schedule.ts:293 walks compositional elements to build parameter-table columns.

• On an extends clause (e.g. extends Foo annotation(__ctrlFlow(enable=false));): the Extend relationship itself gets deadEnd = true. LongClass.getChildElements(useDeadEnd=true) then drops the entire set of compositional elements that would otherwise be pulled in from Foo via inheritance (parser.ts:673-676) — this is the one case that actually suppresses inheritance as a mechanism, rather than pruning one already-flattened element.

Dialog(enable=false) → sets instance.enable = false

A separate field, set in setUIInfo() (parser.ts:770-775) for both Component and ShortClass. Does not set deadEnd.

• Component.getInputs() checks this.enable === false || this.deadEnd together (parser.ts:897), so it also blanks that component's own childInputs — its compositional elements disappear from its entry.

  ⚠️ This is problematic regarding the recommended implementation in https://lbl-srg.github.io/modelica-buildings-templates/guide/#subrecord-with-configuration-parameters:

  Within the parameter record, all configuration parameters are (only) accessible via an instance of the configuration record cfg. This instance uses the annotation annotation (Dialog(enable=false)) as it should not be exposed to the user—and record classes do not allow for protected elements, and this instance cannot be final as it is overridden.

• No effect on the containing class's list of compositional elements (no .filter checks enable), no effect on inheritance flattening.

protected elements → sets isProtected = true

Set in LongClass's constructor via processSection (parser.ts:627-629). Read in exactly one place, setInputVisible() (parser.ts:791-796), contributing to visible: false on the emitted entry. Never touches deadEnd, never blanks childInputs, never affects the containing class's compositional-element list or inheritance flattening, never affects schedule.ts.

Comparison

Annotation / flag	Field set	Blanks own compositional elements	Pruned from containing class's element list	Suppresses inheritance from extends	Skipped in schedule.ts	Applies to ShortClass?
__ctrlFlow(enable=false) on element	deadEnd	yes	yes	—	yes	no (ignored)
__ctrlFlow(enable=false) on extends	Extend.deadEnd	n/a	n/a	yes	n/a	n/a
Dialog(enable=false)	enable	yes	no	no	no	yes
protected	isProtected	no (only visible: false)	no	no	no	yes

---

Proposed Refactoring

__ctrlFlow(enable=false):

• Don't just clear childInputs, rather don't parse the class that is instantiated with this annotation: neither its ancestors, nor any of its elements. childInputs will be empty as a consequence and parsing time will be effectively reduced (not the case with the current implementation which prunes reachability but still does the expensive part of recursively constructing/walking the type it points to).
• Implement the logic in the ShortClass constructor.

Dialog(enable=false):

• Fully parse the class that is instantiated with this annotation: ancestors and elements should be included in templates.json and childInputs populated.
• Make it a pure UI feature: as it is when the annotation uses variables and not a literal.

protected: keep as is