@marimo-team/islands 0.23.12-dev9 → 0.23.12

package/src/core/codemirror/reactive-references/__tests__/analyzer.test.ts

@@ -640,6 +640,60 @@ def run(polars):
     `);
   });
 
+  test("set comprehension target shadows outer global", () => {
+    // Regression: SCOPE_CREATING_NODES used "SetComprehension" instead of the
+    // grammar's "SetComprehensionExpression", so set comprehensions never
+    // created a scope and their for-target was treated as reactive.
+    expect(runHighlight(["x"], "result = {x for x in range(5)}"))
+      .toMatchInlineSnapshot(`
+      "
+      result = {x for x in range(5)}
+      "
+    `);
+  });
+
+  test("from-import module path stays reactive", () => {
+    // Regression: ImportStatement collected every VariableName child, so the
+    // module name in `from m import y` was wrongly treated as a local binding.
+    expect(
+      runHighlight(
+        ["math"],
+        `
+def f():
+    from math import sin as my_sin
+    return math + my_sin(1)`,
+      ),
+    ).toMatchInlineSnapshot(`
+      "
+      def f():
+          from math import sin as my_sin
+          return math + my_sin(1)
+                 ^^^^
+      "
+    `);
+  });
+
+  test("from-import: aliased imported name is not a binding", () => {
+    // Regression: `sin` in `from math import sin as my_sin` was incorrectly
+    // registered as a local binding, hiding genuine reactive uses of `sin`.
+    expect(
+      runHighlight(
+        ["sin"],
+        `
+def f():
+    from math import sin as my_sin
+    return sin + my_sin(1)`,
+      ),
+    ).toMatchInlineSnapshot(`
+      "
+      def f():
+          from math import sin as my_sin
+          return sin + my_sin(1)
+                 ^^^
+      "
+    `);
+  });
+
   test("lambda inside function with outer global", () => {
     expect(
       runHighlight(

package/src/core/codemirror/reactive-references/analyzer.ts

@@ -16,7 +16,7 @@ const SCOPE_CREATING_NODES = new Set([
   "FunctionDefinition",
   "LambdaExpression",
   "ArrayComprehensionExpression",
-  "SetComprehension",
+  "SetComprehensionExpression",
   "DictionaryComprehensionExpression",
   "ComprehensionExpression",
   "ClassDefinition",
@@ -152,7 +152,7 @@ export function findReactiveVariables(options: {
       }
       case "ArrayComprehensionExpression":
       case "DictionaryComprehensionExpression":
-      case "SetComprehension":
+      case "SetComprehensionExpression":
       case "ComprehensionExpression": {
         // Domprehension variables - look for VariableName or TupleExpression after 'for'
         const subCursor = node.cursor();
@@ -276,49 +276,52 @@ export function findReactiveVariables(options: {
         break;
       }
       case "ImportStatement": {
-        // Handle import x
+        // The grammar emits a single ImportStatement for both `import x [as y]`
+        // and `from m import x [as y], ...`. Direct children mix keywords,
+        // module-path names (before `import`), imported names, and aliases.
+        // Only post-`import` names that aren't shadowed by a following `as`
+        // (and the alias itself when `as` is present) bind in the current
+        // scope.
         const subCursor = node.cursor();
         subCursor.firstChild();
-        do {
-          if (subCursor.name === "VariableName") {
-            const varName = options.state.doc.sliceString(
-              subCursor.from,
-              subCursor.to,
-            );
-
-            const currentScope =
-              currentScopeStack[currentScopeStack.length - 1] ?? -1;
-            if (!allDeclarations.has(currentScope)) {
-              allDeclarations.set(currentScope, new Set());
-            }
-            allDeclarations.get(currentScope)?.add(varName);
+        const currentScope =
+          currentScopeStack[currentScopeStack.length - 1] ?? -1;
+        if (!allDeclarations.has(currentScope)) {
+          allDeclarations.set(currentScope, new Set());
+        }
+        const scope = allDeclarations.get(currentScope);
+        let pastImport = false;
+        let pending: string | null = null;
+        const commit = () => {
+          if (pending !== null) {
+            scope?.add(pending);
           }
-        } while (subCursor.nextSibling());
-
-        break;
-      }
-      case "ImportFromStatement": {
-        // Handle from x import y as z
-        const subCursor = node.cursor();
-        subCursor.firstChild();
-        let foundImport = false;
+          pending = null;
+        };
         do {
           if (subCursor.name === "import") {
-            foundImport = true;
-          } else if (foundImport && subCursor.name === "VariableName") {
-            const varName = options.state.doc.sliceString(
+            pastImport = true;
+            continue;
+          }
+          if (!pastImport) {
+            continue;
+          }
+          if (subCursor.name === "as") {
+            // Drop the imported name; the next VariableName is the alias.
+            pending = null;
+            continue;
+          }
+          if (subCursor.name === "VariableName") {
+            commit();
+            pending = options.state.doc.sliceString(
               subCursor.from,
               subCursor.to,
             );
-            // Add to the current innermost scope
-            const currentScope =
-              currentScopeStack[currentScopeStack.length - 1] ?? -1;
-            if (!allDeclarations.has(currentScope)) {
-              allDeclarations.set(currentScope, new Set());
-            }
-            allDeclarations.get(currentScope)?.add(varName);
+          } else if (subCursor.name === ",") {
+            commit();
           }
         } while (subCursor.nextSibling());
+        commit();
 
         break;
       }
@@ -424,6 +427,12 @@ export function findReactiveVariables(options: {
     const nodeName = cursor.name;
     const nodeStart = cursor.from;
 
+    // Names inside an import statement are module paths, imported names, or
+    // aliases — none of them are reactive *uses* of an outer-cell global.
+    if (nodeName === "ImportStatement") {
+      return;
+    }
+
     const isNewScope = SCOPE_CREATING_NODES.has(nodeName);
 
     let currentScopeStack = scopeStack;

package/src/core/islands/__tests__/bridge.test.ts

@@ -12,6 +12,7 @@ import {
 type Base64String = components["schemas"]["Base64String"];
 interface TestIslandApp {
   id: string;
+  payloadBacked?: boolean;
   cells: { code: string; idx: number; output: string }[];
 }
 interface TestExportContext {
@@ -142,6 +143,30 @@ describe("IslandsPyodideBridge", () => {
       });
     });
 
+    it("should ignore trusted export notebook code for a payload-backed app", async () => {
+      const payloadApp = {
+        id: "app-1",
+        payloadBacked: true,
+        cells: [{ code: "x = 1", idx: 0, output: "<div>1</div>" }],
+      };
+      mockParseMarimoIslandApps.mockReturnValue([payloadApp]);
+      mockGetMarimoExportContext.mockReturnValue({
+        trusted: true,
+        notebookCode: "full notebook should be ignored",
+      });
+      mockCreateMarimoFile.mockReturnValue("generated payload app");
+
+      await (
+        bridge as unknown as { startSessionsForAllApps(): Promise<void> }
+      ).startSessionsForAllApps();
+
+      expect(mockCreateMarimoFile).toHaveBeenCalledWith(payloadApp);
+      expect(mockStartSessionRequest).toHaveBeenCalledWith({
+        appId: "app-1",
+        code: "generated payload app",
+      });
+    });
+
     it("should keep synthesized per-app files for multiple reactive apps even when export context exists", async () => {
       mockParseMarimoIslandApps.mockReturnValue([
         {