sysmlpy 0.41.0__tar.gz → 0.42.0__tar.gz

{sysmlpy-0.41.0 → sysmlpy-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.41.0
+Version: 0.42.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)
@@ -39,6 +39,8 @@ The project had diverged so much from sysml2py that a new name, sysmlpy, was sel
 
 ![Lines of Code Over Time](loc_history.svg)
 
+**v0.42.0:** Two deep fixes in the specialization layer. (1) `satisfy R : T by p;` and `assert someConstraint : CType;` crashed with `NameError` — the makers called a helper that was never defined; all three sites now use `_build_full_specialization_from_fsp`. (2) Chained re-declarations (`attribute :> base.x;`) dropped every segment after the first, at both visitor and grammar layers — new visitor helpers emit one Owned* dict per source chain (head + `OwnedFeatureChain`), grammar classes keep both parts, `redefined_name` resolves to the leaf segment, and the semantic analyzer now reports/resolves full dotted names (`Undefined symbol 'missing.chain'`). 14 tests in `tests/redefined_name_test.py`.
+
 **v0.41.0:** Full-specialization capture across all usage kinds — v0.40.0 fixed `attributeUsage` only; actions, calculations, constraints, requirements, use cases, interfaces and nested occurrences still dropped `:>`, `:>>`, `::>` specializations. New `_full_specialization_for_ctx` helper walks any usage-like context to its featureSpecializationPart; twelve visitor sites now use it (typed-by kept as fallback). `Action.load_from_grammar` captures all four kinds and the hand-rolled dumps on Action/Interface/UseCase/Requirement render them (`action a2 ::> RefType;`). `Usage.redefined_name` now works on deeper declaration nestings too. 10 tests in `tests/redefined_name_test.py`.
 
 **v0.40.0:** `References` (`::>` / `references` keyword) implemented end-to-end — previously the grammar-side `FeatureSpecialization` had a silent "not yet implemented" stub and the visitor never emitted dicts for it, so `ref attribute ::> X;` lost its specialization on round-trip (dump emitted `attribute ;`). New `References` grammar class mirrors `Redefinitions`; visitor branches in both full-specialization builders now cover the operator and keyword forms. The top-level `attributeUsage` path was the only one still using the typed-by-only helper; it now uses `_build_full_specialization_from_ctx` so all four kinds (Typings, Subsettings, Redefinitions, References) round-trip. `redefined_name` / `display_name` already handled this case. New `test_attribute_ref_references_operator_roundtrip` in `tests/grammar_test.py`; two new cases in `tests/redefined_name_test.py`. 97/97 grammar round-trip tests pass.

{sysmlpy-0.41.0 → sysmlpy-0.42.0}/README.md

@@ -14,6 +14,8 @@ The project had diverged so much from sysml2py that a new name, sysmlpy, was sel
 
 ![Lines of Code Over Time](loc_history.svg)
 
+**v0.42.0:** Two deep fixes in the specialization layer. (1) `satisfy R : T by p;` and `assert someConstraint : CType;` crashed with `NameError` — the makers called a helper that was never defined; all three sites now use `_build_full_specialization_from_fsp`. (2) Chained re-declarations (`attribute :> base.x;`) dropped every segment after the first, at both visitor and grammar layers — new visitor helpers emit one Owned* dict per source chain (head + `OwnedFeatureChain`), grammar classes keep both parts, `redefined_name` resolves to the leaf segment, and the semantic analyzer now reports/resolves full dotted names (`Undefined symbol 'missing.chain'`). 14 tests in `tests/redefined_name_test.py`.
+
 **v0.41.0:** Full-specialization capture across all usage kinds — v0.40.0 fixed `attributeUsage` only; actions, calculations, constraints, requirements, use cases, interfaces and nested occurrences still dropped `:>`, `:>>`, `::>` specializations. New `_full_specialization_for_ctx` helper walks any usage-like context to its featureSpecializationPart; twelve visitor sites now use it (typed-by kept as fallback). `Action.load_from_grammar` captures all four kinds and the hand-rolled dumps on Action/Interface/UseCase/Requirement render them (`action a2 ::> RefType;`). `Usage.redefined_name` now works on deeper declaration nestings too. 10 tests in `tests/redefined_name_test.py`.
 
 **v0.40.0:** `References` (`::>` / `references` keyword) implemented end-to-end — previously the grammar-side `FeatureSpecialization` had a silent "not yet implemented" stub and the visitor never emitted dicts for it, so `ref attribute ::> X;` lost its specialization on round-trip (dump emitted `attribute ;`). New `References` grammar class mirrors `Redefinitions`; visitor branches in both full-specialization builders now cover the operator and keyword forms. The top-level `attributeUsage` path was the only one still using the typed-by-only helper; it now uses `_build_full_specialization_from_ctx` so all four kinds (Typings, Subsettings, Redefinitions, References) round-trip. `redefined_name` / `display_name` already handled this case. New `test_attribute_ref_references_operator_roundtrip` in `tests/grammar_test.py`; two new cases in `tests/redefined_name_test.py`. 97/97 grammar round-trip tests pass.

