onec-interactive-runtime-core 0.1.19__py3-none-any.whl

onec_runtime/bsl/worker_dependency_resolver.py

@@ -0,0 +1,289 @@
+"""Resolve minimal Worker name projections against a session catalog snapshot."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from onec_runtime.bsl.module_catalog import (
+    CommonModuleCatalogSnapshot,
+    CommonModuleDescriptor,
+)
+from onec_runtime.bsl.source_maps import SourceSpan
+from onec_runtime.bsl.worker_projection_model import (
+    BareName,
+    BareNameKind,
+    ParsedMethodModel,
+    ParsedModuleModel,
+)
+from onec_runtime.errors import ModuleUniverseAdmissionError
+
+
+MODULE_SCOPE_DEPENDENCY = "module_scope_dependency"
+AMBIGUOUS_BINDING = "ambiguous_module_dependency"
+
+_PLATFORM_GLOBALS = frozenset(
+    {
+        "статуссообщения",
+        "символы",
+        "кодировкатекста",
+        "справочники",
+        "документы",
+        "журналыдокументов",
+        "регистрысведений",
+        "регистрынакопления",
+        "регистрыбухгалтерии",
+        "регистрырасчета",
+        "планывидовхарактеристик",
+        "планысчетов",
+        "планывидоврасчета",
+        "планыобмена",
+        "бизнеспроцессы",
+        "задачи",
+        "критерииотбора",
+        "последовательности",
+        "константы",
+        "перечисления",
+        "внешниеобработки",
+        "внешниеотчеты",
+        "обработки",
+        "отчеты",
+        "метаданные",
+        "параметрысеанса",
+        "частидаты",
+        "обходрезультатазапроса",
+        "видсравнениякомпоновкиданных",
+        "типгруппыэлементовотборакомпоновкиданных",
+        "цветастиля",
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedMethodPlan:
+    source: ParsedMethodModel
+    local_names: tuple[str, ...]
+    implicit_local_names: tuple[str, ...]
+    dependencies: tuple[str, ...]
+    forbidden_global_writes: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedModulePlan:
+    source: ParsedModuleModel
+    catalog_generation: int
+    catalog_identity: tuple[str, str, int, str]
+    implicit_local_names: tuple[str, ...]
+    forbidden_global_writes: tuple[str, ...]
+    methods: tuple[ResolvedMethodPlan, ...]
+    dependencies: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class _ResolvedNames:
+    implicit_locals: tuple[str, ...]
+    forbidden_writes: tuple[str, ...]
+    dependencies: tuple[str, ...]
+
+
+def worker_model_candidate_names(
+    models: Iterable[ParsedModuleModel],
+) -> tuple[str, ...]:
+    """Return the canonical catalog lookup set for parsed module models."""
+    candidates: set[str] = set()
+    for model in models:
+        if not isinstance(model, ParsedModuleModel):
+            raise TypeError("models must contain ParsedModuleModel values")
+        candidates.update(item.normalized_name for item in model.module_bare_names)
+        candidates.update(
+            item.normalized_name
+            for method in model.methods
+            for item in method.bare_names
+        )
+    return tuple(sorted(candidates))
+
+
+def resolve_worker_dependencies(
+    model: ParsedModuleModel,
+    catalog: CommonModuleCatalogSnapshot,
+    *,
+    previous: ResolvedModulePlan | None = None,
+) -> ResolvedModulePlan:
+    """Resolve one immutable syntax model without revisiting source or tokens."""
+
+    if not isinstance(model, ParsedModuleModel):
+        raise TypeError("model must be ParsedModuleModel")
+    if not isinstance(catalog, CommonModuleCatalogSnapshot):
+        raise TypeError("catalog must be CommonModuleCatalogSnapshot")
+    if previous is not None:
+        if not isinstance(previous, ResolvedModulePlan):
+            raise TypeError("previous must be ResolvedModulePlan")
+        if (
+            previous.source.source_sha256 != model.source_sha256
+            or previous.source.parser_identity != model.parser_identity
+        ):
+            raise ValueError("previous plan must describe the same source version")
+        current_identity = _catalog_identity(catalog)
+        if previous.catalog_identity[:2] != current_identity[:2]:
+            raise ValueError("catalog profile identity cannot change")
+        if previous.catalog_generation > catalog.revision:
+            raise ValueError("catalog generation cannot move backwards")
+        if (
+            previous.catalog_generation == catalog.revision
+            and previous.catalog_identity != current_identity
+        ):
+            raise ValueError("catalog identity changed within one generation")
+
+    method_names: set[str] = set()
+    for method in model.methods:
+        if method.normalized_name in method_names:
+            error = ModuleUniverseAdmissionError(
+                "worker module contains an ambiguous method declaration"
+            )
+            error.code = AMBIGUOUS_BINDING
+            error.span = method.declaration_span
+            raise error
+        method_names.add(method.normalized_name)
+
+    catalog_by_name = {
+        descriptor.canonical_name.casefold(): descriptor
+        for descriptor in catalog.modules
+    }
+    catalog_order = tuple(catalog_by_name)
+    internal_methods = frozenset(method_names)
+    module_hard_locals = frozenset(model.module_variables)
+    previous_module_implicit = (
+        frozenset(previous.implicit_local_names) if previous is not None else frozenset()
+    )
+    module_names = _resolve_names(
+        model.module_bare_names,
+        hard_locals=module_hard_locals,
+        frozen_implicit=previous_module_implicit,
+        internal_methods=internal_methods,
+        catalog_by_name=catalog_by_name,
+        catalog_order=catalog_order,
+    )
+    if module_names.dependencies:
+        error = ModuleUniverseAdmissionError(
+            "common module dependency is unsupported in module scope"
+        )
+        error.code = MODULE_SCOPE_DEPENDENCY
+        error.span = SourceSpan(0, 0)
+        raise error
+
+    previous_methods = (
+        {method.source.normalized_name: method for method in previous.methods}
+        if previous is not None
+        else {}
+    )
+    methods: list[ResolvedMethodPlan] = []
+    all_dependencies: set[str] = set()
+    for method in model.methods:
+        prior = previous_methods.get(method.normalized_name)
+        hard_locals = (
+            module_hard_locals
+            | frozenset(module_names.implicit_locals)
+            | frozenset(method.declared_names)
+        )
+        resolved = _resolve_names(
+            method.bare_names,
+            hard_locals=hard_locals,
+            frozen_implicit=(
+                frozenset(prior.implicit_local_names)
+                if prior is not None
+                else frozenset()
+            ),
+            internal_methods=internal_methods,
+            catalog_by_name=catalog_by_name,
+            catalog_order=catalog_order,
+        )
+        all_dependencies.update(name.casefold() for name in resolved.dependencies)
+        methods.append(
+            ResolvedMethodPlan(
+                source=method,
+                local_names=tuple(
+                    sorted(hard_locals | frozenset(resolved.implicit_locals))
+                ),
+                implicit_local_names=resolved.implicit_locals,
+                dependencies=resolved.dependencies,
+                forbidden_global_writes=resolved.forbidden_writes,
+            )
+        )
+
+    return ResolvedModulePlan(
+        source=model,
+        catalog_generation=catalog.revision,
+        catalog_identity=_catalog_identity(catalog),
+        implicit_local_names=module_names.implicit_locals,
+        forbidden_global_writes=module_names.forbidden_writes,
+        methods=tuple(methods),
+        dependencies=tuple(
+            catalog_by_name[name].canonical_name
+            for name in catalog_order
+            if name in all_dependencies
+        ),
+    )
+
+
+def _catalog_identity(
+    catalog: CommonModuleCatalogSnapshot,
+) -> tuple[str, str, int, str]:
+    return (
+        catalog.profile,
+        catalog.preprocessor_profile,
+        catalog.revision,
+        catalog.sha256,
+    )
+
+
+def _resolve_names(
+    bare_names: tuple[BareName, ...],
+    *,
+    hard_locals: frozenset[str],
+    frozen_implicit: frozenset[str],
+    internal_methods: frozenset[str],
+    catalog_by_name: dict[str, CommonModuleDescriptor],
+    catalog_order: tuple[str, ...],
+) -> _ResolvedNames:
+    by_name = {item.normalized_name: item for item in bare_names}
+    implicit: set[str] = set(frozen_implicit)
+    forbidden: set[str] = set()
+    dependencies: set[str] = set()
+    shadowed = hard_locals | frozen_implicit | internal_methods | _PLATFORM_GLOBALS
+
+    for normalized, item in by_name.items():
+        if normalized in shadowed:
+            continue
+        descriptor = catalog_by_name.get(normalized)
+        if item.kinds & BareNameKind.BARE_WRITE:
+            if descriptor is None:
+                implicit.add(normalized)
+            else:
+                forbidden.add(normalized)
+            continue
+        if item.kinds & BareNameKind.READ and descriptor is not None:
+            dependencies.add(normalized)
+
+    return _ResolvedNames(
+        implicit_locals=tuple(sorted(implicit)),
+        forbidden_writes=tuple(
+            catalog_by_name[name].canonical_name
+            for name in catalog_order
+            if name in forbidden
+        ),
+        dependencies=tuple(
+            catalog_by_name[name].canonical_name
+            for name in catalog_order
+            if name in dependencies
+        ),
+    )
+
+
+__all__ = [
+    "AMBIGUOUS_BINDING",
+    "MODULE_SCOPE_DEPENDENCY",
+    "ResolvedMethodPlan",
+    "ResolvedModulePlan",
+    "resolve_worker_dependencies",
+    "worker_model_candidate_names",
+]

onec_runtime/bsl/worker_preprocessor.py

@@ -0,0 +1,247 @@
+"""Select the server-effective token view without rewriting Worker source."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from onec_runtime.bsl.lexer import Token
+from onec_runtime.bsl.parser_target import BslParseError
+from onec_runtime.bsl.source_maps import SourceSpan
+
+
+_TRUE_SYMBOLS = frozenset({"сервер", "server"})
+_FALSE_SYMBOLS = frozenset(
+    {
+        "клиент",
+        "client",
+        "вебклиент",
+        "webclient",
+        "тонкийклиент",
+        "thinclient",
+        "толстыйклиентобычноеприложение",
+        "thickclientordinaryapplication",
+        "толстыйклиентуправляемоеприложение",
+        "thickclientmanagedapplication",
+        "внешнеесоединение",
+        "externalconnection",
+        "мобильныйклиент",
+        "mobileclient",
+        "мобильныйавтономныйсервер",
+        "mobilestandaloneserver",
+        "мобильноеприложениеклиент",
+        "mobileapplicationclient",
+        "мобильноеприложениесервер",
+        "mobileapplicationserver",
+        "сервермобильногоприложения",
+        "mobileapplicationserver",
+    }
+)
+_SERVICE_DIRECTIVES = frozenset(
+    {"ОБЛАСТЬ", "КОНЕЦОБЛАСТИ", "ИСПОЛЬЗОВАТЬ", "NATIVE", "STACK"}
+)
+
+
+class WorkerPreprocessorError(BslParseError):
+    pass
+
+
+@dataclass(slots=True)
+class _ConditionalFrame:
+    opening: Token
+    parent_active: bool
+    any_taken: bool
+    current_active: bool
+    else_seen: bool = False
+
+
+class _ExpressionParser:
+    def __init__(self, tokens: tuple[Token, ...]) -> None:
+        self._tokens = tokens
+        self._index = 0
+
+    def parse(self) -> bool:
+        if not self._tokens:
+            self._fail("empty preprocessor expression")
+        value = self._parse_or()
+        if self._index != len(self._tokens):
+            self._fail("unexpected token in preprocessor expression")
+        return value
+
+    def _parse_or(self) -> bool:
+        value = self._parse_and()
+        while self._accept("ИЛИ"):
+            operand = self._parse_and()
+            value = value or operand
+        return value
+
+    def _parse_and(self) -> bool:
+        value = self._parse_unary()
+        while self._accept("И"):
+            operand = self._parse_unary()
+            value = value and operand
+        return value
+
+    def _parse_unary(self) -> bool:
+        if self._accept("НЕ"):
+            return not self._parse_unary()
+        if self._accept("("):
+            value = self._parse_or()
+            if not self._accept(")"):
+                self._fail("missing closing parenthesis")
+            return value
+        if self._index >= len(self._tokens) or self._tokens[self._index].type != "ID":
+            self._fail("expected a preprocessor symbol")
+        token = self._tokens[self._index]
+        self._index += 1
+        normalized = token.text.casefold()
+        if normalized in _TRUE_SYMBOLS:
+            return True
+        if normalized in _FALSE_SYMBOLS:
+            return False
+        raise WorkerPreprocessorError(
+            f"Unknown server preprocessor symbol {token.text!r} at {token.start}",
+            span=SourceSpan(token.start, token.end),
+            code="unknown_symbol",
+        )
+
+    def _accept(self, token_type: str) -> bool:
+        if (
+            self._index < len(self._tokens)
+            and self._tokens[self._index].type == token_type
+        ):
+            self._index += 1
+            return True
+        return False
+
+    def _fail(self, message: str) -> None:
+        token = self._tokens[min(self._index, len(self._tokens) - 1)]
+        raise WorkerPreprocessorError(
+            f"{message} at {token.start}",
+            span=SourceSpan(token.start, token.end),
+            code="invalid_expression",
+        )
+
+
+def _directive_end(source: str, token: Token) -> int:
+    newline = source.find("\n", token.end)
+    return len(source) if newline < 0 else newline + 1
+
+
+def _error(token: Token, message: str, code: str) -> WorkerPreprocessorError:
+    return WorkerPreprocessorError(
+        f"{message} at {token.start}",
+        span=SourceSpan(token.start, token.end),
+        code=code,
+    )
+
+
+def _validate_service_directive(directive: tuple[Token, ...]) -> None:
+    kind = directive[1].type
+    valid = (
+        kind == "ОБЛАСТЬ"
+        and len(directive) == 3
+        and directive[2].type == "ID"
+    ) or (
+        kind == "ИСПОЛЬЗОВАТЬ"
+        and len(directive) == 3
+        and directive[2].type in {"ID", "STRING"}
+    ) or (
+        kind in {"КОНЕЦОБЛАСТИ", "NATIVE", "STACK"}
+        and len(directive) == 2
+    )
+    if not valid:
+        raise _error(
+            directive[-1],
+            f"invalid #{directive[1].text} directive",
+            "invalid_directive",
+        )
+
+
+def select_server_effective_tokens(
+    source: str,
+    tokens: tuple[Token, ...],
+) -> tuple[Token, ...]:
+    """Return original tokens belonging to the server-effective source branch."""
+    selected: list[Token] = []
+    stack: list[_ConditionalFrame] = []
+    active = True
+    index = 0
+    while index < len(tokens):
+        token = tokens[index]
+        if token.type != "#":
+            if active:
+                selected.append(token)
+            index += 1
+            continue
+
+        line_start = max(
+            source.rfind("\n", 0, token.start),
+            source.rfind("\r", 0, token.start),
+        ) + 1
+        if source[line_start : token.start].strip():
+            raise _error(token, "preprocessor directive must start its line", "invalid_directive")
+        end = _directive_end(source, token)
+        next_index = index + 1
+        while next_index < len(tokens) and tokens[next_index].start < end:
+            next_index += 1
+        directive = tokens[index:next_index]
+        index = next_index
+        if len(directive) < 2:
+            raise _error(token, "empty preprocessor directive", "invalid_directive")
+        kind = directive[1].type
+
+        if kind in _SERVICE_DIRECTIVES:
+            _validate_service_directive(directive)
+            continue
+        if kind == "ЕСЛИ":
+            if len(directive) < 4 or directive[-1].type != "ТОГДА":
+                raise _error(token, "invalid #If directive", "invalid_directive")
+            condition = _ExpressionParser(directive[2:-1]).parse()
+            frame = _ConditionalFrame(token, active, condition, active and condition)
+            stack.append(frame)
+            active = frame.current_active
+            continue
+        if kind == "ИНАЧЕЕСЛИ":
+            if not stack:
+                raise _error(token, "#ElsIf without #If", "unexpected_directive")
+            frame = stack[-1]
+            if frame.else_seen:
+                raise _error(token, "#ElsIf after #Else", "unexpected_directive")
+            if len(directive) < 4 or directive[-1].type != "ТОГДА":
+                raise _error(token, "invalid #ElsIf directive", "invalid_directive")
+            condition = _ExpressionParser(directive[2:-1]).parse()
+            frame.current_active = frame.parent_active and not frame.any_taken and condition
+            frame.any_taken = frame.any_taken or condition
+            active = frame.current_active
+            continue
+        if kind == "ИНАЧЕ":
+            if not stack:
+                raise _error(token, "#Else without #If", "unexpected_directive")
+            frame = stack[-1]
+            if frame.else_seen or len(directive) != 2:
+                raise _error(token, "invalid or repeated #Else", "unexpected_directive")
+            frame.else_seen = True
+            frame.current_active = frame.parent_active and not frame.any_taken
+            frame.any_taken = True
+            active = frame.current_active
+            continue
+        if kind == "КОНЕЦЕСЛИ":
+            if not stack:
+                raise _error(token, "#EndIf without #If", "unexpected_directive")
+            if len(directive) != 2:
+                raise _error(token, "invalid #EndIf directive", "invalid_directive")
+            frame = stack.pop()
+            active = frame.parent_active
+            continue
+        raise _error(directive[1], "unsupported preprocessor directive", "invalid_directive")
+
+    if stack:
+        raise _error(
+            stack[-1].opening,
+            "unterminated #If directive",
+            "unbalanced_directive",
+        )
+    return tuple(selected)
+
+
+__all__ = ["WorkerPreprocessorError", "select_server_effective_tokens"]

