Added support for calling component methods to the mrc_call_python_function block.

Handle case where a component name collides with a variable name.
Added getComponentNames method to the editor class so the mrc_call_python_function blocks can populate the component name dropdown fields.
Added robot parameter to OpMode init method.
Modified mrc_class_method_def so it generates the call to super().__init__() for __init__ methods.
Save the component names and types in the files.
Added blocks to component_samples_category.ts.

Author: lizlooney

src/blocks/mrc_call_python_function.ts

@@ -24,11 +24,13 @@ import * as Blockly from 'blockly';
 import { Order } from 'blockly/python';
 
 import * as pythonUtils from './utils/generated/python';
+import { createFieldDropdown } from '../fields/FieldDropdown';
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
 import { getAllowedTypesForSetCheck, getOutputCheck } from './utils/python';
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
 import { MRC_STYLE_FUNCTIONS } from '../themes/styles'
 import { ClassMethodDefExtraState } from './mrc_class_method_def'
+import { Editor } from '../editor/editor';
 
 // A block to call a python function.
 
@@ -40,10 +42,13 @@ enum FunctionKind {
   CONSTRUCTOR = 'constructor',
   INSTANCE = 'instance',
   INSTANCE_WITHIN = 'instance_within',
+  INSTANCE_COMPONENT = 'instance_component'
 }
 
 const RETURN_TYPE_NONE = 'None';
 