{sysmlpy-0.41.0 → sysmlpy-0.42.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.41.0"
+version = "0.42.0"
 description = ""
 authors = [{ name = "Jon R. Fox (mycr0ft)", email = "jon.fox@drfox.com" }]
 readme = "README.md"

{sysmlpy-0.41.0 → sysmlpy-0.42.0}/src/sysmlpy/__init__.py

@@ -25,7 +25,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.41.0"
+__version__ = "0.42.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,

{sysmlpy-0.41.0 → sysmlpy-0.42.0}/src/sysmlpy/antlr_visitor.py

@@ -2212,7 +2212,7 @@ def _make_assert_constraint_usage_dict(acu_ctx, prefix=None):
         
         if hasattr(acu_ctx, 'featureSpecializationPart') and acu_ctx.featureSpecializationPart():
             fsp_ctx = acu_ctx.featureSpecializationPart()
-            fsp = _build_feature_specialization_part(fsp_ctx)
+            fsp = _build_full_specialization_from_fsp(fsp_ctx)
     
     declaration = None
     if hasattr(acu_ctx, 'constraintUsageDeclaration') and acu_ctx.constraintUsageDeclaration():
@@ -2315,7 +2315,7 @@ def _make_satisfy_requirement_usage_dict(sru_ctx, prefix=None):
         
         if hasattr(sru_ctx, 'featureSpecializationPart') and sru_ctx.featureSpecializationPart():
             fsp_ctx = sru_ctx.featureSpecializationPart()
-            fsp = _build_feature_specialization_part(fsp_ctx)
+            fsp = _build_full_specialization_from_fsp(fsp_ctx)
     elif hasattr(sru_ctx, 'REQUIREMENT') and sru_ctx.REQUIREMENT():
         if hasattr(sru_ctx, 'usageDeclaration') and sru_ctx.usageDeclaration():
             ud = sru_ctx.usageDeclaration()
@@ -9111,7 +9111,7 @@ def _visit_requirement_constraint_usage(rcu_ctx):
         fs = []
         if hasattr(rcu_ctx, 'featureSpecializationPart') and rcu_ctx.featureSpecializationPart():
             fsp_ctx = rcu_ctx.featureSpecializationPart()
-            fsp = _build_feature_specialization_part(fsp_ctx)
+            fsp = _build_full_specialization_from_fsp(fsp_ctx)
             if fsp and "specialization" in fsp:
                 fs = fsp["specialization"]
         
@@ -11561,6 +11561,68 @@ def _get_action_usage_subsetted_by(ctx):
     return None
 
 
+def _dotted_segments(owned_ctx):
+    """Segments of an ownedSubsetting / ownedRedefinition /
+    ownedReferenceSubsetting context.
+
+    Grammar: qualifiedName (DOT qualifiedName)* — e.g. ``base.x`` yields
+    ``['base', 'x']``. Each segment may itself be '::'-qualified.
+    """
+    segs = []
+    if owned_ctx is None:
+        return segs
+    for c2 in owned_ctx.children:
+        if type(c2).__name__ == 'QualifiedNameContext':
+            segs.append(c2.getText())
+    return segs
+
+
+def _emit_owned_chain(dict_name, feature_key, segs):
+    """Build an Owned{Subsetting,Redefinition,ReferenceSubsetting} dict
+    from dotted segments: first segment becomes the direct feature, the
+    remainder become an OwnedFeatureChain so chained forms like
+    ``:> base.x`` survive round-trip."""
+    head = {
+        "name": "QualifiedName",
+        "names": segs[0].split("::"),
+    }
+    owned_related = []
+    if len(segs) > 1:
+        chain_elements = [
+            {
+                "name": "OwnedFeatureChaining",
+                "chainingFeature": {"name": "QualifiedName", "names": s.split("::")},
+            }
+            for s in segs[1:]
+        ]
+        owned_related.append({
+            "name": "OwnedFeatureChain",
+            "feature": {
+                "name": "FeatureChain",
+                "ownedRelationship": chain_elements,
+            },
+        })
+    return {
+        "name": dict_name,
+        feature_key: head,
+        "ownedRelatedElement": owned_related,
+    }
+
+
+def _collect_owned_contexts(wrapper_children, direct_type, wrapper_types):
+    """Yield each Owned*Context found under a Subsettings/Redefinitions/
+    References rule context. Handles both direct children and one of the
+    keyword-wrapper contexts (SubsetsContext, RedefinesContext, …)."""
+    for child in wrapper_children:
+        child_name = type(child).__name__
+        if child_name == direct_type:
+            yield child
+        elif child_name in wrapper_types:
+            for c3 in child.children:
+                if type(c3).__name__ == direct_type:
+                    yield c3
+
+
 def _full_specialization_for_ctx(ctx):
     """Best-effort full specialization for any usage-like context.
 
@@ -11848,30 +11910,19 @@ def _build_full_specialization_from_ctx(ctx):
             # redef_ctx can be a single RedefinitionsContext or a list
             if not isinstance(redef_ctx, list):
                 redef_ctx = [redef_ctx]
-            redef_names = []
+            owned = []
             for rc in redef_ctx:
-                # RedefinitionsContext → [RedefinesContext, ...] → [OwnedRedefinitionContext, ...] → QualifiedNameContext
-                for child in rc.children:
-                    child_name = type(child).__name__
-                    if child_name == 'OwnedRedefinitionContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'QualifiedNameContext':
-                                redef_names.append(c2.getText())
-                    elif child_name == 'RedefinesContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'OwnedRedefinitionContext':
-                                for c3 in c2.children:
-                                    if type(c3).__name__ == 'QualifiedNameContext':
-                                        redef_names.append(c3.getText())
-            if redef_names:
-                owned = [
-                    {
-                        "name": "OwnedRedefinition",
-                        "redefinedFeature": {"name": "QualifiedName", "names": n.split("::")},
-                        "ownedRelatedElement": []
-                    }
-                    for n in redef_names
-                ]
+                # OwnedRedefinitionContext may be a dotted chain
+                # (qualifiedName (DOT qualifiedName)*).
+                for or_ctx in _collect_owned_contexts(
+                    rc.children, 'OwnedRedefinitionContext',
+                    ('RedefinesContext',),
+                ):
+                    segs = _dotted_segments(or_ctx)
+                    if segs:
+                        owned.append(_emit_owned_chain(
+                            'OwnedRedefinition', 'redefinedFeature', segs))
+            if owned:
                 specialization_list.append({
                     "name": "FeatureSpecialization",
                     "ownedRelationship": {
@@ -11886,36 +11937,19 @@ def _build_full_specialization_from_ctx(ctx):
             # sub_ctx can be a single SubsettingsContext or a list
             if not isinstance(sub_ctx, list):
                 sub_ctx = [sub_ctx]
-            sub_names = []
+            owned = []
             for sc in sub_ctx:
-                # SubsettingsContext → [SubsetsContext, ...] → [OwnedSubsettingContext] → QualifiedNameContext
-                for child in sc.children:
-                    child_name = type(child).__name__
-                    if child_name == 'OwnedSubsettingContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'QualifiedNameContext':
-                                sub_names.append(c2.getText())
-                    elif child_name == 'SubsetsContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'OwnedSubsettingContext':
-                                for c3 in c2.children:
-                                    if type(c3).__name__ == 'QualifiedNameContext':
-                                        sub_names.append(c3.getText())
-                    elif child_name == 'SpecializesContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'OwnedSubsettingContext':
-                                for c3 in c2.children:
-                                    if type(c3).__name__ == 'QualifiedNameContext':
-                                        sub_names.append(c3.getText())
-            if sub_names:
-                owned = [
-                    {
-                        "name": "OwnedSubsetting",
-                        "subsettedFeature": {"name": "QualifiedName", "names": n.split("::")},
-                        "ownedRelatedElement": []
-                    }
-                    for n in sub_names
-                ]
+                # Each Owned*Context may be a dotted chain
+                # (qualifiedName (DOT qualifiedName)*).
+                for os_ctx in _collect_owned_contexts(
+                    sc.children, 'OwnedSubsettingContext',
+                    ('SubsetsContext', 'SpecializesContext'),
+                ):
+                    segs = _dotted_segments(os_ctx)
+                    if segs:
+                        owned.append(_emit_owned_chain(
+                            'OwnedSubsetting', 'subsettedFeature', segs))
+            if owned:
                 specialization_list.append({
                     "name": "FeatureSpecialization",
                     "ownedRelationship": {
@@ -11929,29 +11963,18 @@ def _build_full_specialization_from_ctx(ctx):
             ref_ctx = spec.references()
             if not isinstance(ref_ctx, list):
                 ref_ctx = [ref_ctx]
-            ref_names = []
+            owned = []
             for rc in ref_ctx:
-                for child in rc.children:
-                    child_name = type(child).__name__
-                    if child_name == 'OwnedReferenceSubsettingContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'QualifiedNameContext':
-                                ref_names.append(c2.getText())
-                    elif child_name == 'ReferencesContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'OwnedReferenceSubsettingContext':
-                                for c3 in c2.children:
-                                    if type(c3).__name__ == 'QualifiedNameContext':
-                                        ref_names.append(c3.getText())
-            if ref_names:
-                owned = [
-                    {
-                        "name": "OwnedReferenceSubsetting",
-                        "referencedFeature": {"name": "QualifiedName", "names": n.split("::")},
-                        "ownedRelatedElement": []
-                    }
-                    for n in ref_names
-                ]
+                # OwnedReferenceSubsettingContext may be a dotted chain.
+                for ors_ctx in _collect_owned_contexts(
+                    rc.children, 'OwnedReferenceSubsettingContext',
+                    ('ReferencesContext',),
+                ):
+                    segs = _dotted_segments(ors_ctx)
+                    if segs:
+                        owned.append(_emit_owned_chain(
+                            'OwnedReferenceSubsetting', 'referencedFeature', segs))
+            if owned:
                 specialization_list.append({
                     "name": "FeatureSpecialization",
                     "ownedRelationship": {
@@ -12242,29 +12265,19 @@ def _build_full_specialization_from_fsp(fsp):
             redef_ctx = spec.redefinitions()
             if not isinstance(redef_ctx, list):
                 redef_ctx = [redef_ctx]
-            redef_names = []
+            owned = []
             for rc in redef_ctx:
-                for child in rc.children:
-                    child_name = type(child).__name__
-                    if child_name == 'OwnedRedefinitionContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'QualifiedNameContext':
-                                redef_names.append(c2.getText())
-                    elif child_name == 'RedefinesContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'OwnedRedefinitionContext':
-                                for c3 in c2.children:
-                                    if type(c3).__name__ == 'QualifiedNameContext':
-                                        redef_names.append(c3.getText())
-            if redef_names:
-                owned = [
-                    {
-                        "name": "OwnedRedefinition",
-                        "redefinedFeature": {"name": "QualifiedName", "names": n.split("::")},
-                        "ownedRelatedElement": []
-                    }
-                    for n in redef_names
-                ]
+                # OwnedRedefinitionContext may be a dotted chain
+                # (qualifiedName (DOT qualifiedName)*).
+                for or_ctx in _collect_owned_contexts(
+                    rc.children, 'OwnedRedefinitionContext',
+                    ('RedefinesContext',),
+                ):
+                    segs = _dotted_segments(or_ctx)
+                    if segs:
+                        owned.append(_emit_owned_chain(
+                            'OwnedRedefinition', 'redefinedFeature', segs))
+            if owned:
                 specialization_list.append({
                     "name": "FeatureSpecialization",
                     "ownedRelationship": {
@@ -12278,35 +12291,19 @@ def _build_full_specialization_from_fsp(fsp):
             sub_ctx = spec.subsettings()
             if not isinstance(sub_ctx, list):
                 sub_ctx = [sub_ctx]
-            sub_names = []
+            owned = []
             for sc in sub_ctx:
-                for child in sc.children:
-                    child_name = type(child).__name__
-                    if child_name == 'OwnedSubsettingContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'QualifiedNameContext':
-                                sub_names.append(c2.getText())
-                    elif child_name == 'SubsetsContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'OwnedSubsettingContext':
-                                for c3 in c2.children:
-                                    if type(c3).__name__ == 'QualifiedNameContext':
-                                        sub_names.append(c3.getText())
-                    elif child_name == 'SpecializesContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'OwnedSubsettingContext':
-                                for c3 in c2.children:
-                                    if type(c3).__name__ == 'QualifiedNameContext':
-                                        sub_names.append(c3.getText())
-            if sub_names:
-                owned = [
-                    {
-                        "name": "OwnedSubsetting",
-                        "subsettedFeature": {"name": "QualifiedName", "names": n.split("::")},
-                        "ownedRelatedElement": []
-                    }
-                    for n in sub_names
-                ]
+                # Each Owned*Context may be a dotted chain
+                # (qualifiedName (DOT qualifiedName)*).
+                for os_ctx in _collect_owned_contexts(
+                    sc.children, 'OwnedSubsettingContext',
+                    ('SubsetsContext', 'SpecializesContext'),
+                ):
+                    segs = _dotted_segments(os_ctx)
+                    if segs:
+                        owned.append(_emit_owned_chain(
+                            'OwnedSubsetting', 'subsettedFeature', segs))
+            if owned:
                 specialization_list.append({
                     "name": "FeatureSpecialization",
                     "ownedRelationship": {
@@ -12320,29 +12317,18 @@ def _build_full_specialization_from_fsp(fsp):
             ref_ctx = spec.references()
             if not isinstance(ref_ctx, list):
                 ref_ctx = [ref_ctx]
-            ref_names = []
+            owned = []
             for rc in ref_ctx:
-                for child in rc.children:
-                    child_name = type(child).__name__
-                    if child_name == 'OwnedReferenceSubsettingContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'QualifiedNameContext':
-                                ref_names.append(c2.getText())
-                    elif child_name == 'ReferencesContext':
-                        for c2 in child.children:
-                            if type(c2).__name__ == 'OwnedReferenceSubsettingContext':
-                                for c3 in c2.children:
-                                    if type(c3).__name__ == 'QualifiedNameContext':
-                                        ref_names.append(c3.getText())
-            if ref_names:
-                owned = [
-                    {
-                        "name": "OwnedReferenceSubsetting",
-                        "referencedFeature": {"name": "QualifiedName", "names": n.split("::")},
-                        "ownedRelatedElement": []
-                    }
-                    for n in ref_names
-                ]
+                # OwnedReferenceSubsettingContext may be a dotted chain.
+                for ors_ctx in _collect_owned_contexts(
+                    rc.children, 'OwnedReferenceSubsettingContext',
+                    ('ReferencesContext',),
+                ):
+                    segs = _dotted_segments(ors_ctx)
+                    if segs:
+                        owned.append(_emit_owned_chain(
+                            'OwnedReferenceSubsetting', 'referencedFeature', segs))
+            if owned:
                 specialization_list.append({
                     "name": "FeatureSpecialization",
                     "ownedRelationship": {

{sysmlpy-0.41.0 → sysmlpy-0.42.0}/src/sysmlpy/grammar/classes.py

@@ -8243,33 +8243,40 @@ class References:
 class OwnedRedefinition:
     def __init__(self, definition):
         if valid_definition(definition, "OwnedRedefinition"):
+            # A dotted chain (:>> base.x) carries BOTH the head
+            # qualifiedName and one OwnedFeatureChain per remaining
+            # segment. Keep both so chained forms survive round-trip.
+            self.redefinedFeature = None
             if definition["redefinedFeature"] is not None:
                 self.redefinedFeature = QualifiedName(definition["redefinedFeature"])
-            else:
-                self.redefinedFeature = None
-                self.elements = []
-                for element in definition["ownedRelatedElement"]:
-                    self.elements.append(OwnedFeatureChain(element))
+            self.elements = []
+            for element in definition.get("ownedRelatedElement", []) or []:
+                self.elements.append(OwnedFeatureChain(element))
 
     def dump(self):
+        parts = []
         if self.redefinedFeature is not None:
-            return self.redefinedFeature.dump()
-        else:
-            return ".".join([e.dump() for e in self.elements])
+            parts.append(self.redefinedFeature.dump())
+        parts.extend([e.dump() for e in self.elements])
+        return ".".join(parts) if parts else ""
 
     def get_definition(self):
-        if self.redefinedFeature is not None:
+        if self.redefinedFeature is not None and not self.elements:
             return {
                 "name": self.__class__.__name__,
                 "redefinedFeature": self.redefinedFeature.get_definition(),
                 "ownedRelatedElement": [],
             }
         else:
-            return {
+            output = {
                 "name": self.__class__.__name__,
-                "redefinedFeature": None,
+                "redefinedFeature": self.redefinedFeature.get_definition() if self.redefinedFeature is not None else None,
                 "ownedRelatedElement": [e.get_definition() for e in self.elements],
             }
+            if self.redefinedFeature is None and not self.elements:
+                # Fully empty: keep legacy shape
+                pass
+            return output
 
 
 class Subsettings:
@@ -8298,15 +8305,17 @@ class OwnedSubsetting:
     def __init__(self, definition):
         if valid_definition(definition, "OwnedSubsetting"):
             # subsettedFeature = QualifiedName | ownedRelatedElement += OwnedFeatureChain
+            # A dotted chain (:> base.x) carries BOTH: the head qualifiedName
+            # plus one OwnedFeatureChain per remaining segment. Keep both so
+            # chained forms survive round-trip (v0.42.0).
+            self.elements = []
             if definition["subsettedFeature"] is not None:
-                self.elements = [QualifiedName(definition["subsettedFeature"])]
-            else:
-                self.elements = []
-                for element in definition["ownedRelatedElement"]:
-                    self.elements.append(OwnedFeatureChain(element))
+                self.elements.append(QualifiedName(definition["subsettedFeature"]))
+            for element in definition.get("ownedRelatedElement", []) or []:
+                self.elements.append(OwnedFeatureChain(element))
 
     def dump(self):
-        return " ".join([child.dump() for child in self.elements])
+        return ".".join([child.dump() for child in self.elements])
 
     def get_definition(self):
         output = {

{sysmlpy-0.41.0 → sysmlpy-0.42.0}/src/sysmlpy/semantic.py

@@ -948,20 +948,23 @@ class ReferenceCollector:
         self, sub: Any, element: Any, results: list[tuple[str, Any, list[str]]], scope_path: list[str]
     ) -> None:
         for child in getattr(sub, "children", []):
-            for el in getattr(child, "elements", []):
-                names = getattr(el, "names", [])
-                if names:
-                    results.append(("::".join(names), element, scope_path))
+            segments = _chain_segments(child)
+            if segments:
+                # Namespace qualification joins with '::', feature chains
+                # with '.' (e.g. base.x).
+                # Namespace qualification stays inside a segment ('A::B');
+                # feature-chain segments join with '.'.
+                results.append((".".join(segments), element, scope_path))
 
     def _collect_redefinitions(
         self, red: Any, element: Any, results: list[tuple[str, Any, list[str]]], scope_path: list[str]
     ) -> None:
         for child in getattr(red, "children", []):
-            rf = getattr(child, "redefinedFeature", None)
-            if rf is not None:
-                names = getattr(rf, "names", [])
-                if names:
-                    results.append(("::".join(names), element, scope_path))
+            segments = _chain_segments(child)
+            if segments:
+                # Namespace qualification stays inside a segment ('A::B');
+                # feature-chain segments join with '.'.
+                results.append((".".join(segments), element, scope_path))
 
     def _collect_subclassification(
         self, sc: Any, element: Any, results: list[tuple[str, Any, list[str]]], scope_path: list[str]
@@ -973,6 +976,36 @@ class ReferenceCollector:
                     results.append(("::".join(names), element, scope_path))
 
 
+
+def _chain_segments(child: Any) -> list[str]:
+    """Reference segments of an Owned*Subsetting/Redefinition child, in order.
+
+    Each returned string is one feature-chain segment: a QualifiedName keeps
+    its internal ``::`` namespace qualification (``A::B``), while dotted
+    chain steps become separate segments (``:> base.x`` -> ``['base','x']``).
+    """
+    segments: list[str] = []
+    qn = getattr(child, "redefinedFeature", None) or getattr(
+        child, "referencedFeature", None
+    ) or getattr(child, "subsettedFeature", None)
+    if qn is not None:
+        names = getattr(qn, "names", [])
+        if names:
+            segments.append("::".join(names))
+    for el in getattr(child, "elements", []) or []:
+        if hasattr(el, "names") and getattr(el, "names", []):
+            # Bare QualifiedName element (OwnedSubsetting single form)
+            segments.append("::".join(el.names))
+        elif hasattr(el, "feature"):
+            for seg in getattr(el.feature, "children", []) or []:
+                cf = getattr(seg, "chainingFeature", None)
+                if cf is not None:
+                    names = getattr(cf, "names", [])
+                    if names:
+                        segments.append("::".join(names))
+    return segments
+
+
 # ---------------------------------------------------------------------------
 # Semantic Analyzer
 # ---------------------------------------------------------------------------

{sysmlpy-0.41.0 → sysmlpy-0.42.0}/src/sysmlpy/usage.py

@@ -33,29 +33,6 @@ def _is_uuid(s: str) -> bool:
     )
 
 
-def _qn_last_name(qn):
-    """Return the last identifier segment of a QualifiedName, or None."""
-    if qn is None:
-        return None
-    names = getattr(qn, "names", None)
-    if names:
-        return names[-1]
-    return None
-
-
-def _feature_chain_last_name(chain):
-    """Walk a chain of OwnedFeatureChain segments; return the last identifier
-    segment of the final segment, or None."""
-    if chain is None:
-        return None
-    feature = getattr(chain, "feature", None)
-    children = getattr(feature, "children", None) or []
-    last_seg = None
-    for seg in children:
-        last_seg = _qn_last_name(getattr(seg, "chainingFeature", None))
-    return last_seg
-
-
 def _resolve_name_from_specialization(specialization):
     """Find the most user-visible identifier in a ``FeatureSpecializationPart``.
 
@@ -76,36 +53,31 @@ def _resolve_name_from_specialization(specialization):
         if rel is None:
             continue
         for child in getattr(rel, "children", None) or []:
-            # OwnedRedefinition / OwnedReferenceSubsetting: prefer the
-            # direct referenced feature, fall back to a chained path.
-            qn = _qn_last_name(
+            # OwnedRedefinition / OwnedReferenceSubsetting / OwnedSubsetting:
+            # a dotted chain (:> base.x) keeps the head QualifiedName plus
+            # one OwnedFeatureChain per remaining segment. Collect every
+            # segment in order and resolve to the last one.
+            segments = []
+            qn = (
                 getattr(child, "redefinedFeature", None)
-            ) or _qn_last_name(
-                getattr(child, "referencedFeature", None)
+                or getattr(child, "referencedFeature", None)
             )
-            if qn:
-                return qn
-            # Chained path on either of the above (OwnedFeatureChain[])
-            elements = getattr(child, "elements", None)
-            if elements:
-                head = elements[0]
-                if isinstance(head, _qn_owner()):
-                    name = _qn_last_name(head)
-                else:
-                    name = _feature_chain_last_name(head)
-                if name:
-                    return name
+            if qn is not None and getattr(qn, "names", None):
+                segments.extend(qn.names)
+            for el in getattr(child, "elements", None) or []:
+                if hasattr(el, "names") and el.names:
+                    segments.extend(el.names)
+                elif hasattr(el, "feature"):
+                    for seg in getattr(el.feature, "children", []) or []:
+                        cf = getattr(seg, "chainingFeature", None)
+                        if cf is not None and getattr(cf, "names", None):
+                            segments.extend(cf.names)
+            if segments:
+                return segments[-1]
         # First chain resolved; stop looking further.
         return None
     return None
 
-
-def _qn_owner():
-    """Return the QualifiedName class without importing it at module
-    load time (avoids a cycle with the visitor package)."""
-    from sysmlpy.grammar.classes import QualifiedName
-    return QualifiedName
-
 # Load custom US Customary unit definitions
 _us_customary_path = os.path.join(os.path.dirname(__file__), "us_customary_units.txt")
 if os.path.exists(_us_customary_path):