onec_runtime/bsl/worker_projection_model.py

@@ -0,0 +1,137 @@
+"""Catalog-independent public model produced by the Worker projection parser."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import IntFlag
+import re
+
+from onec_runtime.bsl.source_maps import SourceSpan
+
+
+class BareNameKind(IntFlag):
+    READ = 1
+    BARE_WRITE = 2
+
+
+def _require_name(value: str, field: str) -> None:
+    if type(value) is not str or not value:
+        raise ValueError(f"{field} must be a non-empty string")
+
+
+def _require_normalized(value: str, field: str) -> None:
+    _require_name(value, field)
+    if value != value.casefold():
+        raise ValueError(f"{field} must be casefold-normalized")
+
+
+def _require_sorted_names(values: tuple[str, ...], field: str) -> None:
+    if type(values) is not tuple:
+        raise TypeError(f"{field} must be a tuple")
+    for value in values:
+        _require_normalized(value, field)
+    if values != tuple(sorted(set(values))):
+        raise ValueError(f"{field} must contain unique sorted names")
+
+
+@dataclass(frozen=True, slots=True)
+class BareName:
+    name: str
+    normalized_name: str
+    kinds: BareNameKind
+
+    def __post_init__(self) -> None:
+        _require_name(self.name, "name")
+        _require_normalized(self.normalized_name, "normalized_name")
+        if self.normalized_name != self.name.casefold():
+            raise ValueError("normalized_name must match name")
+        if not isinstance(self.kinds, BareNameKind) or not self.kinds:
+            raise ValueError("kinds must contain at least one BareNameKind")
+        known_kinds = BareNameKind.READ | BareNameKind.BARE_WRITE
+        if int(self.kinds) & ~int(known_kinds):
+            raise ValueError("kinds contains unknown BareNameKind bits")
+
+
+@dataclass(frozen=True, slots=True)
+class ParsedMethodModel:
+    name: str
+    normalized_name: str
+    exported: bool
+    declaration_span: SourceSpan
+    alias_declaration_offset: int
+    alias_initializer_offset: int
+    declared_names: tuple[str, ...]
+    bare_names: tuple[BareName, ...]
+
+    def __post_init__(self) -> None:
+        _require_name(self.name, "name")
+        _require_normalized(self.normalized_name, "normalized_name")
+        if self.normalized_name != self.name.casefold():
+            raise ValueError("normalized_name must match name")
+        if type(self.exported) is not bool:
+            raise TypeError("exported must be bool")
+        if not isinstance(self.declaration_span, SourceSpan):
+            raise TypeError("declaration_span must be SourceSpan")
+        for field, offset in (
+            ("alias_declaration_offset", self.alias_declaration_offset),
+            ("alias_initializer_offset", self.alias_initializer_offset),
+        ):
+            if type(offset) is not int or offset < 0:
+                raise ValueError(f"{field} must be a non-negative integer")
+        if self.alias_initializer_offset < self.alias_declaration_offset:
+            raise ValueError("initializer cannot precede declarations")
+        _require_sorted_names(self.declared_names, "declared_names")
+        if type(self.bare_names) is not tuple or not all(
+            isinstance(item, BareName) for item in self.bare_names
+        ):
+            raise TypeError("bare_names must be a tuple of BareName")
+        normalized = tuple(item.normalized_name for item in self.bare_names)
+        if len(normalized) != len(set(normalized)):
+            raise ValueError("bare_names must be unique by normalized_name")
+
+
+@dataclass(frozen=True, slots=True)
+class ParsedModuleModel:
+    source_sha256: str
+    module_variables: tuple[str, ...]
+    module_bare_names: tuple[BareName, ...]
+    methods: tuple[ParsedMethodModel, ...]
+    parser_identity: tuple[str, str] = field(compare=False, repr=False)
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.source_sha256) is not str
+            or len(self.source_sha256) != 64
+            or any(character not in "0123456789abcdef" for character in self.source_sha256)
+        ):
+            raise ValueError("source_sha256 must be a lowercase hexadecimal SHA-256")
+        _require_sorted_names(self.module_variables, "module_variables")
+        if type(self.module_bare_names) is not tuple or not all(
+            isinstance(item, BareName) for item in self.module_bare_names
+        ):
+            raise TypeError("module_bare_names must be a tuple of BareName")
+        normalized = tuple(item.normalized_name for item in self.module_bare_names)
+        if len(normalized) != len(set(normalized)):
+            raise ValueError("module_bare_names must be unique by normalized_name")
+        if type(self.methods) is not tuple or not all(
+            isinstance(item, ParsedMethodModel) for item in self.methods
+        ):
+            raise TypeError("methods must be a tuple of ParsedMethodModel")
+        if (
+            type(self.parser_identity) is not tuple
+            or len(self.parser_identity) != 2
+            or any(
+                type(value) is not str
+                or re.fullmatch(r"[0-9a-f]{64}", value) is None
+                for value in self.parser_identity
+            )
+        ):
+            raise ValueError("parser_identity must contain two SHA-256 values")
+
+
+__all__ = [
+    "BareName",
+    "BareNameKind",
+    "ParsedMethodModel",
+    "ParsedModuleModel",
+]