sysmlpy 0.74.0__tar.gz → 0.76.0__tar.gz

{sysmlpy-0.74.0 → sysmlpy-0.76.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.74.0
+Version: 0.76.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)

{sysmlpy-0.74.0 → sysmlpy-0.76.0}/pyproject.toml

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

{sysmlpy-0.74.0 → sysmlpy-0.76.0}/src/sysmlpy/__init__.py

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

{sysmlpy-0.74.0 → sysmlpy-0.76.0}/src/sysmlpy/antlr_parser.py

@@ -74,8 +74,9 @@ def parse(source, library=None, recover=False, prediction_mode="sll"):
     prediction_mode : {"sll", "ll"}, default "sll"
         ``"sll"`` (default) runs the fast SLL pass with LL fallback.
         ``"ll"`` forces the full-context pass directly (slower; useful
-        for debugging).  ``"sll"`` without fallback can be forced with
-        ``prediction_mode="sll_only"``.
+        for debugging).  ``"sll_only"`` keeps every pass in SLL
+        prediction — including the fallback pass — so diagnostics
+        reflect SLL behaviour (error parity with the fast path).
 
     Returns
     -------
@@ -127,14 +128,20 @@ def parse(source, library=None, recover=False, prediction_mode="sll"):
             # errors but re-run without bail to build the partial tree.
             pass
 
-    # ── Stage 2: full LL parse (fallback) ─────────────────────────────
+    # ── Stage 2: full parse (fallback / forced mode) ──────────────────
     lexer, token_stream, parser = _make_parser(content)
     error_listener = ANTLRErrorListener()
     lexer.addErrorListener(error_listener)
     parser.addErrorListener(error_listener)
     from antlr4.error.ErrorStrategy import DefaultErrorStrategy
     parser._errHandler = DefaultErrorStrategy()
-    parser._interp.predictionMode = PredictionMode.LL
+    # SLL error parity (Goal 10): an explicit "sll_only" request stays
+    # in SLL prediction so its diagnostics match the fast pass; every
+    # other fallback (sll -> ll, forced ll) uses full LL prediction.
+    if prediction_mode == "sll_only":
+        parser._interp.predictionMode = PredictionMode.SLL
+    else:
+        parser._interp.predictionMode = PredictionMode.LL
     tree = parser.rootNamespace()
 
     # Check for errors

{sysmlpy-0.74.0 → sysmlpy-0.76.0}/src/sysmlpy/project.py

@@ -233,17 +233,73 @@ def _extract_imports(content: str) -> list[str]:
     Returns a list of qualified names like ``['ScalarValues', 'ISQ']``.
     Handles quoted package names (e.g., ``'Some Package'``) and the
     ``all`` keyword (e.g., ``import all Types::*``).
