GithubStar/UA-.NETStandard
1
0
Fork 0
mirror of https://github.com/OPCFoundation/UA-.NETStandard.git synced 2026-10-29 15:11:53 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
aas
UA-.NETStandard/tools/Opc.Ua.SourceGeneration.Core/Templating/Tokens.cs
T
romanettClaude Opus 5copilot-swe-agent[bot]marcschier
 e61ad4b306 Fully support sub-state machines in the fluent state-machine builder (#4322) 
# Description

Part 16 §B.3 places `HasSubStateMachine` on the parent **state** node,
but the fluent builder attached it to the state-machine **root** because
`FluentFiniteStateMachineState` never materialized state nodes at all.
Investigating #3821 showed the gap was wider than the reference
placement:

1. **No state nodes existed.** The NodeId written into `CurrentState/Id`
— `new NodeId(stateId, ElementNamespaceIndex)` — was **dangling**: no
node with that id was in the address space.
2. **`AvailableStates` was never populated**, so
`GetAvailableStatesAsync` returned empty against a fluent-built server.
3. **The whole client discovery chain was therefore dead.**
`ObserveEffectiveStateAsync` enumerates `AvailableStates` and browses
`HasSubStateMachine` from each state node — it found nothing. The client
side was already spec-correct; only the server deviated.
4. **`HasSubStateMachine` is non-hierarchical** (a subtype of
`NonHierarchicalReferences`, `i=32`). Using it as the sub-SM's
`BaseInstanceState.ReferenceTypeId` left the sub-SM unreachable from a
hierarchical browse of the machine.

## What changed

**Element nodes are materialized.** Definition-mode machines now create
one `StateType` node per declared state and one `TransitionType` node
per declared transition — each a `HasComponent` child carrying
`StateNumber` / `TransitionNumber`, with the §B.4 `FromState` /
`ToState` / `HasEffect` references and `HasCause` added by `WithCause`.
`AvailableStates`, `AvailableTransitions` and `LastTransition` are
populated, so `CurrentState/Id` and `LastTransition/Id` resolve to real,
browsable nodes. NodeIds are per-instance, so several machines built
from one definition coexist.

**`HasSubStateMachine` moved to the state node**, with the inverse
`SubStateMachineOf`, and the sub-SM is attached as a `HasComponent`
child (fixing 4).

**Core gains element-id mapping hooks.** `GetCurrentStateId` /
`UpdateStateVariable` / `UpdateTransitionVariable` hard-coded the
numeric form and were non-virtual, so a subclass could not redirect
them. They now route through `public virtual` `GetStateNodeId` /
`GetStateId` / `GetTransitionNodeId` / `GetTransitionId`, whose defaults
reproduce the previous `(elementId, ElementNamespaceIndex)` convention
**exactly** — every stack-shipped and generator-emitted machine is
unaffected, and there is a regression test asserting that.

**Generated machines report their model namespace.** The generator now
emits an `ElementNamespaceUri` override on `FiniteStateMachineType`
subtypes, taken from the nearest type that actually *declares* state
children — a subtype that only adds behaviour inherits its elements, and
their namespace, from its base.

**Ordering and validation fixes.** `WithSubStateMachine` and
`WithInitialState` are now order-independent (previously, attaching a
sub-SM before setting the initial state left the child suspended until
the parent left and re-entered the state — silently).
`WithSubStateMachine` validates `parentStateId`, and the builder rejects
duplicate element browse names, since element NodeIds are now derived
from them.

## A defect this surfaced

Code that assembles nodes with the generated `CreateInstanceOf<Type>`
factories never calls `NodeState.CreateAsPredefinedNode`, so
`OnBeforeCreate` / `OnAfterCreate` are skipped for the entire subtree —
and `OnAfterCreate` is the only place a state machine resolves its
element namespace. It is also where `ConditionState` binds its `Enable`
/ `Disable` / `AddComment` handlers and `AlarmConditionState` binds the
shelving methods, so the impact is broader than state machines.

This PR fixes only the two call sites it depends on — DI's
`SoftwareUpdateFacetWiring` and Robotics' `RoboticsOperationBuilder`.
**The repository-wide audit is deliberately left out of scope and
tracked in #4320** (24 files call these factories; none completed the
lifecycle).

The Robotics regression had no test coverage at all, so an assertion on
`CurrentState/Id` was added and verified to fail without the fix.

## Breaking changes

