codeboarding 0.13.6__tar.gz → 0.13.8__tar.gz

{codeboarding-0.13.6/codeboarding.egg-info → codeboarding-0.13.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.13.6
+Version: 0.13.8
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.13.6 → codeboarding-0.13.8/codeboarding.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.13.6
+Version: 0.13.8
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.13.6 → codeboarding-0.13.8}/codeboarding.egg-info/SOURCES.txt

@@ -189,6 +189,7 @@ tests/test_github_action.py
 tests/test_install.py
 tests/test_logging_config.py
 tests/test_main.py
+tests/test_persisted_analysis_artifacts.py
 tests/test_pyproject_packages.py
 tests/test_registry_coverage.py
 tests/test_telemetry_events.py

{codeboarding-0.13.6 → codeboarding-0.13.8}/constants.py

@@ -1,6 +1,18 @@
 """Application-level constants for CodeBoarding."""
 
 CODEBOARDING_DIR_NAME = ".codeboarding"
+ANALYSIS_FILENAME = "analysis.json"
+FINGERPRINT_FILENAME = "fingerprint.json"
+STATIC_ANALYSIS_PKL = "static_analysis.pkl"
+STATIC_ANALYSIS_SHA = "static_analysis.sha"
+CODEBOARDING_VERSION_FILENAME = "codeboarding_version.json"
+PERSISTED_ANALYSIS_ARTIFACT_FILENAMES = (
+    ANALYSIS_FILENAME,
+    FINGERPRINT_FILENAME,
+    STATIC_ANALYSIS_PKL,
+    STATIC_ANALYSIS_SHA,
+    CODEBOARDING_VERSION_FILENAME,
+)
 # Ignore-file names read from a repo (``.gitignore`` at the repo root,
 # ``.codeboardingignore`` under ``CODEBOARDING_DIR_NAME``).
 GITIGNORE_FILENAME = ".gitignore"

