Merged PR posit-dev/positron-python#259: Use "smart send" for Cmd+Enter statement range detection

Merge pull request #259 from posit-dev/smart-send

Use "smart send" for Cmd+Enter statement range detection
--------------------
Commit message for posit-dev/positron-python@8a7f634:

fix merge issues

--------------------
Commit message for posit-dev/positron-python@a6ead38:

Merge remote-tracking branch 'origin/main' into smart-send

--------------------
Commit message for posit-dev/positron-python@96f3ed2:

fix excluding closing token

Addresses #1811.

--------------------
Commit message for posit-dev/positron-python@7872ce0:

use smart send feature in positron statement range provider


Authored-by: Wasim Lorgat <[email protected]>
Signed-off-by: Wasim Lorgat <[email protected]>

Author: seeM

extensions/positron-python/pythonFiles/normalizeSelection.py

@@ -181,9 +181,7 @@ def traverse_file(wholeFileContent, start_line, end_line, was_highlighted):
             ast.IfExp,
             ast.ExceptHandler,
         )
-        if isinstance(node, ast_types_with_nodebody) and isinstance(
-            node.body, Iterable
-        ):
+        if isinstance(node, ast_types_with_nodebody) and isinstance(node.body, Iterable):
             for child_nodes in node.body:
                 top_level_nodes.append(child_nodes)
 
@@ -194,13 +192,18 @@ def traverse_file(wholeFileContent, start_line, end_line, was_highlighted):
         which_line_next = 0
         for same_line_node in exact_nodes:
             should_run_top_blocks.append(same_line_node)
-            smart_code += (
-                f"{ast.get_source_segment(wholeFileContent, same_line_node)}\n"
-            )
+            smart_code += f"{ast.get_source_segment(wholeFileContent, same_line_node)}\n"
             which_line_next = get_next_block_lineno(should_run_top_blocks)
         return {
             "normalized_smart_result": smart_code,
             "which_line_next": which_line_next,
+            # --- Start Positron ---
+            # Return additional info required by a Positron statement range provider.
+            "start_line": should_run_top_blocks[0].lineno,
+            "start_character": should_run_top_blocks[0].col_offset,
+            "end_line": should_run_top_blocks[-1].end_lineno,
+            "end_character": should_run_top_blocks[-1].end_col_offset,
+            # --- End Positron ---
         }
 
     # For each of the nodes in the parsed file content,
@@ -228,11 +231,28 @@ def traverse_file(wholeFileContent, start_line, end_line, was_highlighted):
             smart_code += str(ast.get_source_segment(wholeFileContent, top_node))
             smart_code += "\n"
 
+    # --- Start Positron ---
+    # If we get here, we may still be between top-level nodes -- try to find the next one.
+    if not should_run_top_blocks:
+        for node in top_level_nodes:
+            if node.lineno > start_line:
+                should_run_top_blocks.append(node)
+                smart_code += f"{ast.get_source_segment(wholeFileContent, top_node)}\n"
+                break
+    # --- End Positron ---
+
     normalized_smart_result = normalize_lines(smart_code)
     which_line_next = get_next_block_lineno(should_run_top_blocks)
     return {
         "normalized_smart_result": normalized_smart_result,
         "which_line_next": which_line_next,
+        # --- Start Positron ---
+        # Return additional info required by a Positron statement range provider.
+        "start_line": should_run_top_blocks[0].lineno,
+        "start_character": should_run_top_blocks[0].col_offset,
+        "end_line": should_run_top_blocks[-1].end_lineno,
+        "end_character": should_run_top_blocks[-1].end_col_offset,
+        # --- End Positron ---
     }
 
 
@@ -277,7 +297,17 @@ def get_next_block_lineno(which_line_next):
         normalized = result["normalized_smart_result"]
         which_line_next = result["which_line_next"]
         data = json.dumps(
-            {"normalized": normalized, "nextBlockLineno": result["which_line_next"]}
+            # --- Start Positron ---
+            # Return additional info required by a Positron statement range provider.
+            {
+                "normalized": normalized,
+                "nextBlockLineno": result["which_line_next"],
+                "startLine": result["start_line"],
+                "endLine": result["end_line"],
+                "startCharacter": result["start_character"],
+                "endCharacter": result["end_character"],
+            }
+            # --- End Positron ---
         )
     else:
         normalized = normalize_lines(contents["code"])