- Sub-state machines are **no longer browsable from the state-machine
root**. Callers passing a machine's `ObjectId` to
`GetSubStateMachineAsync` must pass a state NodeId instead — from
`GetAvailableStatesAsync` or a snapshot's `CurrentStateId`.
- `CurrentState/Id` for fluent machines changes from the numeric form to
the materialized node's id. Code reading a numeric id out of it should
call `FiniteStateMachineState.GetStateId` rather than parsing the
identifier.
- Generated machines qualify `CurrentState/Id` / `LastTransition/Id`
with their companion-spec namespace instead of the OPC UA one.

Documented in `docs/WhatsNewIn2.0.md` and `docs/StateMachines.md`.

## Notes for reviewers

- Adding `virtual` to the `FiniteStateMachineState` members is a binary
(not source) breaking change — assumed acceptable on the 2.0 line, but
worth confirming against the compatibility policy.
- Address-space cost is one node plus one property per declared state
and transition, per machine instance; called out in the docs for servers
instantiating many machines.
- `AvailableTransitions` is modelled as a `HasComponent`
`BaseDataVariable` (matching the standard NodeSet and what the client's
browse path expects), not a Property.

## Related Issues

- Fixes #3821
- Surfaced #4320 (node create lifecycle audit — not addressed here)

## Checklist