+const FIELD_COMPONENT_NAME = 'COMPONENT_NAME';
+
 export type FunctionArg = {
   name: string,
   type: string,
@@ -58,6 +63,8 @@ interface CallPythonFunctionMixin extends CallPythonFunctionMixinType {
   mrcImportModule: string,
   mrcActualFunctionName: string,
   mrcExportedFunction: boolean,
+  mrcComponentClassName: string,
+  mrcComponentName: string, // Do not access directly. Call getComponentName.
   renameMethod(this: CallPythonFunctionBlock, newName: string): void;
   mutateMethod(this: CallPythonFunctionBlock, defBlockExtraState: ClassMethodDefExtraState): void;
 }
@@ -99,6 +106,14 @@ type CallPythonFunctionExtraState = {
    * user's Project).
    */
   exportedFunction: boolean,
+  /**
+   * The component name. Specified only if the function kind is INSTANCE_COMPONENT.
+   */
+  componentName?: string,
+  /**
+   * The component class name. Specified only if the function kind is INSTANCE_COMPONENT.
+   */
+  componentClassName?: string,
 };
 
 const CALL_PYTHON_FUNCTION = {
@@ -138,6 +153,12 @@ const CALL_PYTHON_FUNCTION = {
           tooltip = 'Calls the method ' + functionName + '.';
           break;
         }
+        case FunctionKind.INSTANCE_COMPONENT: {
+          const className = this.mrcComponentClassName;
+          const functionName = this.getFieldValue(pythonUtils.FIELD_FUNCTION_NAME);
+          tooltip = 'Calls the function ' + className + '.' + functionName + '.';
+          break;
+        }
         default:
           throw new Error('mrcFunctionKind has unexpected value: ' + this.mrcFunctionKind)
       }
@@ -174,6 +195,12 @@ const CALL_PYTHON_FUNCTION = {
     if (this.mrcActualFunctionName) {
       extraState.actualFunctionName = this.mrcActualFunctionName;
     }
+    if (this.mrcComponentClassName) {
+      extraState.componentClassName = this.mrcComponentClassName;
+    }
+    if (this.getField(FIELD_COMPONENT_NAME)) {
+      extraState.componentName = this.getComponentName();
+    }
     return extraState;
   },
   /**
@@ -199,6 +226,10 @@ const CALL_PYTHON_FUNCTION = {
         ? extraState.actualFunctionName : '';
     this.mrcExportedFunction = extraState.exportedFunction
         ? extraState.exportedFunction : false;
+    this.mrcComponentClassName = extraState.componentClassName
+        ? extraState.componentClassName : '';
+    this.mrcComponentName = extraState.componentName
+        ? extraState.componentName : '';
     this.updateBlock_();
   },
   /**
@@ -260,6 +291,19 @@ const CALL_PYTHON_FUNCTION = {
           }
           break;
         }
+        case FunctionKind.INSTANCE_COMPONENT: {
+          const componentNames = Editor.getComponentNames(this.workspace, this.mrcComponentClassName);
+          const componentName = this.getComponentName();
+          if (!componentNames.includes(componentName)) {
+            componentNames.push(componentName);
+          }
+          this.appendDummyInput('TITLE')
+              .appendField('call')
+              .appendField(createFieldDropdown(componentNames), FIELD_COMPONENT_NAME)
+              .appendField('.')
+              .appendField(createFieldNonEditableText(''), pythonUtils.FIELD_FUNCTION_NAME);
+          break;
+        }
         default:
           throw new Error('mrcFunctionKind has unexpected value: ' + this.mrcFunctionKind)
       }
@@ -293,6 +337,15 @@ const CALL_PYTHON_FUNCTION = {
       this.removeInput('ARG' + i);
     }
   },
+  getComponentName(this: CallPythonFunctionBlock): string {
+    // If the COMPONENT_NAME field has been created, get the field value, which the user may have changed.
+    // If the COMPONENT_NAME field has not been created, get the component name from this.mrcComponentName.
+    return (this.getField(FIELD_COMPONENT_NAME))
+      ? this.getFieldValue(FIELD_COMPONENT_NAME) : this.mrcComponentName;
+  },
+  getComponentClassName(this: CallPythonFunctionBlock): string {
+    return this.mrcComponentClassName;
+  },
   renameMethod: function(this: CallPythonFunctionBlock, newName: string): void {
     this.setFieldValue(newName, pythonUtils.FIELD_FUNCTION_NAME);
   },
@@ -365,6 +418,15 @@ export const pythonFromBlock = function(
       code = 'self.' + functionName;
       break;
     }
+    case FunctionKind.INSTANCE_COMPONENT: {
+      const componentName = callPythonFunctionBlock.getComponentName();
+      const varName = generator.componentNameToVarName(componentName);
+      const functionName = callPythonFunctionBlock.mrcActualFunctionName
+          ? callPythonFunctionBlock.mrcActualFunctionName
+          : block.getFieldValue(pythonUtils.FIELD_FUNCTION_NAME);
+      code = 'self.' + varName + '.' + functionName;
+      break;
+    }
     default:
       throw new Error('mrcFunctionKind has unexpected value: ' + callPythonFunctionBlock.mrcFunctionKind)
   }

src/blocks/mrc_class_method_def.ts

@@ -458,7 +458,8 @@ export const pythonFromBlock = function (
         xfix2 = xfix1;
     }
     if(block.mrcPythonMethodName == '__init__'){
-        branch = generator.defineClassVariables() + branch;
+        branch = generator.INDENT + 'super().__init__()\n' +
+            generator.defineClassVariables() + branch;
     }    
     if (returnValue) {
         returnValue = generator.INDENT + 'return ' + returnValue + '\n';

src/editor/editor.ts

@@ -34,6 +34,8 @@ const EMPTY_TOOLBOX: Blockly.utils.toolbox.ToolboxDefinition = {
 };
 
 export class Editor {
+  private static workspaceIdToEditor: {[key: string]: Editor} = {};
+
   private blocklyWorkspace: Blockly.WorkspaceSvg;
   private generatorContext: GeneratorContext;
   private storage: commonStorage.Storage;
@@ -47,6 +49,7 @@ export class Editor {
   private toolbox: Blockly.utils.toolbox.ToolboxDefinition = EMPTY_TOOLBOX;
 
   constructor(blocklyWorkspace: Blockly.WorkspaceSvg, generatorContext: GeneratorContext, storage: commonStorage.Storage) {
+    Editor.workspaceIdToEditor[blocklyWorkspace.id] = this;
     this.blocklyWorkspace = blocklyWorkspace;
     this.generatorContext = generatorContext;
     this.storage = storage;
@@ -219,8 +222,17 @@ export class Editor {
     const exportedBlocks = JSON.stringify(this.generatorContext.getExportedBlocks());
     const blocksContent = JSON.stringify(
         Blockly.serialization.workspaces.save(this.blocklyWorkspace));
+    const componentsContent = JSON.stringify(this.getComponents());
     return commonStorage.makeModuleContent(
-        this.currentModule, pythonCode, exportedBlocks, blocksContent);
+        this.currentModule, pythonCode, blocksContent, exportedBlocks, componentsContent);
+  }
+
+  private getComponents(): commonStorage.Component[] {
+    const components: commonStorage.Component[] = [];
+    if (this.currentModule?.moduleType === commonStorage.MODULE_TYPE_PROJECT) {
+      // TODO(lizlooney): Fill the components array.
+    }
+    return components;
   }
 
   public async saveBlocks() {
@@ -233,4 +245,45 @@ export class Editor {
     }
   }
 
+  private getComponentNamesImpl(componentClassName: string): string[] {
+    if (!this.projectContent) {
+      throw new Error('getComponentNames: this.projectContent is null.');
+    }
+    const components = commonStorage.extractComponents(this.projectContent);
+
+    // TODO(lizlooney): Remove this fake code after getComponents (above) has been implemented.
+    components.push({name: 'frontTouch', className: 'wpilib.RevTouchSensor'});
+    components.push({name: 'backTouch', className: 'wpilib.RevTouchSensor'});
+    components.push({name: 'leftMotor', className: 'wpilib.SmartMotor'});
+    components.push({name: 'rightMotor', className: 'wpilib.SmartMotor'});
+    components.push({name: 'claw', className: 'wpilib.Servo'});
+    components.push({name: 'colorSensor', className: 'wpilib.ColorRangeSensor'});
+    components.push({name: 'ledStick', className: 'wpilib.SparkFunLEDStick'});
+    // End of fake code
+
+    const componentNames: string[] = [];
+    components.forEach((component) => {
+      if (component.className === componentClassName) {
+        componentNames.push(component.name);
+      }
+    });
+    return componentNames;
+  }
+
+  public static getComponentNames(
+      workspace: Blockly.Workspace, componentClassName: string): string[] {
+
+    let editor: Editor | null = null;
+    if (workspace.id in Editor.workspaceIdToEditor) {
+      editor = Editor.workspaceIdToEditor[workspace.id];
+    } else {
+      // If the workspace id was not found, it might be because the workspace is associated with the
+      // toolbox flyout, not a real workspace. In that case, use the first editor.
+      const allEditors = Object.values(Editor.workspaceIdToEditor);
+      if (allEditors.length) {
+        editor =  allEditors[0];
+      }
+    }
+    return editor ? editor.getComponentNamesImpl(componentClassName) : [];
+  }
 }

src/editor/extended_python_generator.ts

@@ -23,7 +23,7 @@ import * as Blockly from 'blockly/core';
 import { PythonGenerator } from 'blockly/python';
 import { GeneratorContext } from './generator_context';
 import { Block } from '../toolbox/items';
-import { FunctionArg } from '../blocks/mrc_call_python_function';
+import { CallPythonFunctionBlock, FunctionArg } from '../blocks/mrc_call_python_function';
 import * as commonStorage from '../storage/common_storage';
 
 // Extends the python generator to collect some information about functions and
@@ -34,16 +34,18 @@ export class ExtendedPythonGenerator extends PythonGenerator {
   private context: GeneratorContext | null = null;
 
   private classMethods: {[key: string]: string} = Object.create(null);
+  private mapComponentNameToVarName: {[key: string]: string} = Object.create(null);
 
   constructor() {
     super('Python');
   }
 
   init(workspace: Blockly.Workspace){
     super.init(workspace);
-    // This will have all variables in the definition 'variables' so we will need to make it contain only the developer variables
-    delete this.definitions_['variables'];
 
+    // super.init will have put all variables in this.definitions_['variables'] but we need to make
+    // it contain only the developer variables.
+    delete this.definitions_['variables'];
     const defvars = [];
     // Add developer variables (not created or named by the user).
     const devVarList = Blockly.Variables.allDeveloperVariables(workspace);
@@ -52,20 +54,37 @@ export class ExtendedPythonGenerator extends PythonGenerator {
         this.nameDB_!.getName(devVarList[i], Blockly.Names.DEVELOPER_VARIABLE_TYPE) + ' = None',
       );
     }
-    this.definitions_['variables'] = defvars.join('\n');     
+    this.definitions_['variables'] = defvars.join('\n');
+
+    // Collect the components used in all mrc_call_python_function blocks.
+    workspace.getBlocksByType('mrc_call_python_function', false).forEach((block) => {
+      const callPythonFunctionBlock = block as CallPythonFunctionBlock;
+      const componentName = callPythonFunctionBlock.getComponentName();
+      if (componentName) {
+        if (!(componentName in this.mapComponentNameToVarName)) {
+          const varName = this.nameDB_!.getDistinctName(componentName, 'VARIABLE');
+          this.mapComponentNameToVarName[componentName] = varName;
+        }
+      }
+    });
   }
 
-  /* 
+  /*
    * This is called from the python generator for the mrc_class_method_def for the
    * init method
    */
   defineClassVariables() : string {
-      let variableDefinitions = '';
+    let variableDefinitions = '';
 
-      if (this.context?.getHasMechanisms()) {
-        variableDefinitions += this.INDENT + "self.mechanisms = []\n";
-      }
-      return variableDefinitions;
+    if (this.context?.getHasMechanisms()) {
+      variableDefinitions += this.INDENT + "self.mechanisms = []\n";
+    }
+
+    Object.entries(this.mapComponentNameToVarName).forEach(([componentName, varName]) => {
+      variableDefinitions += this.INDENT + 'self.' + varName + ' = robot.' + componentName + '\n';
+    });
+
+    return variableDefinitions;
   }
   getVariableName(nameOrId: string): string {
     const varName = super.getVariableName(nameOrId);
@@ -74,7 +93,7 @@ export class ExtendedPythonGenerator extends PythonGenerator {
   setHasMechanism() : void{
     this.context?.setHasMechanism();
   }
-  
+
   mrcWorkspaceToCode(workspace: Blockly.Workspace, context: GeneratorContext): string {
     this.workspace = workspace;
     this.context = context;
@@ -101,14 +120,21 @@ export class ExtendedPythonGenerator extends PythonGenerator {
     this.classMethods[methodName] = code;
   }
 
+  /**
+   * Get the variable name to use for a component.
+   */
+  componentNameToVarName(componentName: string): string {
+    return this.mapComponentNameToVarName[componentName];
+  }
+
   finish(code: string): string {
     if (this.context && this.workspace) {
       const className = this.context.getClassName();
       const classParent = this.context.getClassParent();
       this.addImport(classParent);
       const classDef = 'class ' + className + '(' + classParent + '):\n';
       const classMethods = [];
-      for (let name in this.classMethods) {
+      for (const name in this.classMethods) {
         classMethods.push(this.classMethods[name])
       }
       this.classMethods = Object.create(null);
@@ -117,6 +143,8 @@ export class ExtendedPythonGenerator extends PythonGenerator {
       this.context.setExportedBlocks(this.produceExportedBlocks(this.workspace));
     }
 
+    this.mapComponentNameToVarName = Object.create(null);
+
     return super.finish(code);
   }
 

src/modules/opmode_start.json

@@ -13,7 +13,12 @@
                     "canBeCalledWithinClass": false,
                     "canBeCalledOutsideClass": false,
                     "returnType": "None",
-                    "params": [],
+                    "params": [
+                        {
+                            "name": "robot",
+                            "type": "Robot"
+                        }
+                    ],
                     "pythonMethodName": "__init__"
                 },
                 "fields": {

src/storage/client_side_storage.ts

@@ -574,7 +574,7 @@ class ClientSideStorage implements commonStorage.Storage {
       };
       const modulesObjectStore = transaction.objectStore('modules');
 
-      for (let moduleName in moduleTypes) {
+      for (const moduleName in moduleTypes) {
         const moduleType = moduleTypes[moduleName];
         const moduleContent = moduleContents[moduleName];
         const modulePath = commonStorage.makeModulePath(projectName, moduleName);