extensions/positron-python/src/client/positron/extension.ts

@@ -10,7 +10,6 @@ import { IInterpreterService } from '../interpreter/contracts';
 import { IServiceContainer } from '../ioc/types';
 import { traceError, traceInfo } from '../logging';
 import { createPythonRuntime, pythonRuntimeProvider } from './provider';
-import { PythonStatementRangeProvider } from './statementRange';
 
 export async function activatePositron(
     activatedPromise: Promise<void>,
@@ -29,10 +28,6 @@ export async function activatePositron(
             pythonRuntimeProvider(serviceContainer, runtimes, activatedPromise),
         );
 
-        // Register a statement range provider to detect Python statements
-        traceInfo('activatePositron: registering python statement range provider');
-        positron.languages.registerStatementRangeProvider('python', new PythonStatementRangeProvider());
-
         // Wait for all extension components to be activated before registering event listeners
         traceInfo('activatePositron: awaiting extension activation');
         await activatedPromise;

extensions/positron-python/src/client/positron/lsp.ts

@@ -8,6 +8,7 @@ import { LanguageClient, LanguageClientOptions, State, StreamInfo } from 'vscode
 import { Socket } from 'net';
 
 import { PYTHON_LANGUAGE } from '../common/constants';
+import { IServiceContainer } from '../ioc/types';
 import { traceError, traceInfo } from '../logging';
 import { ProgressReporting } from '../activation/progress';
 import { PromiseHandles } from './util';
@@ -40,10 +41,11 @@ export class PythonLsp implements vscode.Disposable {
     private activationDisposables: vscode.Disposable[] = [];
 
     public constructor(
+        private readonly serviceContainer: IServiceContainer,
         private readonly _version: string,
         private readonly _clientOptions: LanguageClientOptions,
         private readonly _notebook: vscode.NotebookDocument | undefined,
-    ) { }
+    ) {}
 
     /**
      * Activate the language server; returns a promise that resolves when the LSP is
@@ -82,10 +84,10 @@ export class PythonLsp implements vscode.Disposable {
         this._clientOptions.documentSelector = this._notebook
             ? [{ language: 'python', pattern: this._notebook.uri.path }]
             : [
-                { language: 'python', scheme: 'untitled' },
-                { language: 'python', scheme: 'inmemory' }, // Console
-                { language: 'python', pattern: '**/*.py' },
-            ];
+                  { language: 'python', scheme: 'untitled' },
+                  { language: 'python', scheme: 'inmemory' }, // Console
+                  { language: 'python', pattern: '**/*.py' },
+              ];
 
         traceInfo(`Creating Positron Python ${this._version} language client (port ${port})...`);
         this._client = new LanguageClient(
@@ -165,20 +167,20 @@ export class PythonLsp implements vscode.Disposable {
 
         const promise = awaitStop
             ? // If the kernel hasn't exited, we can just await the promise directly
-            this._client!.stop()
+              this._client!.stop()
             : // The promise returned by `stop()` never resolves if the server
-            // side is disconnected, so rather than awaiting it when the runtime
-            // has exited, we wait for the client to change state to `stopped`,
-            // which does happen reliably.
-            new Promise<void>((resolve) => {
-                const disposable = this._client!.onDidChangeState((event) => {
-                    if (event.newState === State.Stopped) {
-                        resolve();
-                        disposable.dispose();
-                    }
-                });
-                this._client!.stop();
-            });
+              // side is disconnected, so rather than awaiting it when the runtime
+              // has exited, we wait for the client to change state to `stopped`,
+              // which does happen reliably.
+              new Promise<void>((resolve) => {
+                  const disposable = this._client!.onDidChangeState((event) => {
+                      if (event.newState === State.Stopped) {
+                          resolve();
+                          disposable.dispose();
+                      }
+                  });
+                  this._client!.stop();
+              });
 
         // Don't wait more than a couple of seconds for the client to stop.
         const timeout = new Promise<void>((_, reject) => {
@@ -208,17 +210,20 @@ export class PythonLsp implements vscode.Disposable {
      */
     private registerPositronLspExtensions(client: LanguageClient) {
         // Register a statement range provider to detect Python statements
-        const rangeDisposable = positron.languages.registerStatementRangeProvider('python',
-            new PythonStatementRangeProvider());
+        const rangeDisposable = positron.languages.registerStatementRangeProvider(
+            'python',
+            new PythonStatementRangeProvider(this.serviceContainer),
+        );
         this.activationDisposables.push(rangeDisposable);
 
         // Register a help topic provider to provide help topics for Python
-        const helpDisposable = positron.languages.registerHelpTopicProvider('python',
-            new PythonHelpTopicProvider(client));
+        const helpDisposable = positron.languages.registerHelpTopicProvider(
+            'python',
+            new PythonHelpTopicProvider(client),
+        );
         this.activationDisposables.push(helpDisposable);
     }
 
-
     /**
      * Dispose of the client instance.
      */

extensions/positron-python/src/client/positron/provider.ts

@@ -238,7 +238,16 @@ export async function createPythonRuntime(
 
     // Create an adapter for the kernel to fulfill the LanguageRuntime interface.
     traceInfo(`createPythonRuntime: creating PythonRuntime`);
-    return new PythonRuntime(kernelSpec, metadata, dynState, languageClientOptions, interpreter, installer, extra);
+    return new PythonRuntime(
+        serviceContainer,
+        kernelSpec,
+        metadata,
+        dynState,
+        languageClientOptions,
+        interpreter,
+        installer,
+        extra,
+    );
 }
 
 // Returns a sorted copy of the array of Python environments, in descending order

extensions/positron-python/src/client/positron/runtime.ts

@@ -12,7 +12,8 @@ import { cloneDeep } from 'lodash';
 import PQueue from 'p-queue';
 import { LanguageClientOptions } from 'vscode-languageclient/node';
 import { InstallOptions } from '../common/installer/types';
-import { IInstaller, Product, InstallerResponse } from '../common/types';
+import { IInstaller, InstallerResponse, Product } from '../common/types';
+import { IServiceContainer } from '../ioc/types';
 import { JupyterAdapterApi, JupyterKernelSpec, JupyterLanguageRuntime, JupyterKernelExtra } from '../jupyter-adapter.d';
 import { traceInfo } from '../logging';
 import { PythonEnvironment } from '../pythonEnvironments/info';
@@ -45,6 +46,7 @@ export class PythonRuntime implements positron.LanguageRuntime, vscode.Disposabl
     private adapterApi?: JupyterAdapterApi;
 
     constructor(
+        private readonly serviceContainer: IServiceContainer,
         readonly kernelSpec: JupyterKernelSpec,
         readonly metadata: positron.LanguageRuntimeMetadata,
         readonly dynState: positron.LanguageRuntimeDynState,
@@ -54,7 +56,7 @@ export class PythonRuntime implements positron.LanguageRuntime, vscode.Disposabl
         readonly extra?: JupyterKernelExtra,
         readonly notebook?: vscode.NotebookDocument,
     ) {
-        this._lsp = new PythonLsp(metadata.languageVersion, languageClientOptions, notebook);
+        this._lsp = new PythonLsp(serviceContainer, metadata.languageVersion, languageClientOptions, notebook);
         this._queue = new PQueue({ concurrency: 1 });
         this.onDidReceiveRuntimeMessage = this._messageEmitter.event;
         this.onDidChangeRuntimeState = this._stateEmitter.event;
@@ -285,6 +287,7 @@ export class PythonRuntime implements positron.LanguageRuntime, vscode.Disposabl
     clone(metadata: positron.LanguageRuntimeMetadata, notebook: vscode.NotebookDocument): positron.LanguageRuntime {
         const kernelSpec: JupyterKernelSpec = { ...this.kernelSpec, display_name: metadata.runtimeName };
         return new PythonRuntime(
+            this.serviceContainer,
             kernelSpec,
             metadata,
             { ...this.dynState },