{codeboarding-0.13.6 → codeboarding-0.13.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeboarding"
-version = "0.13.6"
+version = "0.13.8"
 description = "Interactive Diagrams for Code"
 readme = "PYPI.md"
 license = "MIT"

{codeboarding-0.13.6 → codeboarding-0.13.8}/static_analyzer/analysis_cache.py

@@ -29,11 +29,12 @@ from typing import TYPE_CHECKING, Any
 
 from filelock import FileLock
 
+from constants import STATIC_ANALYSIS_PKL, STATIC_ANALYSIS_SHA
+from repo_utils.path_utils import to_absolute_path, to_relative_path
 from static_analyzer.analysis_result import AnalysisData, InvalidatedAnalysis, InvalidatedEdge
 from static_analyzer.graph import CallGraph, Edge, EdgeKind
 from static_analyzer.lsp_client.diagnostics import FileDiagnosticsMap
 from static_analyzer.node import Node
-from repo_utils.path_utils import to_absolute_path, to_relative_path
 
 if TYPE_CHECKING:
     from static_analyzer.analysis_result import StaticAnalysisResults
@@ -44,8 +45,6 @@ logger = logging.getLogger(__name__)
 # Run-artifact filenames. Stored in ``<repo>/.codeboarding/`` (sibling of
 # ``analysis.json``), not under ``cache/`` — losing them costs a full LSP
 # re-index, so they're not safe to wipe with the rest of the cache.
-STATIC_ANALYSIS_PKL = "static_analysis.pkl"
-STATIC_ANALYSIS_SHA = "static_analysis.sha"
 STATIC_ANALYSIS_LOCK = "static_analysis.lock"
 # Legacy location ``StaticAnalysisCache`` wrote to before the run-artifact
 # split. Kept for one-time read fallback so CLI users transition smoothly.

{codeboarding-0.13.6 → codeboarding-0.13.8}/static_analyzer/engine/adapters/csharp_adapter.py

@@ -36,7 +36,7 @@ _SINGLE_TARGET_FRAMEWORK_TARGETS = r"""<Project>
   <Import
     Project="$(CodeBoardingDirectoryBuildTargetsPath)"
     Condition="Exists('$(CodeBoardingDirectoryBuildTargetsPath)')" />
-  <PropertyGroup Condition="'$(TargetFrameworks)' != ''">
+  <PropertyGroup Condition="'$(TargetFrameworks)' != '' and '$(CodeBoardingFoldMultiTargetFrameworks)' == 'true'">
     <CodeBoardingTargetFrameworks>$([System.Text.RegularExpressions.Regex]::Replace('$(TargetFrameworks)', '\s', ''))</CodeBoardingTargetFrameworks>
     <CodeBoardingTargetFrameworks>$([System.Text.RegularExpressions.Regex]::Replace('$(CodeBoardingTargetFrameworks)', ';+', ';'))</CodeBoardingTargetFrameworks>
     <CodeBoardingTargetFrameworks>;$([System.String]::Copy('$(CodeBoardingTargetFrameworks)').Trim(';'));</CodeBoardingTargetFrameworks>
@@ -47,24 +47,68 @@ _SINGLE_TARGET_FRAMEWORK_TARGETS = r"""<Project>
 </Project>
 """
 
+_WORKSPACE_TARGET_FRAMEWORK_PROPS = r"""<Project TreatAsLocalProperty="TargetFramework">
+  <PropertyGroup>
+    <CodeBoardingWorkspaceTargetFramework>$(TargetFramework)</CodeBoardingWorkspaceTargetFramework>
+    <CodeBoardingDirectoryBuildPropsPath Condition="'$(CodeBoardingOriginalDirectoryBuildPropsPath)' == ''">$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildProjectDirectory)'))</CodeBoardingDirectoryBuildPropsPath>
+  </PropertyGroup>
+  <Import
+    Project="$(CodeBoardingOriginalDirectoryBuildPropsPath)"
+    Condition="Exists('$(CodeBoardingOriginalDirectoryBuildPropsPath)')" />
+  <Import
+    Project="$(CodeBoardingDirectoryBuildPropsPath)"
+    Condition="Exists('$(CodeBoardingDirectoryBuildPropsPath)')" />
+</Project>
+"""
+
+
+def _write_injected_import(name: str, content: str) -> Path:
+    """Materialize an MSBuild import CodeBoarding injects via environment variable."""
+    path = get_servers_dir() / name
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists() or path.read_text(encoding="utf-8") != content:
+        temporary_path = path.with_name(f"{path.name}.{os.getpid()}.tmp")
+        temporary_path.write_text(content, encoding="utf-8")
+        os.replace(temporary_path, path)
+    return path
+
 
 def _single_target_framework_env(project_root: Path) -> dict[str, str]:
-    """Prevent csharp-ls's exponential multi-target framework fold."""
-    project_count = sum(1 for pattern in ("*.csproj", "*.fsproj") for _ in project_root.rglob(pattern))
-    if project_count <= _MULTI_TARGET_PROJECT_THRESHOLD:
-        return {}
+    """Keep csharp-ls's workspace-wide TargetFramework from rewriting single-target projects.
+
+    Why: csharp-ls folds every project's frameworks into one global MSBuild
+    ``TargetFramework``. A global property outranks a project's own
+    ``<TargetFramework>``, so a solution whose projects do not all share one
+    framework has that property forced onto the odd ones out. Conditions keyed
+    on ``$(TargetFramework)`` then evaluate against a framework the project does
+    not target -- the idiomatic ``Condition="'$(TargetFramework)' !=
+    'netstandard2.0'"`` guard around analyzer ``ProjectReference`` items inverts
+    and the analyzer projects reference themselves, which sends Roslyn's
+    solution load into unbounded growth. ``TreatAsLocalProperty`` demotes the
+    property so each project sees its declared framework again. Roslyn retains
+    its normal inner-build expansion for projects that genuinely multi-target.
+
+    Folding a multi-target project down to a single framework stays behind
+    ``_MULTI_TARGET_PROJECT_THRESHOLD``, because that fold discards frameworks a
+    small solution may want analyzed. Demoting the property has no such cost: it
+    only changes evaluation for a project whose declared framework the workspace
+    value contradicts, so it applies to every solution.
+    """
+    targets_path = _write_injected_import("csharp-ls-single-target.targets", _SINGLE_TARGET_FRAMEWORK_TARGETS)
+    props_path = _write_injected_import("csharp-ls-workspace-tfm.props", _WORKSPACE_TARGET_FRAMEWORK_PROPS)
+
+    env = {"DirectoryBuildTargetsPath": str(targets_path), "DirectoryBuildPropsPath": str(props_path)}
 
-    targets_path = get_servers_dir() / "csharp-ls-single-target.targets"
-    targets_path.parent.mkdir(parents=True, exist_ok=True)
-    if not targets_path.exists() or targets_path.read_text(encoding="utf-8") != _SINGLE_TARGET_FRAMEWORK_TARGETS:
-        temporary_path = targets_path.with_name(f"{targets_path.name}.{os.getpid()}.tmp")
-        temporary_path.write_text(_SINGLE_TARGET_FRAMEWORK_TARGETS, encoding="utf-8")
-        os.replace(temporary_path, targets_path)
+    project_count = sum(1 for pattern in ("*.csproj", "*.fsproj") for _ in project_root.rglob(pattern))
+    if project_count > _MULTI_TARGET_PROJECT_THRESHOLD:
+        env["CodeBoardingFoldMultiTargetFrameworks"] = "true"
 
-    env = {"DirectoryBuildTargetsPath": str(targets_path)}
     original_targets_path = os.environ.get("DirectoryBuildTargetsPath")
     if original_targets_path:
         env["CodeBoardingOriginalDirectoryBuildTargetsPath"] = original_targets_path