+
+    Since v0.76.0 this scans the SysML v2 lexer token stream instead
+    of a regex over raw text (Goal 10 "regex to parser" item), which
+    fixes three defects of the old regex:
+
+    - a bare ``import X::Y;`` (no visibility keyword) was missed —
+      the visibility prefix is optional per the SysML grammar and is
+      now correctly treated as such
+    - imports inside comments produced false positives
+    - imports inside string literals (e.g. ``doc about "..."``)
+      produced false positives
+
+    Syntax-error tolerance: the lexer keeps producing tokens for
+    partially broken sources (dependency scanning must not require a
+    parseable file), so scanning continues past stray tokens; an
+    import with a stray token in its name run is skipped.
     """
-    imports = []
-    # Match: [private|public|protected] import [all] <QualifiedName> [::*] [::**];
-    # Qualified name parts can be identifiers or quoted strings
-    pattern = _re.compile(
-        r'(?:private|public|protected)\s+import\s+(?:all\s+)?'
-        r"((?:[A-Za-z_][A-Za-z0-9_]*|'[^']*')(?:::(?:[A-Za-z_][A-Za-z0-9_]*|'[^']*'))*)"
-        r'(?:\:\:\*)?(?:\:\:\*\*)?\s*;'
-    )
-    for match in pattern.finditer(content):
-        imports.append(match.group(1))
+    imports: list[str] = []
+    try:
+        from sysmlpy.antlr_parser import _make_parser
+        from sysmlpy.antlr.SysMLv2Lexer import SysMLv2Lexer
+        _lexer, token_stream, _parser = _make_parser(content)
+        token_stream.fill()
+        tokens = token_stream.tokens
+    except Exception:
+        return imports
+
+    from antlr4.Token import Token
+
+    visible = [t for t in tokens
+               if t.type != Token.EOF
+               and t.channel == Token.DEFAULT_CHANNEL]
+
+    NAME_TYPES = frozenset((SysMLv2Lexer.IDENTIFIER, SysMLv2Lexer.STRING))
+    COLON_COLON = SysMLv2Lexer.COLON_COLON
+    STAR = SysMLv2Lexer.STAR
+    STAR_STAR = SysMLv2Lexer.STAR_STAR
+    SEMI = SysMLv2Lexer.SEMI
+    ALL = SysMLv2Lexer.ALL
+
+    i = 0
+    n = len(visible)
+    while i < n:
+        tok = visible[i]
+        if tok.type != SysMLv2Lexer.IMPORT:
+            i += 1
+            continue
+        # Collect the import run up to the terminating ';'
+        j = i + 1
+        parts: list[str] = []
+        aborted = False
+        while j < n and visible[j].type != SEMI:
+            t = visible[j]
+            if t.type in NAME_TYPES:
+                parts.append(t.text)
+            elif t.type in (ALL, COLON_COLON, STAR, STAR_STAR):
+                pass  # 'all' keyword, namespace separators, wildcards
+            else:
+                aborted = True  # stray token — not a well-formed import
+                break
+            j += 1
+        if parts and not aborted:
+            imports.append("::".join(parts))
+        # advance past the run (or the aborted token) and its ';' if present
+        i = j
+        if i < n and visible[i].type == SEMI:
+            i += 1
     return imports
 
 

{sysmlpy-0.74.0 → sysmlpy-0.76.0}/src/sysmlpy/semantic.py

@@ -1533,6 +1533,22 @@ def _parse_dimension(dim: Optional[str]) -> Optional[dict[str, int]]:
     return dims
 
 
+def _dims_mul(a: dict[str, int], b: dict[str, int]) -> dict[str, int]:
+    """Multiply two dimension dicts (add exponents, drop zeros)."""
+    out = dict(a)
+    for k, v in b.items():
+        out[k] = out.get(k, 0) + v
+    return {k: v for k, v in out.items() if v != 0}
+
+
+def _dims_div(a: dict[str, int], b: dict[str, int]) -> dict[str, int]:
+    """Divide two dimension dicts (subtract exponents, drop zeros)."""
+    out = dict(a)
+    for k, v in b.items():
+        out[k] = out.get(k, 0) - v
+    return {k: v for k, v in out.items() if v != 0}
+
+
 def _dimension_to_pint(dims: Optional[dict[str, int]]) -> Optional[Any]:
     """Map a SysML dimension dict to a pint dimensionality.
 
@@ -2107,6 +2123,263 @@ class ExpressionTypeChecker:
         if lhs_cat in ("boolean", "string") or rhs_cat in ("boolean", "string"):
             self._emit_mismatch(op, lhs_cat, rhs_cat, element, issues)
 