- [ ] I have signed the
[CLA](https://opcfoundation.org/license/cla/ContributorLicenseAgreementv1.0.pdf)
and read the
[CONTRIBUTING](https://github.com/OPCFoundation/UA-.NETStandard/blob/master/CONTRIBUTING.md)
doc.
- [x] I have added tests that prove my fix is effective or that my
feature works and increased code coverage.
- [x] I have added all necessary documentation.
- [x] I have verified that my changes do not introduce (new) build or
analyzer warnings.
- [ ] I ran **all** tests locally using the **UA.slnx** solution against
at least .net **framework** and .net **10**, and all passed.
- [ ] I fixed **all** failing and flaky tests in the CI pipelines and
**all** CodeQL warnings.
- [ ] I have addressed **all** PR feedback received.

### Test runs (net10.0)

| Suite | Result |
|---|---|
| `Opc.Ua.Server.Tests` (full) | 4734 passed, 5 skipped |
| `Opc.Ua.SourceGeneration.Core.Tests` | 3780 passed |
| `Opc.Ua.SourceGeneration.Tests` | 132 passed |
| `Opc.Ua.SourceGeneration.Stack.Tests` | 94 passed |
| `Opc.Ua.Types.Tests` | 8763 passed |
| `Opc.Ua.Robotics.Tests` | 540 passed |
| `Opc.Ua.Robotics.Intent.Tests` | 22 passed |
| `Opc.Ua.Di.Tests` | 424 passed |
| `Opc.Ua.ISA95.Tests` | 136 passed |
| `Opc.Ua.Aas.Tests` | 670 passed |
| `Opc.Ua.Positioning.Tests` | 69 passed |
| `Opc.Ua.Client.Tests` (StateMachines) | 36 passed |

Only net10.0 was run locally; the .NET Framework leg is left to CI,
hence the unchecked box above.

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: marcschier <11168470+marcschier@users.noreply.github.com>
2026-08-29 13:33:16 +00:00

256 lines
17 KiB
C#
Raw Permalink Blame History

/* ========================================================================
* Copyright (c) 2005-2025 The OPC Foundation, Inc. All rights reserved.
*
* OPC Foundation MIT License 1.00
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* The complete license agreement can be found here:
* http://opcfoundation.org/License/MIT/1.00/
* ======================================================================*/
namespace Opc.Ua.SourceGeneration
{
internal static class Tokens
{
public static string AdditionalNamespaceUris => nameof(AdditionalNamespaceUris);
public static string ArrayDimensions => nameof(ArrayDimensions);
public static string BaseClassName => nameof(BaseClassName);
public static string BaseInterfaces => nameof(BaseInterfaces);
public static string BaseType => nameof(BaseType);
public static string BaseTypeNamespacePrefix => nameof(BaseTypeNamespacePrefix);
public static string BaseTypeNamespaceUri => nameof(BaseTypeNamespaceUri);
public static string BinaryEncodingId => nameof(BinaryEncodingId);
public static string BrowseName => nameof(BrowseName);
public static string BrowseNameLiteral => nameof(BrowseNameLiteral);
public static string BrowseNameNamespacePrefix => nameof(BrowseNameNamespacePrefix);
public static string BrowseNameNamespaceUri => nameof(BrowseNameNamespaceUri);
public static string BrowseNameSymbol => nameof(BrowseNameSymbol);
public static string SymbolicNameSymbol => nameof(SymbolicNameSymbol);
public static string BuiltInTypes => nameof(BuiltInTypes);
public static string ChildDataType => nameof(ChildDataType);
public static string ValueWrite => nameof(ValueWrite);
public static string ValueComparison => nameof(ValueComparison);
public static string ChildName => nameof(ChildName);
public static string ChildBrowseName => nameof(ChildBrowseName);
public static string ChildBrowseNameLiteral => nameof(ChildBrowseNameLiteral);
public static string ChildPath => nameof(ChildPath);
public static string ClassName => nameof(ClassName);
public static string ClassFactory => nameof(ClassFactory);
public static string ClientApi => nameof(ClientApi);
public static string ClientMethod => nameof(ClientMethod);
public static string CodeName => nameof(CodeName);
public static string CollectionType => nameof(CollectionType);
public static string DataType => nameof(DataType);
public static string StructureType => nameof(StructureType);
public static string FirstExplicitFieldIndex => nameof(FirstExplicitFieldIndex);
public static string DataTypeNamespacePrefix => nameof(DataTypeNamespacePrefix);
public static string DataTypeNamespaceUri => nameof(DataTypeNamespaceUri);
public static string DefaultValue => nameof(DefaultValue);
public static string Description => nameof(Description);
public static string DictionaryUri => nameof(DictionaryUri);
public static string Documentation => nameof(Documentation);
public static string EmitDefaultValue => nameof(EmitDefaultValue);
public static string EncodingMaskModifier => nameof(EncodingMaskModifier);
public static string EncodingMaskFieldNamesModifier =>
nameof(EncodingMaskFieldNamesModifier);
public static string EncodingMaskEncode => nameof(EncodingMaskEncode);
public static string EncodingMaskDecode => nameof(EncodingMaskDecode);
public static string EnumerationName => nameof(EnumerationName);
public static string ElementNamespaceOverride => nameof(ElementNamespaceOverride);
public static string EventNotifier => nameof(EventNotifier);
public static string FieldIndex => nameof(FieldIndex);
public static string ExtraInterfaces => nameof(ExtraInterfaces);
public static string FieldName => nameof(FieldName);
public static string ListOfChildOperations => nameof(ListOfChildOperations);
public static string Historizing => nameof(Historizing);
public static string Identifier => nameof(Identifier);
public static string IdType => nameof(IdType);
public static string Imports => nameof(Imports);
public static string InitializeOptionalChildren => nameof(InitializeOptionalChildren);
public static string InvokeServiceAsync => nameof(InvokeServiceAsync);
public static string Purpose => nameof(Purpose);
public static string IsAbstract => nameof(IsAbstract);
public static string IsOptionSet => nameof(IsOptionSet);
public static string IsRequired => nameof(IsRequired);
public static string LengthInBits => nameof(LengthInBits);
public static string ListOfBrowseNames => nameof(ListOfBrowseNames);
public static string ListOfChildInitializers => nameof(ListOfChildInitializers);
public static string ListOfChildMethods => nameof(ListOfChildMethods);
public static string ListOfClonedFields => nameof(ListOfClonedFields);
public static string ListOfAppendStringFields => nameof(ListOfAppendStringFields);
public static string ListOfComparedFields => nameof(ListOfComparedFields);
public static string ListOfDecodedFields => nameof(ListOfDecodedFields);
public static string ListOfEncodedFields => nameof(ListOfEncodedFields);
public static string ListOfEncodingMaskFields => nameof(ListOfEncodingMaskFields);
public static string ListOfFieldInitializers => nameof(ListOfFieldInitializers);
public static string ListOfFields => nameof(ListOfFields);
public static string ListOfSwitchFieldNames => nameof(ListOfSwitchFieldNames);
public static string ListOfEncodingMaskFieldNames => nameof(ListOfEncodingMaskFieldNames);
public static string ListOfFindChildCase => nameof(ListOfFindChildCase);
public static string ListOfFindChildren => nameof(ListOfFindChildren);
public static string ListOfIdentifiers => nameof(ListOfIdentifiers);
public static string ListOfIdentifersToNames => nameof(ListOfIdentifersToNames);
public static string ListOfNamesToIdentifiers => nameof(ListOfNamesToIdentifiers);
public static string ListOfImports => nameof(ListOfImports);
public static string ListOfInputArguments => nameof(ListOfInputArguments);
public static string ListOfNamespaceUris => nameof(ListOfNamespaceUris);
public static string ListOfNodeIds => nameof(ListOfNodeIds);
public static string ListOfOutputArguments => nameof(ListOfOutputArguments);
public static string ListOfOutputArgumentsFromResult => nameof(ListOfOutputArgumentsFromResult);
public static string ListOfOutputDeclarations => nameof(ListOfOutputDeclarations);
public static string ListOfProperties => nameof(ListOfProperties);
public static string ListOfNonMandatoryChildren => nameof(ListOfNonMandatoryChildren);
public static string ListOfRemoveChild => nameof(ListOfRemoveChild);
public static string ListOfChildCopies => nameof(ListOfChildCopies);
public static string ListOfChildHashes => nameof(ListOfChildHashes);
public static string ListOfEqualityComparers => nameof(ListOfEqualityComparers);
public static string ListOfCreateOrReplaceChild => nameof(ListOfCreateOrReplaceChild);
public static string ListOfResultProperties => nameof(ListOfResultProperties);
public static string ListOfSwitchFields => nameof(ListOfSwitchFields);
public static string ListOfTypes => nameof(ListOfTypes);
public static string ListOfTypeActivators => nameof(ListOfTypeActivators);
public static string ListOfDataTypeDefinitions => nameof(ListOfDataTypeDefinitions);
public static string DataTypeDefinitionsClass => nameof(DataTypeDefinitionsClass);
public static string ListOfUpdateChildrenChangeMasks => nameof(ListOfUpdateChildrenChangeMasks);
public static string ListOfValues => nameof(ListOfValues);
public static string ListOfActivatorRegistrations => nameof(ListOfActivatorRegistrations);
public static string ListOfChildren => nameof(ListOfChildren);
public static string MethodList => nameof(MethodList);
public static string Name => nameof(Name);
public static string IsOptional => nameof(IsOptional);
public static string Namespace => nameof(Namespace);
public static string NamespacePrefix => nameof(NamespacePrefix);
public static string NamespaceUri => nameof(NamespaceUri);
public static string NodeManagerClassName => nameof(NodeManagerClassName);
public static string NodeManagerFactoryClassName => nameof(NodeManagerFactoryClassName);
public static string Nillable => nameof(Nillable);
public static string NodeClass => nameof(NodeClass);
public static string OnCallAsyncDeclaration => nameof(OnCallAsyncDeclaration);
public static string OnCallAsyncImplementation => nameof(OnCallAsyncImplementation);
public static string OnCallDeclaration => nameof(OnCallDeclaration);
public static string OnCallImplementation => nameof(OnCallImplementation);
public static string Prefix => nameof(Prefix);
public static string PropertyName => nameof(PropertyName);
public static string OwnerClassName => nameof(OwnerClassName);
public static string RequestParameters => nameof(RequestParameters);
public static string ResponseParameters => nameof(ResponseParameters);
public static string ServerApi => nameof(ServerApi);
public static string ServerStubs => nameof(ServerStubs);
public static string ServiceSet => nameof(ServiceSet);
public static string ServiceSets => nameof(ServiceSets);
public static string SymbolicId => nameof(SymbolicId);
public static string SymbolicName => nameof(SymbolicName);
public static string TypedVariableType => nameof(TypedVariableType);
public static string TypeName => nameof(TypeName);
public static string ValueRank => nameof(ValueRank);
public static string VariableTypeValue => nameof(VariableTypeValue);
public static string Version => nameof(Version);
public static string Tool => nameof(Tool);
public static string XmlEncodingId => nameof(XmlEncodingId);
public static string VariantFrom => nameof(VariantFrom);
public static string VariantTryGet => nameof(VariantTryGet);
public static string XmlIdentifier => nameof(XmlIdentifier);
public static string XmlNamespaceUri => nameof(XmlNamespaceUri);
public static string XmlnsS0ListOfNamespaces => nameof(XmlnsS0ListOfNamespaces);
public static string TypeList => nameof(TypeList);
public static string BasicType => nameof(BasicType);
public static string Flags => nameof(Flags);
public static string AddKnownType => nameof(AddKnownType);
public static string ModelUri => nameof(ModelUri);
public static string TargetPublicationDate => nameof(TargetPublicationDate);
public static string TargetVersion => nameof(TargetVersion);
public static string BaseT => nameof(BaseT);
public static string XsRestrictionBaseType => nameof(XsRestrictionBaseType);
public static string AccessorSymbol => nameof(AccessorSymbol);
public static string ServerMethodAsync => nameof(ServerMethodAsync);
public static string ClientMethodAsync => nameof(ClientMethodAsync);
public static string ClientMethodSync => nameof(ClientMethodSync);
public static string ClientMethodBegin => nameof(ClientMethodBegin);
public static string ClientMethodEnd => nameof(ClientMethodEnd);
public static string CodeHeader => nameof(CodeHeader);
public static string XmlHeader => nameof(XmlHeader);
public static string ResourceName => nameof(ResourceName);
public static string Resource => nameof(Resource);
public static string ListOfResourceGroups => nameof(ListOfResourceGroups);
public static string ListOfResourceDeclarations => nameof(ListOfResourceDeclarations);
public static string ListOfModelDependencies => nameof(ListOfModelDependencies);
public static string ModelVersion => nameof(ModelVersion);
public static string ModelPublicationDate => nameof(ModelPublicationDate);
public static string ModelName => nameof(ModelName);
public static string ModelPayload => nameof(ModelPayload);
public static string AccessModifier => nameof(AccessModifier);
public static string IdentifierReflection => nameof(IdentifierReflection);
public static string ListOfNodeStateInitializers => nameof(ListOfNodeStateInitializers);
public static string ListOfNodeStateTypeFactories => nameof(ListOfNodeStateTypeFactories);
public static string ListOfNodeStateInstanceFactories => nameof(ListOfNodeStateInstanceFactories);
public static string ListOfChildNodeStates => nameof(ListOfChildNodeStates);
public static string ListOfOptionalChildNodeStates => nameof(ListOfOptionalChildNodeStates);
public static string ListOfReferences => nameof(ListOfReferences);
public static string NodeIdConstant => nameof(NodeIdConstant);
public static string EventFilterParameters => nameof(EventFilterParameters);
public static string EventFilterParameterDocumentation =>
nameof(EventFilterParameterDocumentation);
public static string EventTypeId => nameof(EventTypeId);
public static string InstanceNodeIdOverride => nameof(InstanceNodeIdOverride);
public static string ListOfInstanceNodeIdBranches => nameof(ListOfInstanceNodeIdBranches);
public static string ParentNodeIdConstant => nameof(ParentNodeIdConstant);
public static string IfOrElseIf => nameof(IfOrElseIf);
public static string SuperTypeId => nameof(SuperTypeId);
public static string TypeDefinitionId => nameof(TypeDefinitionId);
public static string ReferenceTypeId => nameof(ReferenceTypeId);
public static string ModellingRuleId => nameof(ModellingRuleId);
public static string StateClassName => nameof(StateClassName);
public static string StateClassFactory => nameof(StateClassFactory);
public static string DisplayName => nameof(DisplayName);
public static string DataTypeDefinition => nameof(DataTypeDefinition);
public static string DescriptionValue => nameof(DescriptionValue);
public static string ValueCode => nameof(ValueCode);
public static string DataTypeIdConstant => nameof(DataTypeIdConstant);
public static string InverseNameValue => nameof(InverseNameValue);
public static string SymmetricValue => nameof(SymmetricValue);
public static string ReleaseStatusValue => nameof(ReleaseStatusValue);
public static string CategoriesValue => nameof(CategoriesValue);
public static string SpecificationValue => nameof(SpecificationValue);
public static string WriteMaskValue => nameof(WriteMaskValue);
public static string UserWriteMaskValue => nameof(UserWriteMaskValue);
public static string NumericIdValue => nameof(NumericIdValue);
public static string AccessRestrictionsValue => nameof(AccessRestrictionsValue);
public static string ListOfRolePermissions => nameof(ListOfRolePermissions);
public static string RoleIdConstant => nameof(RoleIdConstant);
public static string PermissionsValue => nameof(PermissionsValue);
public static string ContainsNoLoopsValue => nameof(ContainsNoLoopsValue);
public static string ExecutableValue => nameof(ExecutableValue);
public static string MethodDeclarationId => nameof(MethodDeclarationId);
public static string MinimumSamplingIntervalValue => nameof(MinimumSamplingIntervalValue);
public static string HistorizingValue => nameof(HistorizingValue);
public static string AccessLevelValue => nameof(AccessLevelValue);
public static string UserAccessLevelValue => nameof(UserAccessLevelValue);
public static string ListOfInitOnlyBackingFields => nameof(ListOfInitOnlyBackingFields);
public static string ListOfPooledExtensions => nameof(ListOfPooledExtensions);
public static string ListOfFieldResets => nameof(ListOfFieldResets);
}
}
Reference in New Issue View Git Blame Copy Permalink