+    original_props_path = os.environ.get("DirectoryBuildPropsPath")
+    if original_props_path:
+        env["CodeBoardingOriginalDirectoryBuildPropsPath"] = original_props_path
     return env
 
 

{codeboarding-0.13.6 → codeboarding-0.13.8}/static_analyzer/language_results.py

@@ -25,6 +25,11 @@ class ControlFlowGraph:
         if self.graph is None:
             self.graph = other
             return
+        if self.graph is other:
+            # Why: two engine configs can share a language (two tsconfig projects give
+            # two TypeScript engines) and warm-start hands both the same cached graph.
+            # Iterating a container while adding to it is unbounded, not just wasteful.
+            return
         for node in other.nodes.values():
             self.graph.add_node(node)
         for edge in other.edges:
@@ -55,6 +60,11 @@ class ControlFlowGraph:
         # Re-added via the API so alias-resolution and node-existence guards apply post-merge.
         for src, dst, kind in getattr(other, "reference_edges", ()):
             self.graph.add_reference_edge(src, dst, EdgeKind(kind))
+        # Nodes and call edges are keyed, reference edges are appended, so only they
+        # survive a repeat merge. Dedup after the loop rather than per-add: the stored
+        # tuple is post-alias-resolution, and a membership scan per edge is quadratic.
+        # getattr for the same reason as above: pre-reference-edge caches lack the field.
+        self.graph.reference_edges = list(dict.fromkeys(getattr(self.graph, "reference_edges", ())))
         self.graph.method_cluster_paths.merge(other.method_cluster_paths)
 
     def visit_paths(self, fn: Callable[[str], str]) -> None:
@@ -126,9 +136,16 @@ class SourceFiles:
     paths: list[str] | None = None
 
     def extend(self, files: list[str]) -> None:
+        # Why: called once per engine config, and two engines of one language are
+        # handed the same cached list on warm-start. Duplicates persist into the pkl,
+        # so an undeduped extend doubles the list on every subsequent run.
         if self.paths is None:
             self.paths = []
-        self.paths.extend(files)
+        known = set(self.paths)
+        for path in files:
+            if path not in known:
+                known.add(path)
+                self.paths.append(path)
 
     def visit_paths(self, fn: Callable[[str], str]) -> None:
         if self.paths is None:

codeboarding-0.13.8/tests/test_persisted_analysis_artifacts.py

@@ -0,0 +1,29 @@
+from constants import (
+    ANALYSIS_FILENAME,
+    CODEBOARDING_VERSION_FILENAME,
+    FINGERPRINT_FILENAME,
+    PERSISTED_ANALYSIS_ARTIFACT_FILENAMES,
+    STATIC_ANALYSIS_PKL,
+    STATIC_ANALYSIS_SHA,
+)
+from static_analyzer.analysis_cache import (
+    STATIC_ANALYSIS_PKL as COMPAT_STATIC_ANALYSIS_PKL,
+    STATIC_ANALYSIS_SHA as COMPAT_STATIC_ANALYSIS_SHA,
+)
+from utils import ANALYSIS_FILENAME as COMPAT_ANALYSIS_FILENAME
+from utils import FINGERPRINT_FILENAME as COMPAT_FINGERPRINT_FILENAME
+
+
+def test_persisted_analysis_artifact_manifest_and_compatibility_imports():
+    assert PERSISTED_ANALYSIS_ARTIFACT_FILENAMES == (
+        "analysis.json",
+        "fingerprint.json",
+        "static_analysis.pkl",
+        "static_analysis.sha",
+        "codeboarding_version.json",
+    )
+    assert CODEBOARDING_VERSION_FILENAME == "codeboarding_version.json"
+    assert COMPAT_ANALYSIS_FILENAME == ANALYSIS_FILENAME
+    assert COMPAT_FINGERPRINT_FILENAME == FINGERPRINT_FILENAME
+    assert COMPAT_STATIC_ANALYSIS_PKL == STATIC_ANALYSIS_PKL
+    assert COMPAT_STATIC_ANALYSIS_SHA == STATIC_ANALYSIS_SHA

{codeboarding-0.13.6 → codeboarding-0.13.8}/utils.py

@@ -7,14 +7,12 @@ import uuid
 from collections.abc import Iterable
 from pathlib import Path
 
-from constants import CODEBOARDING_DIR_NAME
+from constants import ANALYSIS_FILENAME, CODEBOARDING_DIR_NAME, FINGERPRINT_FILENAME
 from repo_utils.path_utils import to_absolute_path, to_relative_path
 
 logger = logging.getLogger(__name__)
 
 RUN_OUTPUT_DIR_NAME = "run-output"
-ANALYSIS_FILENAME = "analysis.json"
-FINGERPRINT_FILENAME = "fingerprint.json"
 
 
 class CFGGenerationError(Exception):