+    # -- unit-dimension derivation (Goal 10) ---------------------------------
+
+    def check_derivations(self, model: Any) -> list[SemanticIssue]:
+        """Derive ``*`` / ``/`` dimension algebra and compare with typing.
+
+        For every expression owner whose declared type carries a known
+        quantity dimension (library ``*Value`` / ``*Unit`` definitions),
+        the initializer's dimension is derived algebraically:
+
+        - ``a * b`` adds exponents, ``a / b`` subtracts them
+        - ``a ** n`` (literal integer ``n``) multiplies them
+        - ``+`` / ``-`` chains require equal operand dimensions
+        - dimensionless literals are the multiplicative identity
+
+        A mismatch between the derived dimension and the declared
+        typing is reported as ``UNIT_DIMENSION_DERIVATION_MISMATCH``.
+        Conservative skips: any operand with unknown dimension, non-
+        literal exponents, ``%``, boolean/string/relational levels,
+        and initializers with no quantity-typed operand at all (a bare
+        literal like ``= 70`` cannot reveal its intended unit).
+        """
+        issues: list[SemanticIssue] = []
+        self._walk_derivation_owners(model, issues, [])
+        return issues
+
+    def _walk_derivation_owners(
+        self,
+        element: Any,
+        issues: list[SemanticIssue],
+        scope_path: list[str],
+    ) -> None:
+        if element is None:
+            return
+        name = getattr(element, "name", None)
+        elem_type = type(element).__name__
+        is_container = getattr(element, "is_definition", False) or elem_type == "Package"
+        child_scope = scope_path
+        if is_container and name is not None and elem_type != "Model":
+            child_scope = scope_path + [name]
+
+        if elem_type in _EXPRESSION_OWNER_TYPES:
+            grammar = getattr(element, "grammar", None)
+            if grammar is not None:
+                typed = getattr(element, "typed_by_name", None)
+                if typed:
+                    declared = self._declared_dimension(str(typed))
+                    if declared is not None:
+                        try:
+                            grammar_def = grammar.get_definition()
+                        except Exception:
+                            grammar_def = None
+                        if grammar_def is not None:
+                            for expr in _find_owned_expressions(grammar_def):
+                                self._check_derivation(
+                                    expr, element, str(typed), declared,
+                                    scope_path, issues)
+
+        for child in getattr(element, "children", []):
+            self._walk_derivation_owners(child, issues, child_scope)
+
+    def _declared_dimension(self, type_name: str) -> Optional[dict[str, int]]:
+        """Dimension dict for a declared type name, or None when unknown."""
+        dim_str = self._dimensions.get(type_name)
+        if not dim_str:
+            simple = type_name.rsplit("::", 1)[-1]
+            dim_str = self._dimensions.get(simple)
+        if not dim_str:
+            return None
+        return _parse_dimension(dim_str)
+
+    def _check_derivation(
+        self,
+        expr_dict: dict,
+        element: Any,
+        type_name: str,
+        declared: dict[str, int],
+        scope_path: list[str],
+        issues: list[SemanticIssue],
+    ) -> None:
+        node = expr_dict.get("expression")
+        if not isinstance(node, dict):
+            return
+        derived, contributed = self._derive_dimension(node, scope_path)
+        if derived is None or not contributed:
+            return
+        if derived != declared:
+            issues.append(SemanticIssue(
+                severity="error",
+                code="UNIT_DIMENSION_DERIVATION_MISMATCH",
+                message=(
+                    f"Initializer of '{getattr(element, 'name', '?')}' derives "
+                    f"dimension '{_format_dimension(derived)}' but declared type "
+                    f"'{type_name}' has dimension '{_format_dimension(declared)}'"
+                ),
+                element=element,
+                reference=_format_dimension(declared),
+            ))
+
+    def _derive_dimension(
+        self,
+        node: Any,
+        scope_path: list[str],
+    ) -> tuple:
+        """Algebraically derive the dimension of an expression dict.
+
+        Returns ``(dims, contributed)`` where ``dims`` is ``None`` when
+        the expression is not statically derivable and ``contributed``
+        is True when at least one quantity-typed operand was seen
+        (bare-literal initializers stay silent).
+        """
+        if not isinstance(node, dict):
+            return (None, False)
+        name = node.get("name")
+
+        if name == "OwnedExpression":
+            return self._derive_dimension(node.get("expression"), scope_path)
+        if name == "ConditionalExpression":
+            operands = node.get("operand", []) or []
+            if len(operands) != 1:
+                return (None, False)
+            return self._derive_dimension(operands[0], scope_path)
+
+        # Operator-less levels are pure wrappers (the visitor always
+        # emits the full NullCoalescing → Implies → … chain); with an
+        # operator present the level is boolean-valued — not derivable.
+        if name == "NullCoalescingExpression":
+            if node.get("operator"):
+                return (None, False)
+            return self._derive_dimension(node.get("implies"), scope_path)
+        if name in ("ImpliesExpression", "OrExpression", "XorExpression",
+                    "AndExpression"):
+            if node.get("operator") or node.get("operand") \
+                    or node.get("operation"):
+                return (None, False)
+            child_key = {"ImpliesExpression": "or",
+                         "OrExpression": "xor",
+                         "XorExpression": "and",
+                         "AndExpression": "equality"}[name]
+            return self._derive_dimension(node.get(child_key), scope_path)
+        if name == "EqualityExpression":
+            if node.get("operation"):
+                return (None, False)
+            return self._derive_dimension(
+                node.get("classification"), scope_path)
+        if name == "ClassificationExpression":
+            if node.get("operator"):
+                return (None, False)
+            return self._derive_dimension(
+                node.get("relational"), scope_path)
+        if name == "RelationalExpression":
+            if node.get("operation"):
+                return (None, False)
+            return self._derive_dimension(node.get("range"), scope_path)
+
+        if name == "RangeExpression":
+            if node.get("operator"):
+                return (None, False)  # a .. b — bounds may differ
+            return self._derive_dimension(node.get("additive"), scope_path)
+
+        if name == "AdditiveExpression":
+            dims, contributed = self._derive_dimension(
+                node.get("multiplicitive"), scope_path)
+            for op_dict in node.get("operation", []) or []:
+                if not isinstance(op_dict, dict):
+                    continue
+                op = op_dict.get("operator")
+                rhs, c = self._derive_dimension(
+                    op_dict.get("operand"), scope_path)
+                if op not in ("+", "-") or dims is None or rhs is None \
+                        or dims != rhs:
+                    return (None, False)
+                contributed = contributed or c
+            return (dims, contributed)
+
+        if name == "MultiplicativeExpression":
+            dims, contributed = self._derive_dimension(
+                node.get("exponential"), scope_path)
+            for op_dict in node.get("operation", []) or []:
+                if not isinstance(op_dict, dict):
+                    continue
+                op = op_dict.get("operator")
+                rhs, c = self._derive_dimension(
+                    op_dict.get("operand"), scope_path)
+                if dims is None or rhs is None:
+                    return (None, False)
+                contributed = contributed or c
+                if op == "*":
+                    dims = _dims_mul(dims, rhs)
+                elif op == "/":
+                    dims = _dims_div(dims, rhs)
+                else:  # '%' and anything else — not derivable
+                    return (None, False)
+            return (dims, contributed)
+
+        if name == "ExponentiationExpression":
+            dims, contributed = self._derive_dimension(
+                node.get("unary"), scope_path)
+            if dims is None:
+                return (None, False)
+            # Two shapes: parallel operator/operand lists (visitor form)
+            # or operation entries with nested operator/operand dicts.
+            operator_list = node.get("operator")
+            if isinstance(operator_list, list) and operator_list:
+                operand_list = node.get("operand", []) or []
+                for op, rhs_node in zip(operator_list, operand_list):
+                    if op not in ("**", "^"):
+                        return (None, False)
+                    exponent = const_fold(rhs_node)
+                    if not isinstance(exponent, int) \
+                            or isinstance(exponent, bool):
+                        return (None, False)
+                    dims = {k: v * exponent for k, v in dims.items()}
+                return (dims, contributed)
+            for op_dict in node.get("operation", []) or []:
+                if not isinstance(op_dict, dict):
+                    continue
+                op = op_dict.get("operator")
+                rhs_node = op_dict.get("operand")
+                if op not in ("**", "^"):
+                    return (None, False)
+                exponent = const_fold(rhs_node)
+                if not isinstance(exponent, int) or isinstance(exponent, bool):
+                    return (None, False)
+                dims = {k: v * exponent for k, v in dims.items()}
+            return (dims, contributed)
+
+        if name == "UnaryExpression":
+            op = node.get("operator")
+            if op and op not in ("-", "+"):
+                return (None, False)  # 'not' etc. — boolean
+            return self._derive_leaf(node.get("extent"), scope_path)
+
+        if name in ("ExtentExpression", "PrimaryExpression", "BaseExpression"):
+            return self._derive_leaf(node, scope_path)
+
+        # Leaf nodes (FeatureReferenceExpression etc.)
+        return self._derive_leaf(node, scope_path)
+
+    def _derive_leaf(self, node: Any, scope_path: list[str]) -> tuple:
+        """Dimension of a leaf operand: literal, typed reference or unwrap."""
+        if not isinstance(node, dict):
+            return (None, False)
+        if node.get("name") in ("LiteralInteger", "LiteralReal",
+                                "LiteralInfinity"):
+            return ({}, False)
+        dims = self._dimension_of_operand(node, scope_path)
+        if dims is not None:
+            return (dims, True)
+        # Parenthesized / wrapped operands: descend through wrapper keys
+        for key in ("primary", "base", "expression", "ownedRelationship"):
+            child = node.get(key)
+            if isinstance(child, dict):
+                result = self._derive_dimension(child, scope_path)
+                if result[0] is not None:
+                    return result
+        return (None, False)
+
     # -- unit dimension safety ---------------------------------------------
 
     def _check_unit_dimensions(self, op, lhs, rhs, element, scope_path, issues) -> None:
@@ -2500,6 +2773,8 @@ class SemanticAnalyzer:
         # Step 4c: Expression type checking & unit-dimension safety
         # (v0.55.0 Phase C).
         issues.extend(self._check_expression_types(model, symtab, lib_roots))
+        issues.extend(
+            self._check_expression_derivations(model, symtab, lib_roots))
 
         # Step 5: OCL well-formedness constraints
         issues.extend(self._check_duplicate_names(symtab))
@@ -3100,6 +3375,16 @@ class SemanticAnalyzer:
         checker = ExpressionTypeChecker(self, symtab, lib_roots)
         return checker.check_units(model)
 
+    def _check_expression_derivations(
+        self,
+        model: Any,
+        symtab: SymbolTable,
+        lib_roots: list[Path] | None = None,
+    ) -> list[SemanticIssue]:
+        """Derive ``*``/``/`` dimension algebra vs declared typing."""
+        checker = ExpressionTypeChecker(self, symtab, lib_roots)
+        return checker.check_derivations(model)
+
     # -- OCL well-formedness constraints ------------------------------------
 
     def _check_trigger_payloads(
@@ -3560,7 +3845,7 @@ class SemanticAnalyzer:
         return issues
 
     def _check_connector_directions(self, model: Any) -> list[SemanticIssue]:
-        """Check connection-end port direction compatibility (Goal 9).
+        """Check connection ends: directions (Goal 9) + types (Goal 10).
 
         ``connection c connect a.p1 to b.p2;`` — when both end ports
         carry explicit directions and neither is ``inout``, wiring
@@ -3570,6 +3855,14 @@ class SemanticAnalyzer:
         error).  Ends without a direction keyword, ``inout`` ends,
         chains deeper than two segments and unresolvable parts are
         skipped.
