pyflow-analysis 0.1.0__py3-none-any.whl

pyflow/__init__.py

@@ -0,0 +1,22 @@
+"""PyFlow - Static Analysis Framework for Python."""
+
+__version__ = "0.1.0"
+__author__ = "rainoftime"
+__email__ = "rainoftime@gmail.com"
+
+# Import main components for easy access
+from .application.program import Program
+from .application.pipeline import Pipeline
+from .application.context import Context
+from .api.queries import SemanticQueryService, IpaFunctionSummary
+
+__all__ = [
+    "Program",
+    "Pipeline",
+    "Context",
+    "SemanticQueryService",
+    "IpaFunctionSummary",
+    "__version__",
+    "__author__",
+    "__email__",
+]

pyflow/_pyflow.py

@@ -0,0 +1,50 @@
+"""
+Stub implementation of _pyflow module.
+
+WARNING: This is a pure-Python stub that replaces the missing native C extension.
+The real extension returns actual C function pointer addresses (integers).
+This stub returns opaque tuples instead, which are NOT integers and will break
+any code that performs arithmetic on the result, compares it to a raw integer,
+or passes it to a C API.
+
+Any analysis that depends on precise C-level pointer values will produce
+incorrect results when using this stub.
+"""
+
+import warnings as _warnings
+
+_warnings.warn(
+    "pyflow._pyflow: native C extension not found; using pure-Python stub. "
+    "Analyses that rely on C function pointer values will be unsound.",
+    RuntimeWarning,
+    stacklevel=1,
+)
+
+
+def cfuncptr(obj):
+    """
+    Stub implementation of cfuncptr.
+
+    Returns a stable, hashable identifier for the object.  The real
+    implementation returns an integer (C pointer address); this stub
+    returns an integer derived from the object's identity so that
+    callers that only need a unique key still work correctly.
+
+    NOTE: The returned value is NOT a real C pointer and must not be
+    used for pointer arithmetic or passed to C APIs.
+    """
+    # Return a plain int so that callers expecting an integer do not
+    # immediately crash (e.g. comparisons, dict keys).  Using id() is
+    # safe for the lifetime of the object.
+    return id(obj)
+
+
+# Additional stub functions that might be needed
+def get_object_pointer(obj):
+    """Stub for getting object pointers."""
+    return cfuncptr(obj)
+
+
+def get_function_pointer(func):
+    """Stub for getting function pointers."""
+    return cfuncptr(func)

pyflow/analysis/__init__.py

@@ -0,0 +1,14 @@
+"""Analysis modules for PyFlow static analysis.
+
+This package contains various analysis modules for static analysis of Python
+code, including control flow analysis, data flow analysis, inter-procedural
+analysis, constraint-based analysis, and shape analysis.
+"""
+
+# Import main analysis modules
+from . import shape
+from . import ipa
+from . import cpa
+from . import fsdf
+from . import alias
+from . import ifds

pyflow/analysis/alias/__init__.py

@@ -0,0 +1,3 @@
+"""Alias analyses with flow-sensitive and k-CFA implementations."""
+
+__all__ = ["flow_sensitive", "kcfa"]

pyflow/analysis/alias/flow_sensitive/__init__.py

