Create GeneratorContext once, in the ExtendedPythonGenerator constructor.

Change mrcWorkspaceToCode to take a Module instead of GeneratorContext.
Change mrcWorkspaceToCode to call context.setModule and this.init(workspace).

Author: lizlooney

src/App.tsx

@@ -33,7 +33,6 @@ import ToolboxSettingsModal from './reactComponents/ToolboxSettings';
 import * as Tabs from './reactComponents/Tabs';
 import { TabType } from './types/TabType';
 
-import { createGeneratorContext, GeneratorContext } from './editor/generator_context';
 import * as editor from './editor/editor';
 import { extendedPythonGenerator } from './editor/extended_python_generator';
 
@@ -172,8 +171,6 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
   const [languageInitialized, setLanguageInitialized] = React.useState(false);
   const [themeInitialized, setThemeInitialized] = React.useState(false);
 
-  const generatorContext = React.useRef<GeneratorContext | null>(null);
-
   /** modulePaths controls how BlocklyComponents are created. */
   const modulePaths = React.useRef<string[]>([]);
   const modulePathToBlocklyComponent = React.useRef<{[modulePath: string]: BlocklyComponentType}>({});
@@ -434,7 +431,6 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
   // Initialize blocks when app loads
   React.useEffect(() => {
     initializeBlocks();
-    generatorContext.current = createGeneratorContext();
   }, []);
 
   React.useEffect(() => {
@@ -443,9 +439,6 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
 
   // Update generator context and load module blocks when current module changes
   React.useEffect(() => {
-    if (generatorContext.current) {
-      generatorContext.current.setModule(currentModule);
-    }
     if (currentModule) {
       if (modulePaths.current.includes(currentModule.modulePath)) {
         activateEditor();
@@ -460,9 +453,6 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
     if (!project || !currentModule) {
       return;
     }
-    if (generatorContext.current) {
-      generatorContext.current.setModule(currentModule);
-    }
     for (const modulePath in modulePathToBlocklyComponent.current) {
       const blocklyComponent = modulePathToBlocklyComponent.current[modulePath];
       const active = (modulePath === currentModule.modulePath);
@@ -485,7 +475,7 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
   };
 
   const setupWorkspace = (modulePath: string, newWorkspace: Blockly.WorkspaceSvg) => {
-    if (!project || !storage || !generatorContext.current) {
+    if (!project || !storage) {
       return;
     }
     const module = storageProject.findModuleByModulePath(project, modulePath);
@@ -506,7 +496,7 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
     }
 
     const newEditor = new editor.Editor(
-        newWorkspace, module, project, generatorContext.current, storage, modulePathToContentText);
+        newWorkspace, module, project, storage, modulePathToContentText);
     modulePathToEditor.current[modulePath] = newEditor;
     newEditor.loadModuleBlocks();
     newEditor.updateToolbox(shownPythonToolboxCategories);
@@ -519,11 +509,11 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
   // Generate code when module or regeneration trigger changes
   React.useEffect(() => {
     let generatedCode = '';
-    if (currentModule && generatorContext.current) {
+    if (currentModule) {
       if (currentModule.modulePath in modulePathToBlocklyComponent.current) {
         const blocklyComponent = modulePathToBlocklyComponent.current[currentModule.modulePath];
         generatedCode = extendedPythonGenerator.mrcWorkspaceToCode(
-            blocklyComponent.getBlocklyWorkspace(), generatorContext.current);
+            blocklyComponent.getBlocklyWorkspace(), currentModule);
       }
     }
     setGeneratedCode(generatedCode);

src/editor/editor.ts

@@ -22,7 +22,6 @@
 import * as Blockly from 'blockly/core';
 
 import { extendedPythonGenerator } from './extended_python_generator';
-import { GeneratorContext } from './generator_context';
 import * as commonStorage from '../storage/common_storage';
 import * as storageModule from '../storage/module';
 import * as storageModuleContent from '../storage/module_content';
@@ -46,7 +45,6 @@ export class Editor {
   private readonly blocklyWorkspace: Blockly.WorkspaceSvg;
   private readonly module: storageModule.Module;
   private readonly projectName: string;
-  private readonly generatorContext: GeneratorContext;
   private readonly storage: commonStorage.Storage;
   private readonly modulePath: string;
   private readonly robotPath: string;
@@ -63,13 +61,11 @@ export class Editor {
       blocklyWorkspace: Blockly.WorkspaceSvg,
       module: storageModule.Module,
       project: storageProject.Project,
-      generatorContext: GeneratorContext,
       storage: commonStorage.Storage,
       modulePathToContentText: {[modulePath: string]: string}) {
     this.blocklyWorkspace = blocklyWorkspace;
     this.module = module;
     this.projectName = project.projectName;
-    this.generatorContext = generatorContext;
     this.storage = storage;
     this.modulePath = module.modulePath;
     this.robotPath = project.robot.modulePath;
@@ -228,9 +224,7 @@ export class Editor {
     }
 
     // Generate python because some parts of components, events, and methods are affected.
-    this.generatorContext.setModule(this.module);
-    extendedPythonGenerator.init(this.blocklyWorkspace);
-    extendedPythonGenerator.mrcWorkspaceToCode(this.blocklyWorkspace, this.generatorContext);
+    extendedPythonGenerator.mrcWorkspaceToCode(this.blocklyWorkspace, this.module);
 
     const blocks = Blockly.serialization.workspaces.save(this.blocklyWorkspace);
     const mechanisms: storageModuleContent.MechanismInRobot[] = this.getMechanismsFromWorkspace();

src/editor/extended_python_generator.ts

@@ -21,7 +21,7 @@
 
 import * as Blockly from 'blockly/core';
 import { PythonGenerator } from 'blockly/python';
-import { GeneratorContext } from './generator_context';
+import { createGeneratorContext, GeneratorContext } from './generator_context';
 import * as mechanismContainerHolder from '../blocks/mrc_mechanism_component_holder';
 import * as eventHandler from '../blocks/mrc_event_handler';
 import {
@@ -69,7 +69,7 @@ export class OpModeDetails {
 
 export class ExtendedPythonGenerator extends PythonGenerator {
   private workspace: Blockly.Workspace | null = null;
-  private context: GeneratorContext | null = null;
+  private readonly context: GeneratorContext;
 
   // Fields related to generating the __init__ for a mechanism.
   private hasAnyComponents = false;
@@ -85,6 +85,7 @@ export class ExtendedPythonGenerator extends PythonGenerator {
 
   constructor() {
     super('Python');
+    this.context = createGeneratorContext();
   }
 
   init(workspace: Blockly.Workspace){
@@ -128,22 +129,24 @@ export class ExtendedPythonGenerator extends PythonGenerator {
     return "self." + varName;
   }
 
-  mrcWorkspaceToCode(workspace: Blockly.Workspace, context: GeneratorContext): string {
+  mrcWorkspaceToCode(workspace: Blockly.Workspace, module: storageModule.Module): string {
     this.workspace = workspace;
-    this.context = context;
+
+    this.context.setModule(module);
+    this.init(workspace);
 
     this.hasAnyComponents = false;
     this.componentPorts = Object.create(null);
     if (this.getModuleType() ===  storageModule.ModuleType.MECHANISM) {
-      this.hasAnyComponents = mechanismContainerHolder.hasAnyComponents(this.workspace);
-      mechanismContainerHolder.getComponentPorts(this.workspace, this.componentPorts);
+      this.hasAnyComponents = mechanismContainerHolder.hasAnyComponents(workspace);
+      mechanismContainerHolder.getComponentPorts(workspace, this.componentPorts);
     }
-    this.hasAnyEventHandlers = eventHandler.getHasAnyEnabledEventHandlers(this.workspace);
+    this.hasAnyEventHandlers = eventHandler.getHasAnyEnabledEventHandlers(workspace);
 
     const code = super.workspaceToCode(workspace);
 
-    this.workspace = workspace;
-    this.context = null;
+    this.context.setModule(null);
+    this.workspace = null;
     return code;
   }
 
@@ -192,7 +195,7 @@ export class ExtendedPythonGenerator extends PythonGenerator {
   }
 
   finish(code: string): string {
-    if (this.context && this.workspace) {
+    if (this.workspace) {
       const className = this.context.getClassName();
       const baseClassName = this.context.getBaseClassName();
       const decorations = this.details?.decorations(className);

src/storage/create_python_files.ts

@@ -29,7 +29,6 @@ import { parseModuleContentText } from './module_content';
 import { Project } from './project';
 import { pascalCaseToSnakeCase } from './names';
 import JSZip from 'jszip';
-import { GeneratorContext } from '../editor/generator_context';
 
 /** Result of Python code generation for a single module */
 interface ModulePythonResult {
@@ -66,18 +65,10 @@ async function generatePythonForModule(module: Module, storage: Storage): Promis
 
     // Parse and load the JSON into the workspace
     const blocks = moduleContent.getBlocks();
-
     Blockly.serialization.workspaces.load(blocks, workspace);
 
-    // Create and set up generator context like the editor does
-    const generatorContext = new GeneratorContext();
-    generatorContext.setModule(module);
-
-    // Initialize the generator
-    extendedPythonGenerator.init(workspace);
-
-    // Generate Python code using the same method as the editor
-    const pythonCode = extendedPythonGenerator.mrcWorkspaceToCode(workspace, generatorContext);
+    // Generate Python code.
+    const pythonCode = extendedPythonGenerator.mrcWorkspaceToCode(workspace, module);
 
     // Clean up the workspace
     workspace.dispose();