+
+        Goal 10 (connector-end compatibility depth): when both ends
+        resolve to typings that are local ``port def`` names and
+        neither is a (transitive) specialization of the other, the
+        connection flags CONNECTOR_END_TYPE_MISMATCH (warning) —
+        conjugation only makes ports of the *same* (or related) port
+        definition compatible.  Ends typed by library/external port
+        definitions are skipped (no local subclass data).
         """
         issues: list[SemanticIssue] = []
         try:
@@ -3582,6 +3875,7 @@ class SemanticAnalyzer:
         part_typing: dict = {}   # part usage name -> typed-by name
         member_typing: dict = {}  # (container name, member) -> typed-by
         supertypes: dict = {}    # def name -> {superclassifier names}
+        port_defs: set = set()   # local port def names (Goal 10)
         connections: list = []   # (name, scope_stack, [chain, ...])
 
         def walk2(node, scope_stack):
@@ -3612,6 +3906,8 @@ class SemanticAnalyzer:
                         if sups:
                             supertypes.setdefault(declared, set()).update(
                                 sups)
+                        if nm == "PortDefinition":
+                            port_defs.add(declared)
                     if nm == "PortUsage":
                         d = _port_direction(node)
                         if scope_stack:
@@ -3715,6 +4011,55 @@ class SemanticAnalyzer:
                 return None, False  # known container, no such port
             return None, True       # external/library type: skip
 
+        def end_typing(chain, scope_stack):
+            """Typed-by name of an end chain's final segment, or None."""
+            if not chain:
+                return None
+            if len(chain) == 1:
+                name = chain[0]
+                for scope in reversed(scope_stack):
+                    t = member_typing.get((scope, name))
+                    if t:
+                        return t
+                return part_typing.get(name)
+            first = chain[0]
+            cur = part_typing.get(first)
+            if cur is None:
+                for scope in reversed(scope_stack):
+                    t = member_typing.get((scope, first))
+                    if t:
+                        cur = t
+                        break
+            if cur is None:
+                return None
+            for seg in chain[1:-1]:
+                t = member_typing.get((cur, seg))
+                if t is None:
+                    t = member_typing.get((first, seg))
+                if t is None:
+                    return None
+                cur = t
+            t = member_typing.get((cur, chain[-1]))
+            if t is None:
+                t = member_typing.get((first, chain[-1]))
+            return t
+
+        def _sub(a, b):
+            """True when a is b or a (transitively) specializes b."""
+            if a == b:
+                return True
+            seen = set()
+            stack = [a]
+            while stack:
+                cur = stack.pop()
+                if cur == b:
+                    return True
+                if cur in seen:
+                    continue
+                seen.add(cur)
+                stack.extend(supertypes.get(cur, ()))
+            return False
+
         for cname, cstack, chains in connections:
             d1, r1 = end_resolve(chains[0], cstack)
             d2, r2 = end_resolve(chains[1], cstack)
@@ -3736,6 +4081,22 @@ class SemanticAnalyzer:
                         f"'{'.'.join(chains[1])}' does not resolve"),
                     reference=cname,
                 ))
+            # Goal 10: end-type compatibility (port defs, local only)
+            t1 = end_typing(chains[0], cstack)
+            t2 = end_typing(chains[1], cstack)
+            if (t1 and t2 and t1 in port_defs and t2 in port_defs
+                    and not _sub(t1, t2) and not _sub(t2, t1)):
+                issues.append(SemanticIssue(
+                    severity="warning",
+                    code="CONNECTOR_END_TYPE_MISMATCH",
+                    message=(
+                        f"Connection '{cname}' binds "
+                        f"'{'.'.join(chains[0])}' (typed '{t1}') to "
+                        f"'{'.'.join(chains[1])}' (typed '{t2}'); "
+                        "connected port definitions are unrelated"
+                    ),
+                    reference=cname,
+                ))
             if not d1 or not d2:
                 continue
             if d1 == "inout" or d2 == "inout":