pyre-check-nightly 0.0.101735819888__py3-none-manylinux1_x86_64.whl → 0.0.101736079117__py3-none-manylinux1_x86_64.whl

pyre_check/client/commands/code_navigation.py

@@ -1,380 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-# pyre-strict
-
-"""
-This command contains the main logic for the client connecting language servers
-and Pyre's code navigation server. It mainly ferries LSP requests back and forth between
-editors and the backend, and handles the initialization protocol and searches for appropriate
-configurations.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import traceback
-from typing import Dict, Optional
-
-from .. import (
-    backend_arguments,
-    background_tasks,
-    json_rpc,
-    log_lsp_event,
-    timer,
-    version,
-)
-from ..language_server import (
-    connections,
-    daemon_connection,
-    features,
-    protocol as lsp,
-    remote_index,
-)
-from . import (
-    daemon_querier,
-    document_formatter,
-    initialization,
-    launch_and_subscribe_handler,
-    pyre_language_server,
-    pyre_server_options,
-    server_state as state,
-    status_message_handler,
-    subscription,
-    type_error_handler,
-)
-
-LOG: logging.Logger = logging.getLogger(__name__)
-
-
-async def _read_server_response(
-    server_input_channel: connections.AsyncTextReader,
-) -> str:
-    return await server_input_channel.read_until(separator="\n")
-
-
-class PyreCodeNavigationSubscriptionResponseParser(
-    launch_and_subscribe_handler.PyreSubscriptionResponseParser
-):
-    def parse_response(self, response: str) -> subscription.Response:
-        return subscription.Response.parse_code_navigation_response(response)
-
-
-class PyreCodeNavigationDaemonLaunchAndSubscribeHandler(
-    launch_and_subscribe_handler.PyreDaemonLaunchAndSubscribeHandler
-):
-    querier: daemon_querier.AbstractDaemonQuerier
-    output_channel: connections.AsyncTextWriter
-
-    def __init__(
-        self,
-        server_options_reader: pyre_server_options.PyreServerOptionsReader,
-        server_state: state.ServerState,
-        client_status_message_handler: status_message_handler.ClientStatusMessageHandler,
-        client_type_error_handler: type_error_handler.ClientTypeErrorHandler,
-        querier: daemon_querier.AbstractDaemonQuerier,
-        output_channel: connections.AsyncTextWriter,
-        remote_logging: Optional[backend_arguments.RemoteLogging] = None,
-    ) -> None:
-        super().__init__(
-            server_options_reader,
-            server_state,
-            client_status_message_handler,
-            client_type_error_handler,
-            PyreCodeNavigationSubscriptionResponseParser(),
-            remote_logging,
-        )
-        self.querier = querier
-        self.output_channel = output_channel
-
-    async def write_telemetry(
-        self,
-        parameters: Dict[str, object],
-    ) -> None:
-        should_write_telemetry = self.server_state.server_options.language_server_features.telemetry.is_enabled()
-        if should_write_telemetry:
-            parameters = dict(parameters)
-            parameters["project_identifier"] = (
-                self.server_state.server_options.project_identifier
-            )
-            parameters["enabled_features"] = {
-                "type_errors_enabled": self.server_state.server_options.language_server_features.type_errors.is_enabled()
-            }
-            await lsp.write_json_rpc_ignore_connection_error(
-                self.output_channel,
-                json_rpc.Request(
-                    activity_key=None,
-                    method="telemetry/event",
-                    parameters=json_rpc.ByNameParameters(parameters),
-                ),
-            )
-
-    def get_type_errors_availability(self) -> features.TypeErrorsAvailability:
-        return self.server_state.server_options.language_server_features.type_errors
-
-    async def handle_type_error_event(
-        self, type_error_subscription: subscription.TypeErrors
-    ) -> None:
-        # We currently do not broadcast any type errors on the CodeNav server - the intent is to be
-        # as lazy as possible and only provide actionable information to users. The error is intended
-        # to demonstrate that contract.
-        raise RuntimeError(
-            "The Pyre code navigation server is not expected to broadcast type errors at the moment."
-        )
-
-    async def handle_status_update_event(
-        self, status_update_subscription: subscription.StatusUpdate
-    ) -> None:
-        flavor_simple_name = self.server_state.server_options.flavor.simple_name()
-        if not self.get_type_errors_availability().is_disabled():
-            await self.client_type_error_handler.clear_type_errors_for_client()
-        if status_update_subscription.kind == "Stop":
-            self.server_state.status_tracker.set_status(
-                state.ConnectionStatus.DISCONNECTED
-            )
-            await self.client_status_message_handler.log_and_show_status_message_to_client(
-                "The Pyre code-navigation server has stopped.",
-                short_message=f"{flavor_simple_name} (stopped)",
-                level=lsp.MessageType.WARNING,
-            )
-            raise launch_and_subscribe_handler.PyreDaemonShutdown(
-                status_update_subscription.message or ""
-            )
-        elif status_update_subscription.kind == "BusyBuilding":
-            self.server_state.status_tracker.set_status(
-                state.ConnectionStatus.BUCK_BUILDING
-            )
-            await self.client_status_message_handler.log_and_show_status_message_to_client(
-                "The Pyre code-navigation server is busy re-building the project...",
-                short_message=f"{flavor_simple_name} (building)",
-                level=lsp.MessageType.WARNING,
-            )
-        elif status_update_subscription.kind == "BusyChecking":
-            self.server_state.status_tracker.set_status(
-                state.ConnectionStatus.INCREMENTAL_CHECK
-            )
-            await self.client_status_message_handler.log_and_show_status_message_to_client(
-                "The Pyre code-navigation server is busy re-type-checking the project...",
-                short_message=f"{flavor_simple_name} (checking)",
-                level=lsp.MessageType.WARNING,
-            )
-        elif status_update_subscription.kind == "Idle":
-            self.server_state.status_tracker.set_status(state.ConnectionStatus.READY)
-            await self.client_status_message_handler.log_and_show_status_message_to_client(
-                "Pyre's code navigation server has completed an incremental check and is currently watching on further source changes.",
-                short_message=f"{flavor_simple_name} Ready",
-                level=lsp.MessageType.INFO,
-            )
-
-    async def _subscribe(
-        self,
-        server_input_channel: connections.AsyncTextReader,
-        server_output_channel: connections.AsyncTextWriter,
-    ) -> None:
-        subscription_name = "code_navigation"
-        await server_output_channel.write('["Subscription", ["Subscribe"]]\n')
-        first_response = await _read_server_response(server_input_channel)
-        if json.loads(first_response) != ["Ok"]:
-            raise ValueError(
-                f"Unexpected server response to Subscription: {first_response!r}"
-            )
-        await self._run_subscription_loop(
-            subscription_name,
-            server_input_channel,
-            server_output_channel,
-        )
-
-    async def client_setup(self) -> None:
-        register_client_request = await self.querier.handle_register_client()
-        if isinstance(
-            register_client_request, daemon_connection.DaemonConnectionFailure
-        ):
-            error_message = (
-                f"error occurred in client_setup request: {register_client_request}"
-            )
-            LOG.warning(f"Failed to register daemon querier: {register_client_request}")
-        else:
-            error_message = None
-            LOG.info("Registered daemon querier.")
-        await self.write_telemetry(
-            {
-                "type": "LSP",
-                "operation": "clientSetup",
-                "error_message": error_message,
-                **self.server_state.status_tracker.get_status().as_telemetry_dict(),
-            }
-        )
-
-        results = await asyncio.gather(
-            *[
-                self.querier.handle_file_opened(path, document.code)
-                for path, document in self.server_state.opened_documents.items()
-            ]
-        )
-        if len(results) > 0:
-            LOG.info(f"Sent {len(results)} open messages to daemon for existing state.")
-
-    async def client_teardown(self) -> None:
-        dispose_client_request = await self.querier.handle_dispose_client()
-        if isinstance(
-            dispose_client_request, daemon_connection.DaemonConnectionFailure
-        ):
-            error_message = (
-                f"error occurred in client_teardown request: {dispose_client_request}"
-            )
-            LOG.warning(
-                f"Failed to dispose of daemon querier: {dispose_client_request}"
-            )
-        else:
-            error_message = None
-            LOG.info("Disposed daemon querier.")
-        await self.write_telemetry(
-            {
-                "type": "LSP",
-                "operation": "clientSetup",
-                "error_message": error_message,
-                **self.server_state.status_tracker.get_status().as_telemetry_dict(),
-            }
-        )
-
-
-def process_initialize_request(
-    parameters: lsp.InitializeParameters,
-    language_server_features: Optional[features.LanguageServerFeatures] = None,
-) -> lsp.InitializeResult:
-    LOG.info(
-        f"Received initialization request from {parameters.client_info} "
-        f" (pid = {parameters.process_id})"
-    )
-    if language_server_features is None:
-        language_server_features = features.LanguageServerFeatures()
-    server_info = lsp.Info(name="pyre-codenav", version=version.__version__)
-    server_capabilities = lsp.ServerCapabilities(
-        text_document_sync=lsp.TextDocumentSyncOptions(
-            open_close=True,
-            change=lsp.TextDocumentSyncKind.FULL,
-            save=lsp.SaveOptions(include_text=False),
-        ),
-        **language_server_features.capabilities(),
-    )
-    return lsp.InitializeResult(
-        capabilities=server_capabilities, server_info=server_info
-    )
-
-
-async def async_run_code_navigation_client(
-    server_options_reader: pyre_server_options.PyreServerOptionsReader,
-    remote_logging: Optional[backend_arguments.RemoteLogging],
-    index: remote_index.AbstractRemoteIndex,
-    document_formatter: Optional[document_formatter.AbstractDocumentFormatter],
-) -> int:
-    initial_server_options = pyre_server_options.read_server_options(
-        server_options_reader, remote_logging
-    )
-    stdin, stdout = await connections.create_async_stdin_stdout()
-    LOG.info("Waiting on LSP initialization request")
-    initialize_result = await initialization.async_try_initialize_loop(
-        stdin,
-        stdout,
-        remote_logging,
-        compute_initialize_result=lambda parameters: process_initialize_request(
-            parameters, initial_server_options.language_server_features
-        ),
-    )
-    if isinstance(initialize_result, initialization.InitializationExit):
-        return 0
-    client_info = initialize_result.client_info
-    log_lsp_event.log(
-        remote_logging=remote_logging,
-        event=log_lsp_event.LSPEvent.INITIALIZED,
-        normals=(
-            {}
-            if client_info is None
-            else {
-                "lsp client name": client_info.name,
-                "lsp client version": client_info.version,
-            }
-        ),
-    )
-
-    client_capabilities = initialize_result.client_capabilities
-    LOG.debug(f"Client capabilities: {client_capabilities}")
-    server_state = state.ServerState(
-        client_capabilities=client_capabilities,
-        server_options=initial_server_options,
-        client_register_event=asyncio.Event(),
-    )
-
-    codenav_querier = daemon_querier.CodeNavigationDaemonQuerier(
-        server_state=server_state
-    )
-
-    index_querier = daemon_querier.RemoteIndexBackedQuerier(
-        server_state.status_tracker, codenav_querier, index
-    )
-    client_type_error_handler = type_error_handler.ClientTypeErrorHandler(
-        stdout, server_state, remote_logging
-    )
-    server = pyre_language_server.PyreLanguageServerDispatcher(
-        input_channel=stdin,
-        output_channel=stdout,
-        server_state=server_state,
-        daemon_manager=background_tasks.TaskManager(
-            PyreCodeNavigationDaemonLaunchAndSubscribeHandler(
-                server_options_reader=server_options_reader,
-                remote_logging=remote_logging,
-                server_state=server_state,
-                client_status_message_handler=status_message_handler.ClientStatusMessageHandler(
-                    stdout, server_state
-                ),
-                querier=codenav_querier,
-                client_type_error_handler=client_type_error_handler,
-                output_channel=stdout,
-            )
-        ),
-        api=pyre_language_server.PyreLanguageServer(
-            output_channel=stdout,
-            server_state=server_state,
-            querier=codenav_querier,
-            index_querier=index_querier,
-            document_formatter=document_formatter,
-            client_type_error_handler=client_type_error_handler,
-        ),
-    )
-    return await server.run()
-
-
-def run(
-    server_options_reader: pyre_server_options.PyreServerOptionsReader,
-    remote_logging: Optional[backend_arguments.RemoteLogging],
-    index: remote_index.AbstractRemoteIndex,
-    document_formatter: Optional[document_formatter.AbstractDocumentFormatter],
-) -> int:
-    command_timer = timer.Timer()
-    error_message: Optional[str] = None
-    try:
-        return asyncio.run(
-            async_run_code_navigation_client(
-                server_options_reader,
-                remote_logging,
-                index,
-                document_formatter,
-            )
-        )
-    except Exception:
-        error_message = traceback.format_exc()
-        LOG.exception("Uncaught error in code_navigation.run")
-        return 1
-    finally:
-        log_lsp_event.log(
-            remote_logging,
-            log_lsp_event.LSPEvent.STOPPED,
-            integers={"duration": int(command_timer.stop_in_millisecond())},
-            normals={
-                **({"exception": error_message} if error_message is not None else {})
-            },
-        )

pyre_check/client/commands/document_formatter.py

@@ -1,23 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-# pyre-strict
-
-import abc
-from pathlib import Path
-
-from ..language_server import protocol as lsp
-
-
-class AbstractDocumentFormatter(abc.ABC):
-    @abc.abstractmethod
-    def __init__(self) -> None:
-        pass
-
-    @abc.abstractmethod
-    async def format_document(
-        self, document_path: Path
-    ) -> lsp.DocumentFormattingResponse:
-        raise NotImplementedError("Document formatting not yet implemented")

pyre_check/client/commands/find_symbols.py

@@ -1,154 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-# pyre-strict
-
-"""
-This module contains logic for a Python-based implementation of
-gathering document symbols for a language server. We traverse the
-output of `ast.parse` to do this.
-"""
-
-import ast
-import dataclasses
-from typing import List, Optional, Union
-
-from ..language_server.protocol import (
-    DocumentSymbol,
-    LspRange,
-    PyrePosition,
-    SymbolKind,
-)
-
-
-@dataclasses.dataclass(frozen=True)
-class SymbolInfo:
-    name: str
-    start_pos: PyrePosition
-    end_pos: PyrePosition
-    kind: SymbolKind
-
-
-def _node_to_symbol(
-    node: Union[ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef],
-) -> DocumentSymbol:
-    node_is_class_def = isinstance(node, ast.ClassDef)
-    symbol_info = SymbolKind.CLASS if node_is_class_def else SymbolKind.FUNCTION
-
-    visitor = _SymbolsCollector()
-    visitor.generic_visit(node)
-    symbol_info = _generate_lsp_symbol_info(node, node.name, symbol_info)
-    document_symbols_response = _create_document_symbols_response(
-        symbol_info, visitor.symbols
-    )
-    return document_symbols_response
-
-
-def _create_document_symbols_response(
-    symbol_info: SymbolInfo,
-    children_symbols: Optional[List[DocumentSymbol]] = None,
-) -> DocumentSymbol:
-    if children_symbols is None:
-        children_symbols = []
-    return DocumentSymbol(
-        name=symbol_info.name,
-        # TODO(114362484): add docstrings to details
-        detail="",
-        kind=symbol_info.kind,
-        range=LspRange(
-            start=symbol_info.start_pos.to_lsp_position(),
-            end=symbol_info.end_pos.to_lsp_position(),
-        ),
-        selection_range=LspRange(
-            start=symbol_info.start_pos.to_lsp_position(),
-            end=symbol_info.end_pos.to_lsp_position(),
-        ),
-        children=children_symbols,
-    )
-
-
-def _generate_lsp_symbol_info(node: ast.AST, name: str, kind: SymbolKind) -> SymbolInfo:
-    # pyre-fixme[16]: `AST` has no attribute `lineno`.
-    # pyre-fixme[16]: `AST` has no attribute `col_offset`.
-    start = PyrePosition(line=node.lineno, character=node.col_offset)
-    # pyre-fixme[16]: `AST` has no attribute `end_lineno`.
-    # pyre-fixme[16]: `AST` has no attribute `end_col_offset`.
-    end_lineno, end_col_offset = (node.end_lineno, node.end_col_offset)
-    # Degrade gracefully on nodes that don't have end position information
-    if end_lineno is not None and end_col_offset is not None:
-        end = PyrePosition(line=end_lineno, character=end_col_offset)
-    else:
-        end = PyrePosition(line=node.lineno, character=node.col_offset + len(name))
-    return SymbolInfo(name, start, end, kind)
-
-
-class _SymbolsCollector(ast.NodeVisitor):
-    symbols: List[DocumentSymbol]
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.symbols = []
-
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
-        self.symbols.append(_node_to_symbol(node))
-
-    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
-        self.symbols.append(_node_to_symbol(node))
-
-    def visit_ClassDef(self, node: ast.ClassDef) -> None:
-        self.symbols.append(_node_to_symbol(node))
-
-    def visit_Assign(self, node: ast.Assign) -> None:
-        children_symbol_info = [
-            symbol
-            for target in node.targets
-            for symbol in self.generate_symbols_from_assignment_target(target)
-        ]
-        self.symbols.extend(
-            [
-                _create_document_symbols_response(symbol)
-                for symbol in children_symbol_info
-            ]
-        )
-
-    def generate_symbols_from_assignment_target(
-        self, target: ast.expr
-    ) -> List[SymbolInfo]:
-        if isinstance(target, ast.Name):
-            return [_generate_lsp_symbol_info(target, target.id, SymbolKind.VARIABLE)]
-        elif isinstance(target, (ast.Starred, ast.Subscript, ast.Attribute)):
-            return self.generate_symbols_from_assignment_target(target.value)
-        elif isinstance(target, (ast.Tuple, ast.List)):
-            return [
-                symbol
-                for nested_target in target.elts
-                for symbol in self.generate_symbols_from_assignment_target(
-                    nested_target
-                )
-            ]
-        else:
-            return []
-
-    def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
-        if isinstance(node.target, ast.Name):
-            symbol_info = _generate_lsp_symbol_info(
-                node.target, node.target.id, SymbolKind.VARIABLE
-            )
-            self.symbols.append(_create_document_symbols_response(symbol_info))
-
-
-class UnparseableError(Exception):
-    pass
-
-
-# TODO(114362484): 1) Support details filled with docstrings/comments 2) incremental re-parsing via tree-sitter.
-def parse_source_and_collect_symbols(source: str) -> List[DocumentSymbol]:
-    try:
-        ast_tree = ast.parse(source=source, mode="exec")
-    except Exception as e:
-        raise UnparseableError(e)
-    visitor = _SymbolsCollector()
-    visitor.visit(ast_tree)
-    return visitor.symbols

pyre_check/client/commands/pyre_language_server_error.py

@@ -1,89 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-# pyre-unsafe
-
-import enum
-from typing import Optional
-
-from .daemon_querier import DaemonQuerierSource
-
-
-class PyreLanguageServerError(str, enum.Enum):
-    # Client Errors
-    COULD_NOT_ESTABLISH_CONNECTION = "COULD_NOT_ESTABLISH_CONNECTION"
-    DAEMON_QUERY_FAILURE = "DAEMON_QUERY_FAILURE"
-    DOCUMENT_PATH_MISSING_IN_SERVER_STATE = "DOCUMENT_PATH_MISSING_IN_SERVER_STATE"
-    DOCUMENT_PATH_IS_NULL = "DOCUMENT_PATH_IS_NULL"
-    DID_NOT_FALLBACK_TO_GLEAN_AFTER_PYRE_FAILURE = (
-        "DID_NOT_FALLBACK_TO_GLEAN_AFTER_PYRE_FAILURE"
-    )
-
-    # Daemon Errors
-    CLIENT_ALREADY_REGISTERED = "CLIENT_ALREADY_REGISTERED"
-    CLIENT_NOT_REGISTERED = "CLIENT_NOT_REGISTERED"
-    FILE_NOT_OPENED = "FILE_NOT_OPENED"
-    MODULE_NOT_TRACKED = "MODULE_NOT_TRACKED"
-    GENERIC_DAEMON_QUERY_FAILURE = "GENERIC_DAEMON_QUERY_FAILURE"
-
-
-class PyreLanguageServerEmptyReason(str, enum.Enum):
-    PYRE_DAEMON_UNAVAILABLE_AND_FELLBACK_TO_GLEAN = (
-        "PYRE_DAEMON_UNAVAILABLE_AND_FELLBACK_TO_GLEAN"
-    )
-    PYRE_DAEMON_UNAVAILABLE_AND_FAILED_TO_FALLBACK_TO_GLEAN = (
-        "PYRE_DAEMON_UNAVAILABLE_AND_FAILED_TO_FALLBACK_TO_GLEAN"
-    )
-    PYRE_DAEMON_ERROR_AND_FELLBACK_TO_GLEAN = "PYRE_DAEMON_ERROR_AND_FELLBACK_TO_GLEAN"
-    PYRE_DAEMON_ERROR_AND_FAILED_TO_FALLBACK_TO_GLEAN = (
-        "PYRE_DAEMON_ERROR_AND_FAILED_TO_FALLBACK_TO_GLEAN"
-    )
-
-
-# Capturing the most common errors returned from Daemon:
-# https://fburl.com/scuba/vscode_chronicle_language_server_events/e6efk79s
-def get_language_server_error(
-    error_message: Optional[str],
-    query_source: Optional[DaemonQuerierSource],
-) -> Optional[PyreLanguageServerError]:
-    if error_message is None:
-        return None
-
-    # By default, glean should handle result if pyre has an error
-    if query_source != DaemonQuerierSource.GLEAN_INDEXER:
-        return PyreLanguageServerError.DID_NOT_FALLBACK_TO_GLEAN_AFTER_PYRE_FAILURE
-    # TOOD (T184657347): use predefined error and empty enum instead of performing a substring match
-    if "Could not establish connection" in error_message:
-        return PyreLanguageServerError.COULD_NOT_ESTABLISH_CONNECTION
-    elif "ClientAlreadyRegistered" in error_message:
-        return PyreLanguageServerError.CLIENT_ALREADY_REGISTERED
-    elif "ClientNotRegistered" in error_message:
-        return PyreLanguageServerError.CLIENT_NOT_REGISTERED
-    elif "FileNotOpened" in error_message:
-        return PyreLanguageServerError.FILE_NOT_OPENED
-    elif "ModuleNotTracked" in error_message:
-        return PyreLanguageServerError.MODULE_NOT_TRACKED
-
-
-def get_language_server_empty_reason(
-    empty_reason: Optional[object],
-    error_message: Optional[str],
-    query_source: Optional[DaemonQuerierSource],
-) -> object:
-    if empty_reason is not None:
-        return empty_reason
-
-    if error_message is not None:
-        if query_source == DaemonQuerierSource.GLEAN_INDEXER:
-            return PyreLanguageServerEmptyReason.PYRE_DAEMON_ERROR_AND_FELLBACK_TO_GLEAN
-        else:
-            return PyreLanguageServerEmptyReason.PYRE_DAEMON_ERROR_AND_FAILED_TO_FALLBACK_TO_GLEAN
-    else:
-        # We assume that Pyre daemon always returns an empty reason or error when it returns an empty response, this means that
-        # if Pyre daemon doesn't return an empty, then it means it's unavailable: https://fburl.com/code/a2ilz0iw
-        if query_source == DaemonQuerierSource.GLEAN_INDEXER:
-            return PyreLanguageServerEmptyReason.PYRE_DAEMON_UNAVAILABLE_AND_FELLBACK_TO_GLEAN
-        else:
-            return PyreLanguageServerEmptyReason.PYRE_DAEMON_UNAVAILABLE_AND_FAILED_TO_FALLBACK_TO_GLEAN