sysmlpy 0.75.0__tar.gz → 0.76.0__tar.gz

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

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

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

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

{sysmlpy-0.75.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.75.0"
+__version__ = "0.76.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,

{sysmlpy-0.75.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.75.0 → sysmlpy-0.76.0}/src/sysmlpy/semantic.py

@@ -3845,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
@@ -3855,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:
@@ -3867,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):
@@ -3897,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:
@@ -4000,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)
@@ -4021,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":