@@ -0,0 +1,148 @@
+"""Heap abstraction model for static analysis.
+
+The heap model provides canonical :class:`HeapLocation` objects,
+:class:`HeapAbstraction` for alias tracking and strong/weak update policy,
+and factory classes for translating Python IR operations into heap effects.
+
+Submodules
+----------
+* :mod:`.model` — Data model: enums, HeapPolicy, HeapObject, HeapLocation, HeapSelector, HeapWrite
+* :mod:`.abstraction` — HeapAbstraction engine: canonicalization, alias tracking, update policies
+* :mod:`.heap_effects` — Translates IR operations into HeapEffect records
+* :mod:`.heap_state` — Flow-sensitive, path-insensitive value state
+* :mod:`.heap_summary` — Procedure-level heap summaries
+* :mod:`.points_to_graph` — Read-only PointsToGraph snapshot for optimization passes
+* :mod:`.heap_analysis` — Standalone HeapAnalysis engine and pass integration
+* :mod:`.intrinsics` — Heap-owned built-in call and collection models
+* :mod:`.transfer` — Standalone forward transfer engine
+
+Examples
+--------
+
+>>> from pyflow.analysis.alias.flow_sensitive import HeapPolicy, HeapAbstraction, HeapEffect
+
+>>> policy = HeapPolicy.context_sensitive(depth=2)
+>>> policy.validate()  # catch misconfigurations early
+
+>>> effect = HeapEffect(reads=(...), writes=(...))
+>>> bool(effect)
+True
+>>> effect.is_empty
+False
+>>> merged = effect.merge(other_effect)
+
+>>> heap = HeapAbstraction(raw_storage_provider, policy=policy)
+>>> heap.to_dict()
+{'policy': {...}, 'next_site': 0, 'cached_objects': 0, ...}
+
+Standalone ``HeapAnalysis`` performs a flow-sensitive, path-insensitive
+forward sweep over discoverable code objects.  It keeps precise field and
+literal-key values when possible and records wildcard writes as contaminating
+overlapping paths instead of flattening unrelated exact facts.
+"""
+
+from .model import (
+    AllocationSensitivity,
+    ContainerSensitivity,
+    FieldSensitivity,
+    HeapEscapeState,
+    HeapLocation,
+    HeapObject,
+    HeapObjectCardinality,
+    HeapObjectIdentity,
+    HeapObjectFreshness,
+    HeapObjectKind,
+    HeapPolicy,
+    HeapSelector,
+    HeapWrite,
+    RawStorageProvider,
+    UpdatePolicy,
+)
+
+from .abstraction import (
+    HeapAbstraction,
+    HeapEnvironment,
+)
+
+from .heap_effects import (
+    CALL_RETURN_COPY,
+    CALL_RETURN_FRESH,
+    CALL_RETURN_OPAQUE,
+    CALL_RETURN_SUMMARY,
+    COLLECTION_DELETE_MUTATOR_NAMES,
+    COLLECTION_VALUE_MUTATOR_NAMES,
+    DEFAULT_COLLECTION_MUTATOR_NAMES,
+    HeapEffect,
+    HeapEffectBuilder,
+    HeapOperationSemantics,
+)
+
+from .intrinsics import (
+    CollectionMutatorModel,
+    DEFAULT_HEAP_INTRINSICS,
+    HeapIntrinsicModels,
+)
+
+from .heap_state import HeapState
+
+from .heap_summary import (
+    HeapSummary,
+    HeapSummaryBuilder,
+    ProcedureHeapSummary,
+)
+
+from .points_to_graph import (
+    HeapValueSnapshot,
+    PossibleValues,
+    PointsToEntry,
+    PointsToGraph,
+)
+
+from .heap_analysis import (
+    HeapAnalysis,
+)
+
+from .transfer import HeapTransferEngine
+
+__all__ = [
+    "AllocationSensitivity",
+    "CALL_RETURN_COPY",
+    "CALL_RETURN_FRESH",
+    "CALL_RETURN_OPAQUE",
+    "CALL_RETURN_SUMMARY",
+    "COLLECTION_DELETE_MUTATOR_NAMES",
+    "COLLECTION_VALUE_MUTATOR_NAMES",
+    "CollectionMutatorModel",
+    "ContainerSensitivity",
+    "DEFAULT_COLLECTION_MUTATOR_NAMES",
+    "DEFAULT_HEAP_INTRINSICS",
+    "FieldSensitivity",
+    "HeapAbstraction",
+    "HeapAnalysis",
+    "HeapEffect",
+    "HeapEffectBuilder",
+    "HeapOperationSemantics",
+    "HeapEnvironment",
+    "HeapEscapeState",
+    "HeapLocation",
+    "HeapObject",
+    "HeapObjectCardinality",
+    "HeapObjectIdentity",
+    "HeapObjectFreshness",
+    "HeapObjectKind",
+    "HeapPolicy",
+    "HeapSelector",
+    "HeapState",
+    "HeapSummary",
+    "HeapTransferEngine",
+    "HeapIntrinsicModels",
+    "HeapSummaryBuilder",
+    "ProcedureHeapSummary",
+    "HeapWrite",
+    "HeapValueSnapshot",
+    "PointsToEntry",
+    "PointsToGraph",
+    "PossibleValues",
+    "RawStorageProvider",
+    "UpdatePolicy",
+]