refactor(generators): Migrate Python generators to TypeScript #7602 (#7617)

* refactor(generators): Migrate python_generator.js to TypeScript

* refactor(generators): Migrate generators/python/* to TypeScript

  First pass doing very mechanistic migration, not attempting to fix
  all the resulting type errors.

* fix(generators): Fix type errors in generator functions

  This consists almost entirely of adding casts, so the code output
  by tsc should be as similar as possible to the pre-migration .js
  source files.

* refactor(generators): Migrate generators/python.js to TypeScript

  The way the generator functions are added to
  pythonGenerator.forBlock has been modified so that incorrect
  generator function signatures will cause tsc to generate a type
  error.

* chore(generator): Format

  One block protected with // prettier-ignore to preserve careful
  comment formatting.

  Where there are repeated concatenations prettier has made a pretty
  mess of things, but the correct fix is probably to use template
  literals instead (rather than just locally disabling prettier).
  This is one of the items in the to-do list in #7600.

generators/python.ts

@@ -36,8 +36,18 @@ export const pythonGenerator = new PythonGenerator();
 pythonGenerator.addReservedWords('math,random,Number');
 
 // Install per-block-type generator functions:
-Object.assign(
+// Install per-block-type generator functions:
-  pythonGenerator.forBlock,
+const generators: typeof pythonGenerator.forBlock = {
-  colour, lists, logic, loops, math, procedures,
+  ...colour,
-  text, variables, variablesDynamic
+  ...lists,
-);
+  ...logic,
+  ...loops,
+  ...math,
+  ...procedures,
+  ...text,
+  ...variables,
+  ...variablesDynamic,
+};
+for (const name in generators) {
+  pythonGenerator.forBlock[name] = generators[name];
+}

generators/python/colour.ts

@@ -10,41 +10,62 @@
 
 // Former goog.module ID: Blockly.Python.colour
 
+import type {Block} from '../../core/block.js';
+import type {PythonGenerator} from './python_generator.js';
 import {Order} from './python_generator.js';
 
-
+export function colour_picker(
-export function colour_picker(block, generator) {
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Colour picker.
   const code = generator.quote_(block.getFieldValue('COLOUR'));
   return [code, Order.ATOMIC];
-};
+}
 
-export function colour_random(block, generator) {
+export function colour_random(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Generate a random colour.
-  generator.definitions_['import_random'] = 'import random';
+  // TODO(#7600): find better approach than casting to any to override
-  const code = '\'#%06x\' % random.randint(0, 2**24 - 1)';
+  // CodeGenerator declaring .definitions protected.
+  (generator as AnyDuringMigration).definitions_['import_random'] =
+    'import random';
+  const code = "'#%06x' % random.randint(0, 2**24 - 1)";
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function colour_rgb(block, generator) {
+export function colour_rgb(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Compose a colour from RGB components expressed as percentages.
-  const functionName = generator.provideFunction_('colour_rgb', `
+  const functionName = generator.provideFunction_(
+    'colour_rgb',
+    `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(r, g, b):
   r = round(min(100, max(0, r)) * 2.55)
   g = round(min(100, max(0, g)) * 2.55)
   b = round(min(100, max(0, b)) * 2.55)
   return '#%02x%02x%02x' % (r, g, b)
-`);
+`,
+  );
   const r = generator.valueToCode(block, 'RED', Order.NONE) || 0;
   const g = generator.valueToCode(block, 'GREEN', Order.NONE) || 0;
   const b = generator.valueToCode(block, 'BLUE', Order.NONE) || 0;
   const code = functionName + '(' + r + ', ' + g + ', ' + b + ')';
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function colour_blend(block, generator) {
+export function colour_blend(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Blend two colours together.
-  const functionName = generator.provideFunction_('colour_blend', `
+  const functionName = generator.provideFunction_(
+    'colour_blend',
+    `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(colour1, colour2, ratio):
   r1, r2 = int(colour1[1:3], 16), int(colour2[1:3], 16)
   g1, g2 = int(colour1[3:5], 16), int(colour2[3:5], 16)
@@ -54,15 +75,14 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(colour1, colour2, ratio):
   g = round(g1 * (1 - ratio) + g2 * ratio)
   b = round(b1 * (1 - ratio) + b2 * ratio)
   return '#%02x%02x%02x' % (r, g, b)
-`);
+`,
+  );
   const colour1 =
-      generator.valueToCode(block, 'COLOUR1', Order.NONE)
+    generator.valueToCode(block, 'COLOUR1', Order.NONE) || "'#000000'";
-      || '\'#000000\'';
   const colour2 =
-      generator.valueToCode(block, 'COLOUR2', Order.NONE)
+    generator.valueToCode(block, 'COLOUR2', Order.NONE) || "'#000000'";
-      || '\'#000000\'';
   const ratio = generator.valueToCode(block, 'RATIO', Order.NONE) || 0;
   const code =
     functionName + '(' + colour1 + ', ' + colour2 + ', ' + ratio + ')';
   return [code, Order.FUNCTION_CALL];
-};
+}

generators/python/lists.ts

@@ -11,49 +11,69 @@
 // Former goog.module ID: Blockly.Python.lists
 
 import * as stringUtils from '../../core/utils/string.js';
+import type {Block} from '../../core/block.js';
+import type {CreateWithBlock} from '../../blocks/lists.js';
 import {NameType} from '../../core/names.js';
 import {Order} from './python_generator.js';
+import type {PythonGenerator} from './python_generator.js';
 
-
+export function lists_create_empty(
-export function lists_create_empty(block, generator) {
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Create an empty list.
   return ['[]', Order.ATOMIC];
-};
+}
 
-export function lists_create_with(block, generator) {
+export function lists_create_with(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
+  const createWithBlock = block as CreateWithBlock;
   // Create a list with any number of elements of any type.
-  const elements = new Array(block.itemCount_);
+  const elements = new Array(createWithBlock.itemCount_);
-  for (let i = 0; i < block.itemCount_; i++) {
+  for (let i = 0; i < createWithBlock.itemCount_; i++) {
-    elements[i] =
+    elements[i] = generator.valueToCode(block, 'ADD' + i, Order.NONE) || 'None';
-        generator.valueToCode(block, 'ADD' + i, Order.NONE) || 'None';
   }
   const code = '[' + elements.join(', ') + ']';
   return [code, Order.ATOMIC];
-};
+}
 
-export function lists_repeat(block, generator) {
+export function lists_repeat(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Create a list with one element repeated.
   const item = generator.valueToCode(block, 'ITEM', Order.NONE) || 'None';
   const times =
     generator.valueToCode(block, 'NUM', Order.MULTIPLICATIVE) || '0';
   const code = '[' + item + '] * ' + times;
   return [code, Order.MULTIPLICATIVE];
-};
+}
 
-export function lists_length(block, generator) {
+export function lists_length(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // String or array length.
   const list = generator.valueToCode(block, 'VALUE', Order.NONE) || '[]';
   return ['len(' + list + ')', Order.FUNCTION_CALL];
-};
+}
 
-export function lists_isEmpty(block, generator) {
+export function lists_isEmpty(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Is the string null or array empty?
   const list = generator.valueToCode(block, 'VALUE', Order.NONE) || '[]';
   const code = 'not len(' + list + ')';
   return [code, Order.LOGICAL_NOT];
-};
+}
 
-export function lists_indexOf(block, generator) {
+export function lists_indexOf(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Find an item in the list.
   const item = generator.valueToCode(block, 'FIND', Order.NONE) || '[]';
   const list = generator.valueToCode(block, 'VALUE', Order.NONE) || "''";
@@ -69,31 +89,39 @@ export function lists_indexOf(block, generator) {
 
   let functionName;
   if (block.getFieldValue('END') === 'FIRST') {
-    functionName = generator.provideFunction_('first_index', `
+    functionName = generator.provideFunction_(
+      'first_index',
+      `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(my_list, elem):
   try: index = my_list.index(elem)${firstIndexAdjustment}
   except: index =${errorIndex}
   return index
-`);
+`,
+    );
   } else {
-    functionName = generator.provideFunction_('last_index', `
+    functionName = generator.provideFunction_(
+      'last_index',
+      `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(my_list, elem):
   try: index = len(my_list) - my_list[::-1].index(elem)${lastIndexAdjustment}
   except: index =${errorIndex}
   return index
-`);
+`,
+    );
   }
   const code = functionName + '(' + list + ', ' + item + ')';
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function lists_getIndex(block, generator) {
+export function lists_getIndex(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] | string {
   // Get element at index.
   // Note: Until January 2013 this block did not have MODE or WHERE inputs.
   const mode = block.getFieldValue('MODE') || 'GET';
   const where = block.getFieldValue('WHERE') || 'FROM_START';
-  const listOrder =
+  const listOrder = where === 'RANDOM' ? Order.NONE : Order.MEMBER;
-      (where === 'RANDOM') ? Order.NONE : Order.MEMBER;
   const list = generator.valueToCode(block, 'VALUE', listOrder) || '[]';
 
   switch (where) {
@@ -146,17 +174,20 @@ export function lists_getIndex(block, generator) {
       break;
     }
     case 'RANDOM':
-      generator.definitions_['import_random'] = 'import random';
+      (generator as AnyDuringMigration).definitions_['import_random'] =
+        'import random';
       if (mode === 'GET') {
         const code = 'random.choice(' + list + ')';
         return [code, Order.FUNCTION_CALL];
       } else {
-        const functionName =
+        const functionName = generator.provideFunction_(
-            generator.provideFunction_('lists_remove_random_item', `
+          'lists_remove_random_item',
+          `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(myList):
   x = int(random.random() * len(myList))
   return myList.pop(x)
-`);
+`,
+        );
         const code = functionName + '(' + list + ')';
         if (mode === 'GET_REMOVE') {
           return [code, Order.FUNCTION_CALL];
@@ -167,9 +198,9 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(myList):
       break;
   }
   throw Error('Unhandled combination (lists_getIndex).');
-};
+}
 
-export function lists_setIndex(block, generator) {
+export function lists_setIndex(block: Block, generator: PythonGenerator) {
   // Set element at index.
   // Note: Until February 2013 this block did not have MODE or WHERE inputs.
   let list = generator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
@@ -182,8 +213,10 @@ export function lists_setIndex(block, generator) {
     if (list.match(/^\w+$/)) {
       return '';
     }
-    const listVar =
+    const listVar = generator.nameDB_!.getDistinctName(
-        generator.nameDB_.getDistinctName('tmp_list', NameType.VARIABLE);
+      'tmp_list',
+      NameType.VARIABLE,
+    );
     const code = listVar + ' = ' + list + '\n';
     list = listVar;
     return code;
@@ -223,10 +256,13 @@ export function lists_setIndex(block, generator) {
       break;
     }
     case 'RANDOM': {
-      generator.definitions_['import_random'] = 'import random';
+      (generator as AnyDuringMigration).definitions_['import_random'] =
+        'import random';
       let code = cacheList();
-      const xVar =
+      const xVar = generator.nameDB_!.getDistinctName(
-          generator.nameDB_.getDistinctName('tmp_x', NameType.VARIABLE);
+        'tmp_x',
+        NameType.VARIABLE,
+      );
       code += xVar + ' = int(random.random() * len(' + list + '))\n';
       if (mode === 'SET') {
         code += list + '[' + xVar + '] = ' + value + '\n';
@@ -239,9 +275,12 @@ export function lists_setIndex(block, generator) {
     }
   }
   throw Error('Unhandled combination (lists_setIndex).');
-};
+}
 
-export function lists_getSublist(block, generator) {
+export function lists_getSublist(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Get sublist.
   const list = generator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
   const where1 = block.getFieldValue('WHERE1');
@@ -274,7 +313,8 @@ export function lists_getSublist(block, generator) {
       // Ensure that if the result calculated is 0 that sub-sequence will
       // include all elements as expected.
       if (!stringUtils.isNumber(String(at2))) {
-        generator.definitions_['import_sys'] = 'import sys';
+        (generator as AnyDuringMigration).definitions_['import_sys'] =
+          'import sys';
         at2 += ' or sys.maxsize';
       } else if (at2 === 0) {
         at2 = '';
@@ -288,14 +328,19 @@ export function lists_getSublist(block, generator) {
   }
   const code = list + '[' + at1 + ' : ' + at2 + ']';
   return [code, Order.MEMBER];
-};
+}
 
-export function lists_sort(block, generator) {
+export function lists_sort(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Block for sorting a list.
-  const list = (generator.valueToCode(block, 'LIST', Order.NONE) || '[]');
+  const list = generator.valueToCode(block, 'LIST', Order.NONE) || '[]';
   const type = block.getFieldValue('TYPE');
   const reverse = block.getFieldValue('DIRECTION') === '1' ? 'False' : 'True';
-  const sortFunctionName = generator.provideFunction_('lists_sort', `
+  const sortFunctionName = generator.provideFunction_(
+    'lists_sort',
+    `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(my_list, type, reverse):
   def try_float(s):
     try:
@@ -310,14 +355,18 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(my_list, type, reverse):
   key_func = key_funcs[type]
   list_cpy = list(my_list)
   return sorted(list_cpy, key=key_func, reverse=reverse)
-`);
+`,
+  );
 
   const code =
     sortFunctionName + '(' + list + ', "' + type + '", ' + reverse + ')';
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function lists_split(block, generator) {
+export function lists_split(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Block for splitting text into a list, or joining a list into text.
   const mode = block.getFieldValue('MODE');
   let code;
@@ -336,11 +385,14 @@ export function lists_split(block, generator) {
     throw Error('Unknown mode: ' + mode);
   }
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function lists_reverse(block, generator) {
+export function lists_reverse(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Block for reversing a list.
   const list = generator.valueToCode(block, 'LIST', Order.NONE) || '[]';
   const code = 'list(reversed(' + list + '))';
   return [code, Order.FUNCTION_CALL];
-};
+}

generators/python/logic.ts

@@ -10,13 +10,16 @@
 
 // Former goog.module ID: Blockly.Python.logic
 
+import type {Block} from '../../core/block.js';
+import type {PythonGenerator} from './python_generator.js';
 import {Order} from './python_generator.js';
 
-
+export function controls_if(block: Block, generator: PythonGenerator) {
-export function controls_if(block, generator) {
   // If/elseif/else condition.
   let n = 0;
-  let code = '', branchCode, conditionCode;
+  let code = '',
+    branchCode,
+    conditionCode;
   if (generator.STATEMENT_PREFIX) {
     // Automatic prefix insertion is switched off for this block.  Add manually.
     code += generator.injectId(generator.STATEMENT_PREFIX, block);
@@ -24,55 +27,63 @@ export function controls_if(block, generator) {
   do {
     conditionCode =
       generator.valueToCode(block, 'IF' + n, Order.NONE) || 'False';
-    branchCode =
+    branchCode = generator.statementToCode(block, 'DO' + n) || generator.PASS;
-        generator.statementToCode(block, 'DO' + n) ||
-        generator.PASS;
     if (generator.STATEMENT_SUFFIX) {
       branchCode =
         generator.prefixLines(
           generator.injectId(generator.STATEMENT_SUFFIX, block),
-            generator.INDENT) +
+          generator.INDENT,
-          branchCode;
+        ) + branchCode;
     }
     code += (n === 0 ? 'if ' : 'elif ') + conditionCode + ':\n' + branchCode;
     n++;
   } while (block.getInput('IF' + n));
 
   if (block.getInput('ELSE') || generator.STATEMENT_SUFFIX) {
-    branchCode =
+    branchCode = generator.statementToCode(block, 'ELSE') || generator.PASS;
-        generator.statementToCode(block, 'ELSE') || generator.PASS;
     if (generator.STATEMENT_SUFFIX) {
       branchCode =
         generator.prefixLines(
-            generator.injectId(
+          generator.injectId(generator.STATEMENT_SUFFIX, block),
-              generator.STATEMENT_SUFFIX, block),
+          generator.INDENT,
-            generator.INDENT) +
+        ) + branchCode;
-          branchCode;
     }
     code += 'else:\n' + branchCode;
   }
   return code;
-};
+}
 
 export const controls_ifelse = controls_if;
 
-export function logic_compare(block, generator) {
+export function logic_compare(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Comparison operator.
-  const OPERATORS =
+  const OPERATORS = {
-      {'EQ': '==', 'NEQ': '!=', 'LT': '<', 'LTE': '<=', 'GT': '>', 'GTE': '>='};
+    'EQ': '==',
-  const operator = OPERATORS[block.getFieldValue('OP')];
+    'NEQ': '!=',
+    'LT': '<',
+    'LTE': '<=',
+    'GT': '>',
+    'GTE': '>=',
+  };
+  type OperatorOption = keyof typeof OPERATORS;
+  const operator = OPERATORS[block.getFieldValue('OP') as OperatorOption];
   const order = Order.RELATIONAL;
   const argument0 = generator.valueToCode(block, 'A', order) || '0';
   const argument1 = generator.valueToCode(block, 'B', order) || '0';
   const code = argument0 + ' ' + operator + ' ' + argument1;
   return [code, order];
-};
+}
 
-export function logic_operation(block, generator) {
+export function logic_operation(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Operations 'and', 'or'.
-  const operator = (block.getFieldValue('OP') === 'AND') ? 'and' : 'or';
+  const operator = block.getFieldValue('OP') === 'AND' ? 'and' : 'or';
-  const order =
+  const order = operator === 'and' ? Order.LOGICAL_AND : Order.LOGICAL_OR;
-      (operator === 'and') ? Order.LOGICAL_AND : Order.LOGICAL_OR;
   let argument0 = generator.valueToCode(block, 'A', order);
   let argument1 = generator.valueToCode(block, 'B', order);
   if (!argument0 && !argument1) {
@@ -81,7 +92,7 @@ export function logic_operation(block, generator) {
     argument1 = 'False';
   } else {
     // Single missing arguments have no effect on the return value.
-    const defaultArgument = (operator === 'and') ? 'True' : 'False';
+    const defaultArgument = operator === 'and' ? 'True' : 'False';
     if (!argument0) {
       argument0 = defaultArgument;
     }
@@ -91,28 +102,40 @@ export function logic_operation(block, generator) {
   }
   const code = argument0 + ' ' + operator + ' ' + argument1;
   return [code, order];
-};
+}
 
-export function logic_negate(block, generator) {
+export function logic_negate(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Negation.
   const argument0 =
     generator.valueToCode(block, 'BOOL', Order.LOGICAL_NOT) || 'True';
   const code = 'not ' + argument0;
   return [code, Order.LOGICAL_NOT];
-};
+}
 
-export function logic_boolean(block, generator) {
+export function logic_boolean(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Boolean values true and false.
-  const code = (block.getFieldValue('BOOL') === 'TRUE') ? 'True' : 'False';
+  const code = block.getFieldValue('BOOL') === 'TRUE' ? 'True' : 'False';
   return [code, Order.ATOMIC];
-};
+}
 
-export function logic_null(block, generator) {
+export function logic_null(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Null data type.
   return ['None', Order.ATOMIC];
-};
+}
 
-export function logic_ternary(block, generator) {
+export function logic_ternary(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Ternary operator.
   const value_if =
     generator.valueToCode(block, 'IF', Order.CONDITIONAL) || 'False';
@@ -122,4 +145,4 @@ export function logic_ternary(block, generator) {
     generator.valueToCode(block, 'ELSE', Order.CONDITIONAL) || 'None';
   const code = value_then + ' if ' + value_if + ' else ' + value_else;
   return [code, Order.CONDITIONAL];
-};
+}

generators/python/loops.ts

@@ -11,11 +11,13 @@
 // Former goog.module ID: Blockly.Python.loops
 
 import * as stringUtils from '../../core/utils/string.js';
+import type {Block} from '../../core/block.js';
+import type {ControlFlowInLoopBlock} from '../../blocks/loops.js';
+import type {PythonGenerator} from './python_generator.js';
 import {NameType} from '../../core/names.js';
 import {Order} from './python_generator.js';
 
-
+export function controls_repeat_ext(block: Block, generator: PythonGenerator) {
-export function controls_repeat_ext(block, generator) {
   // Repeat n times.
   let repeats;
   if (block.getField('TIMES')) {
@@ -32,36 +34,42 @@ export function controls_repeat_ext(block, generator) {
   }
   let branch = generator.statementToCode(block, 'DO');
   branch = generator.addLoopTrap(branch, block) || generator.PASS;
-  const loopVar =
+  const loopVar = generator.nameDB_!.getDistinctName(
-      generator.nameDB_.getDistinctName('count', NameType.VARIABLE);
+    'count',
+    NameType.VARIABLE,
+  );
   const code = 'for ' + loopVar + ' in range(' + repeats + '):\n' + branch;
   return code;
-};
+}
 
 export const controls_repeat = controls_repeat_ext;
 
-export function controls_whileUntil(block, generator) {
+export function controls_whileUntil(block: Block, generator: PythonGenerator) {
   // Do while/until loop.
   const until = block.getFieldValue('MODE') === 'UNTIL';
-  let argument0 = generator.valueToCode(
+  let argument0 =
-                      block, 'BOOL',
+    generator.valueToCode(
-                      until ? Order.LOGICAL_NOT : Order.NONE) ||
+      block,
-      'False';
+      'BOOL',
+      until ? Order.LOGICAL_NOT : Order.NONE,
+    ) || 'False';
   let branch = generator.statementToCode(block, 'DO');
   branch = generator.addLoopTrap(branch, block) || generator.PASS;
   if (until) {
     argument0 = 'not ' + argument0;
   }
   return 'while ' + argument0 + ':\n' + branch;
-};
+}
 
-export function controls_for(block, generator) {
+export function controls_for(block: Block, generator: PythonGenerator) {
   // For loop.
-  const variable0 =
+  const variable0 = generator.getVariableName(block.getFieldValue('VAR'));
-      generator.getVariableName(block.getFieldValue('VAR'));
+  let argument0: string | number =
-  let argument0 = generator.valueToCode(block, 'FROM', Order.NONE) || '0';
+    generator.valueToCode(block, 'FROM', Order.NONE) || '0';
-  let argument1 = generator.valueToCode(block, 'TO', Order.NONE) || '0';
+  let argument1: string | number =
-  let increment = generator.valueToCode(block, 'BY', Order.NONE) || '1';
+    generator.valueToCode(block, 'TO', Order.NONE) || '0';
+  let increment: string | number =
+    generator.valueToCode(block, 'BY', Order.NONE) || '1';
   let branch = generator.statementToCode(block, 'DO');
   branch = generator.addLoopTrap(branch, block) || generator.PASS;
 
@@ -70,30 +78,63 @@ export function controls_for(block, generator) {
 
   // Helper functions.
   const defineUpRange = function () {
-    return generator.provideFunction_('upRange', `
+    return generator.provideFunction_(
+      'upRange',
+      `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(start, stop, step):
   while start <= stop:
     yield start
     start += abs(step)
-`);
+`,
+    );
   };
   const defineDownRange = function () {
-    return generator.provideFunction_('downRange', `
+    return generator.provideFunction_(
+      'downRange',
+      `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(start, stop, step):
   while start >= stop:
     yield start
     start -= abs(step)
-`);
+`,
+    );
   };
   // Arguments are legal generator code (numbers or strings returned by scrub()).
-  const generateUpDownRange = function(start, end, inc) {
+  const generateUpDownRange = function (
-    return '(' + start + ' <= ' + end + ') and ' + defineUpRange() + '(' +
+    start: string,
-        start + ', ' + end + ', ' + inc + ') or ' + defineDownRange() + '(' +
+    end: string,
-        start + ', ' + end + ', ' + inc + ')';
+    inc: string,
+  ) {
+    return (
+      '(' +
+      start +
+      ' <= ' +
+      end +
+      ') and ' +
+      defineUpRange() +
+      '(' +
+      start +
+      ', ' +
+      end +
+      ', ' +
+      inc +
+      ') or ' +
+      defineDownRange() +
+      '(' +
+      start +
+      ', ' +
+      end +
+      ', ' +
+      inc +
+      ')'
+    );
   };
 
-  if (stringUtils.isNumber(argument0) && stringUtils.isNumber(argument1) &&
+  if (
-      stringUtils.isNumber(increment)) {
+    stringUtils.isNumber(argument0) &&
+    stringUtils.isNumber(argument1) &&
+    stringUtils.isNumber(increment)
+  ) {
     // All parameters are simple numbers.
     argument0 = Number(argument0);
     argument1 = Number(argument1);
@@ -130,14 +171,16 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(start, stop, step):
     }
   } else {
     // Cache non-trivial values to variables to prevent repeated look-ups.
-    const scrub = function(arg, suffix) {
+    const scrub = function (arg: string, suffix: string) {
       if (stringUtils.isNumber(arg)) {
         // Simple number.
-        arg = Number(arg);
+        arg = String(Number(arg));
       } else if (!arg.match(/^\w+$/)) {
         // Not a variable, it's complicated.
-        const varName = generator.nameDB_.getDistinctName(
+        const varName = generator.nameDB_!.getDistinctName(
-            variable0 + suffix, NameType.VARIABLE);
+          variable0 + suffix,
+          NameType.VARIABLE,
+        );
         code += varName + ' = ' + arg + '\n';
         arg = varName;
       }
@@ -161,21 +204,23 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(start, stop, step):
   }
   code += 'for ' + variable0 + ' in ' + range + ':\n' + branch;
   return code;
-};
+}
 
-export function controls_forEach(block, generator) {
+export function controls_forEach(block: Block, generator: PythonGenerator) {
   // For each loop.
-  const variable0 =
+  const variable0 = generator.getVariableName(block.getFieldValue('VAR'));
-      generator.getVariableName(block.getFieldValue('VAR'));
   const argument0 =
     generator.valueToCode(block, 'LIST', Order.RELATIONAL) || '[]';
   let branch = generator.statementToCode(block, 'DO');
   branch = generator.addLoopTrap(branch, block) || generator.PASS;
   const code = 'for ' + variable0 + ' in ' + argument0 + ':\n' + branch;
   return code;
-};
+}
 
-export function controls_flow_statements(block, generator) {
+export function controls_flow_statements(
+  block: Block,
+  generator: PythonGenerator,
+) {
   // Flow statements: continue, break.
   let xfix = '';
   if (generator.STATEMENT_PREFIX) {
@@ -188,7 +233,7 @@ export function controls_flow_statements(block, generator) {
     xfix += generator.injectId(generator.STATEMENT_SUFFIX, block);
   }
   if (generator.STATEMENT_PREFIX) {
-    const loop = block.getSurroundLoop();
+    const loop = (block as ControlFlowInLoopBlock).getSurroundLoop();
     if (loop && !loop.suppressPrefixSuffix) {
       // Inject loop's statement prefix here since the regular one at the end
       // of the loop will not get executed if 'continue' is triggered.
@@ -203,4 +248,4 @@ export function controls_flow_statements(block, generator) {
       return xfix + 'continue\n';
   }
   throw Error('Unknown flow statement.');
-};
+}

generators/python/math.ts

@@ -10,38 +10,42 @@
 
 // Former goog.module ID: Blockly.Python.math
 
+import type {Block} from '../../core/block.js';
+import type {PythonGenerator} from './python_generator.js';
 import {Order} from './python_generator.js';
 
-
 // If any new block imports any library, add that library name here.
 // RESERVED WORDS: 'math,random,Number'
 
-export function math_number(block, generator) {
+export function math_number(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Numeric value.
-  let code = Number(block.getFieldValue('NUM'));
+  let number = Number(block.getFieldValue('NUM'));
-  let order;
+  if (number === Infinity) {
-  if (code === Infinity) {
+    return ['float("inf")', Order.FUNCTION_CALL];
-    code = 'float("inf")';
+  } else if (number === -Infinity) {
-    order = Order.FUNCTION_CALL;
+    return ['-float("inf")', Order.UNARY_SIGN];
-  } else if (code === -Infinity) {
-    code = '-float("inf")';
-    order = Order.UNARY_SIGN;
   } else {
-    order = code < 0 ? Order.UNARY_SIGN : Order.ATOMIC;
+    return [String(number), number < 0 ? Order.UNARY_SIGN : Order.ATOMIC];
+  }
 }
-  return [code, order];
-};
 
-export function math_arithmetic(block, generator) {
+export function math_arithmetic(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Basic arithmetic operators, and power.
-  const OPERATORS = {
+  const OPERATORS: Record<string, [string | null, Order]> = {
     'ADD': [' + ', Order.ADDITIVE],
     'MINUS': [' - ', Order.ADDITIVE],
     'MULTIPLY': [' * ', Order.MULTIPLICATIVE],
     'DIVIDE': [' / ', Order.MULTIPLICATIVE],
     'POWER': [' ** ', Order.EXPONENTIATION],
   };
-  const tuple = OPERATORS[block.getFieldValue('OP')];
+  type OperatorOption = keyof typeof OPERATORS;
+  const tuple = OPERATORS[block.getFieldValue('OP') as OperatorOption];
   const operator = tuple[0];
   const order = tuple[1];
   const argument0 = generator.valueToCode(block, 'A', order) || '0';
@@ -53,9 +57,12 @@ export function math_arithmetic(block, generator) {
   // guarantee identical results in all languages.  To do otherwise would
   // require every operator to be wrapped in a function call.  This would kill
   // legibility of the generated code.
-};
+}
 
-export function math_single(block, generator) {
+export function math_single(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Math operators with single operand.
   const operator = block.getFieldValue('OP');
   let code;
@@ -65,10 +72,11 @@ export function math_single(block, generator) {
     code = generator.valueToCode(block, 'NUM', Order.UNARY_SIGN) || '0';
     return ['-' + code, Order.UNARY_SIGN];
   }
-  generator.definitions_['import_math'] = 'import math';
+  // TODO(#7600): find better approach than casting to any to override
+  // CodeGenerator declaring .definitions protected (here and below).
+  (generator as AnyDuringMigration).definitions_['import_math'] = 'import math';
   if (operator === 'SIN' || operator === 'COS' || operator === 'TAN') {
-    arg =
+    arg = generator.valueToCode(block, 'NUM', Order.MULTIPLICATIVE) || '0';
-        generator.valueToCode(block, 'NUM', Order.MULTIPLICATIVE) || '0';
   } else {
     arg = generator.valueToCode(block, 'NUM', Order.NONE) || '0';
   }
@@ -131,50 +139,61 @@ export function math_single(block, generator) {
       throw Error('Unknown math operator: ' + operator);
   }
   return [code, Order.MULTIPLICATIVE];
-};
+}
 
-export function math_constant(block, generator) {
+export function math_constant(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Constants: PI, E, the Golden Ratio, sqrt(2), 1/sqrt(2), INFINITY.
-  const CONSTANTS = {
+  const CONSTANTS: Record<string, [string, Order]> = {
     'PI': ['math.pi', Order.MEMBER],
     'E': ['math.e', Order.MEMBER],
     'GOLDEN_RATIO': ['(1 + math.sqrt(5)) / 2', Order.MULTIPLICATIVE],
     'SQRT2': ['math.sqrt(2)', Order.MEMBER],
     'SQRT1_2': ['math.sqrt(1.0 / 2)', Order.MEMBER],
-    'INFINITY': ['float(\'inf\')', Order.ATOMIC],
+    'INFINITY': ["float('inf')", Order.ATOMIC],
   };
-  const constant = block.getFieldValue('CONSTANT');
+  type ConstantOption = keyof typeof CONSTANTS;
+  const constant = block.getFieldValue('CONSTANT') as ConstantOption;
   if (constant !== 'INFINITY') {
-    generator.definitions_['import_math'] = 'import math';
+    (generator as AnyDuringMigration).definitions_['import_math'] =
+      'import math';
   }
   return CONSTANTS[constant];
-};
+}
 
-export function math_number_property(block, generator) {
+export function math_number_property(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Check if a number is even, odd, prime, whole, positive, or negative
   // or if it is divisible by certain number. Returns true or false.
-  const PROPERTIES = {
+  const PROPERTIES: Record<string, [string | null, Order, Order]> = {
     'EVEN': [' % 2 == 0', Order.MULTIPLICATIVE, Order.RELATIONAL],
     'ODD': [' % 2 == 1', Order.MULTIPLICATIVE, Order.RELATIONAL],
-    'WHOLE': [' % 1 == 0', Order.MULTIPLICATIVE,
+    'WHOLE': [' % 1 == 0', Order.MULTIPLICATIVE, Order.RELATIONAL],
-        Order.RELATIONAL],
     'POSITIVE': [' > 0', Order.RELATIONAL, Order.RELATIONAL],
     'NEGATIVE': [' < 0', Order.RELATIONAL, Order.RELATIONAL],
-    'DIVISIBLE_BY': [null, Order.MULTIPLICATIVE,
+    'DIVISIBLE_BY': [null, Order.MULTIPLICATIVE, Order.RELATIONAL],
-        Order.RELATIONAL],
     'PRIME': [null, Order.NONE, Order.FUNCTION_CALL],
-  }
+  };
-  const dropdownProperty = block.getFieldValue('PROPERTY');
+  type PropertyOption = keyof typeof PROPERTIES;
+  const dropdownProperty = block.getFieldValue('PROPERTY') as PropertyOption;
   const [suffix, inputOrder, outputOrder] = PROPERTIES[dropdownProperty];
-  const numberToCheck = generator.valueToCode(block, 'NUMBER_TO_CHECK',
+  const numberToCheck =
-      inputOrder) || '0';
+    generator.valueToCode(block, 'NUMBER_TO_CHECK', inputOrder) || '0';
   let code;
   if (dropdownProperty === 'PRIME') {
     // Prime is a special case as it is not a one-liner test.
-    generator.definitions_['import_math'] = 'import math';
+    (generator as AnyDuringMigration).definitions_['import_math'] =
-    generator.definitions_['from_numbers_import_Number'] =
+      'import math';
-        'from numbers import Number';
+    (generator as AnyDuringMigration).definitions_[
-    const functionName = generator.provideFunction_('math_isPrime', `
+      'from_numbers_import_Number'
+    ] = 'from numbers import Number';
+    const functionName = generator.provideFunction_(
+      'math_isPrime',
+      `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(n):
   # https://en.wikipedia.org/wiki/Primality_test#Naive_methods
   # If n is not a number but a string, try parsing it.
@@ -193,11 +212,12 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(n):
     if n % (x - 1) == 0 or n % (x + 1) == 0:
       return False
   return True
-`);
+`,
+    );
     code = functionName + '(' + numberToCheck + ')';
   } else if (dropdownProperty === 'DIVISIBLE_BY') {
-    const divisor = generator.valueToCode(block, 'DIVISOR',
+    const divisor =
-        Order.MULTIPLICATIVE) || '0';
+      generator.valueToCode(block, 'DIVISOR', Order.MULTIPLICATIVE) || '0';
     // If 'divisor' is some code that evals to 0, generator will raise an error.
     if (divisor === '0') {
       return ['False', Order.ATOMIC];
@@ -205,27 +225,38 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(n):
     code = numberToCheck + ' % ' + divisor + ' == 0';
   } else {
     code = numberToCheck + suffix;
-  };
+  }
   return [code, outputOrder];
-};
+}
 
-export function math_change(block, generator) {
+export function math_change(block: Block, generator: PythonGenerator) {
   // Add to a variable in place.
-  generator.definitions_['from_numbers_import_Number'] =
+  (generator as AnyDuringMigration).definitions_['from_numbers_import_Number'] =
     'from numbers import Number';
   const argument0 =
     generator.valueToCode(block, 'DELTA', Order.ADDITIVE) || '0';
   const varName = generator.getVariableName(block.getFieldValue('VAR'));
-  return varName + ' = (' + varName + ' if isinstance(' + varName +
+  return (
-      ', Number) else 0) + ' + argument0 + '\n';
+    varName +
-};
+    ' = (' +
+    varName +
+    ' if isinstance(' +
+    varName +
+    ', Number) else 0) + ' +
+    argument0 +
+    '\n'
+  );
+}
 
 // Rounding functions have a single operand.
 export const math_round = math_single;
 // Trigonometry functions have a single operand.
 export const math_trig = math_single;
 
-export function math_on_list(block, generator) {
+export function math_on_list(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Math functions for lists.
   const func = block.getFieldValue('OP');
   const list = generator.valueToCode(block, 'LIST', Order.NONE) || '[]';
@@ -241,25 +272,32 @@ export function math_on_list(block, generator) {
       code = 'max(' + list + ')';
       break;
     case 'AVERAGE': {
-      generator.definitions_['from_numbers_import_Number'] =
+      (generator as AnyDuringMigration).definitions_[
-          'from numbers import Number';
+        'from_numbers_import_Number'
+      ] = 'from numbers import Number';
       // This operation excludes null and values that aren't int or float:
       // math_mean([null, null, "aString", 1, 9]) -> 5.0
-      const functionName = generator.provideFunction_('math_mean', `
+      const functionName = generator.provideFunction_(
+        'math_mean',
+        `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(myList):
   localList = [e for e in myList if isinstance(e, Number)]
   if not localList: return
   return float(sum(localList)) / len(localList)
-`);
+`,
+      );
       code = functionName + '(' + list + ')';
       break;
     }
     case 'MEDIAN': {
-      generator.definitions_['from_numbers_import_Number'] =
+      (generator as AnyDuringMigration).definitions_[
-          'from numbers import Number';
+        'from_numbers_import_Number'
+      ] = 'from numbers import Number';
       // This operation excludes null values:
       // math_median([null, null, 1, 3]) -> 2.0
-      const functionName = generator.provideFunction_( 'math_median', `
+      const functionName = generator.provideFunction_(
+        'math_median',
+        `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(myList):
   localList = sorted([e for e in myList if isinstance(e, Number)])
   if not localList: return
@@ -267,7 +305,8 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(myList):
     return (localList[len(localList) // 2 - 1] + localList[len(localList) // 2]) / 2.0
   else:
     return localList[(len(localList) - 1) // 2]
-`);
+`,
+      );
       code = functionName + '(' + list + ')';
       break;
     }
@@ -275,7 +314,9 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(myList):
       // As a list of numbers can contain more than one mode,
       // the returned result is provided as an array.
       // Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1]
-      const functionName = generator.provideFunction_('math_modes', `
+      const functionName = generator.provideFunction_(
+        'math_modes',
+        `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(some_list):
   modes = []
   # Using a lists of [item, count] to keep count rather than dict
@@ -295,84 +336,99 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(some_list):
     if item_count == maxCount:
       modes.append(counted_item)
   return modes
-`);
+`,
+      );
       code = functionName + '(' + list + ')';
       break;
     }
     case 'STD_DEV': {
-      generator.definitions_['import_math'] = 'import math';
+      (generator as AnyDuringMigration).definitions_['import_math'] =
-      const functionName =
+        'import math';
-          generator.provideFunction_('math_standard_deviation', `
+      const functionName = generator.provideFunction_(
+        'math_standard_deviation',
+        `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(numbers):
   n = len(numbers)
   if n == 0: return
   mean = float(sum(numbers)) / n
   variance = sum((x - mean) ** 2 for x in numbers) / n
   return math.sqrt(variance)
-`);
+`,
+      );
       code = functionName + '(' + list + ')';
       break;
     }
     case 'RANDOM':
-      generator.definitions_['import_random'] = 'import random';
+      (generator as AnyDuringMigration).definitions_['import_random'] =
+        'import random';
       code = 'random.choice(' + list + ')';
       break;
     default:
       throw Error('Unknown operator: ' + func);
   }
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function math_modulo(block, generator) {
+export function math_modulo(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Remainder computation.
   const argument0 =
-      generator.valueToCode(block, 'DIVIDEND', Order.MULTIPLICATIVE) ||
+    generator.valueToCode(block, 'DIVIDEND', Order.MULTIPLICATIVE) || '0';
-      '0';
   const argument1 =
-      generator.valueToCode(block, 'DIVISOR', Order.MULTIPLICATIVE) ||
+    generator.valueToCode(block, 'DIVISOR', Order.MULTIPLICATIVE) || '0';
-      '0';
   const code = argument0 + ' % ' + argument1;
   return [code, Order.MULTIPLICATIVE];
-};
+}
 
-export function math_constrain(block, generator) {
+export function math_constrain(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Constrain a number between two limits.
-  const argument0 =
+  const argument0 = generator.valueToCode(block, 'VALUE', Order.NONE) || '0';
-      generator.valueToCode(block, 'VALUE', Order.NONE) || '0';
+  const argument1 = generator.valueToCode(block, 'LOW', Order.NONE) || '0';
-  const argument1 =
-      generator.valueToCode(block, 'LOW', Order.NONE) || '0';
   const argument2 =
-      generator.valueToCode(block, 'HIGH', Order.NONE) ||
+    generator.valueToCode(block, 'HIGH', Order.NONE) || "float('inf')";
-      'float(\'inf\')';
   const code =
     'min(max(' + argument0 + ', ' + argument1 + '), ' + argument2 + ')';
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function math_random_int(block, generator) {
+export function math_random_int(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Random integer between [X] and [Y].
-  generator.definitions_['import_random'] = 'import random';
+  (generator as AnyDuringMigration).definitions_['import_random'] =
-  const argument0 =
+    'import random';
-      generator.valueToCode(block, 'FROM', Order.NONE) || '0';
+  const argument0 = generator.valueToCode(block, 'FROM', Order.NONE) || '0';
-  const argument1 =
+  const argument1 = generator.valueToCode(block, 'TO', Order.NONE) || '0';
-      generator.valueToCode(block, 'TO', Order.NONE) || '0';
   const code = 'random.randint(' + argument0 + ', ' + argument1 + ')';
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function math_random_float(block, generator) {
+export function math_random_float(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Random fraction between 0 and 1.
-  generator.definitions_['import_random'] = 'import random';
+  (generator as AnyDuringMigration).definitions_['import_random'] =
+    'import random';
   return ['random.random()', Order.FUNCTION_CALL];
-};
+}
 
-export function math_atan2(block, generator) {
+export function math_atan2(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Arctangent of point (X, Y) in degrees from -180 to 180.
-  generator.definitions_['import_math'] = 'import math';
+  (generator as AnyDuringMigration).definitions_['import_math'] = 'import math';
   const argument0 = generator.valueToCode(block, 'X', Order.NONE) || '0';
   const argument1 = generator.valueToCode(block, 'Y', Order.NONE) || '0';
   return [
     'math.atan2(' + argument1 + ', ' + argument0 + ') / math.pi * 180',
-    Order.MULTIPLICATIVE
+    Order.MULTIPLICATIVE,
   ];
-};
+}

generators/python/procedures.ts

@@ -11,11 +11,13 @@
 // Former goog.module ID: Blockly.Python.procedures
 
 import * as Variables from '../../core/variables.js';
+import type {Block} from '../../core/block.js';
+import type {IfReturnBlock} from '../../blocks/procedures.js';
 import {NameType} from '../../core/names.js';
 import {Order} from './python_generator.js';
+import type {PythonGenerator} from './python_generator.js';
 
-
+export function procedures_defreturn(block: Block, generator: PythonGenerator) {
-export function procedures_defreturn(block, generator) {
   // Define a procedure with a return value.
   // First, add a 'global' statement for every variable that is not shadowed by
   // a local parameter.
@@ -33,15 +35,14 @@ export function procedures_defreturn(block, generator) {
   const devVarList = Variables.allDeveloperVariables(workspace);
   for (let i = 0; i < devVarList.length; i++) {
     globals.push(
-        generator.nameDB_.getName(
+      generator.nameDB_!.getName(devVarList[i], NameType.DEVELOPER_VARIABLE),
-          devVarList[i], NameType.DEVELOPER_VARIABLE));
+    );
   }
 
-  const globalString = globals.length ?
+  const globalString = globals.length
-      generator.INDENT + 'global ' + globals.join(', ') + '\n' :
+    ? generator.INDENT + 'global ' + globals.join(', ') + '\n'
-      '';
+    : '';
-  const funcName =
+  const funcName = generator.getProcedureName(block.getFieldValue('NAME'));
-      generator.getProcedureName(block.getFieldValue('NAME'));
   let xfix1 = '';
   if (generator.STATEMENT_PREFIX) {
     xfix1 += generator.injectId(generator.STATEMENT_PREFIX, block);
@@ -56,11 +57,11 @@ export function procedures_defreturn(block, generator) {
   if (generator.INFINITE_LOOP_TRAP) {
     loopTrap = generator.prefixLines(
       generator.injectId(generator.INFINITE_LOOP_TRAP, block),
-        generator.INDENT);
+      generator.INDENT,
+    );
   }
   let branch = generator.statementToCode(block, 'STACK');
-  let returnValue =
+  let returnValue = generator.valueToCode(block, 'RETURN', Order.NONE) || '';
-      generator.valueToCode(block, 'RETURN', Order.NONE) || '';
   let xfix2 = '';
   if (branch && returnValue) {
     // After executing the function body, revisit this block for the return.
@@ -76,41 +77,57 @@ export function procedures_defreturn(block, generator) {
   for (let i = 0; i < variables.length; i++) {
     args[i] = generator.getVariableName(variables[i]);
   }
-  let code = 'def ' + funcName + '(' + args.join(', ') + '):\n' + globalString +
+  let code =
-      xfix1 + loopTrap + branch + xfix2 + returnValue;
+    'def ' +
+    funcName +
+    '(' +
+    args.join(', ') +
+    '):\n' +
+    globalString +
+    xfix1 +
+    loopTrap +
+    branch +
+    xfix2 +
+    returnValue;
   code = generator.scrub_(block, code);
   // Add % so as not to collide with helper functions in definitions list.
-  generator.definitions_['%' + funcName] = code;
+  // TODO(#7600): find better approach than casting to any to override
+  // CodeGenerator declaring .definitions protected.
+  (generator as AnyDuringMigration).definitions_['%' + funcName] = code;
   return null;
-};
+}
 
 // Defining a procedure without a return value uses the same generator as
 // a procedure with a return value.
 export const procedures_defnoreturn = procedures_defreturn;
 
-export function procedures_callreturn(block, generator) {
+export function procedures_callreturn(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Call a procedure with a return value.
-  const funcName =
+  const funcName = generator.getProcedureName(block.getFieldValue('NAME'));
-      generator.getProcedureName(block.getFieldValue('NAME'));
   const args = [];
   const variables = block.getVars();
   for (let i = 0; i < variables.length; i++) {
-    args[i] =
+    args[i] = generator.valueToCode(block, 'ARG' + i, Order.NONE) || 'None';
-        generator.valueToCode(block, 'ARG' + i, Order.NONE) || 'None';
   }
   const code = funcName + '(' + args.join(', ') + ')';
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function procedures_callnoreturn(block, generator) {
+export function procedures_callnoreturn(
+  block: Block,
+  generator: PythonGenerator,
+) {
   // Call a procedure with no return value.
   // Generated code is for a function call as a statement is the same as a
   // function call as a value, with the addition of line ending.
-  const tuple = generator.forBlock['procedures_callreturn'](block, generator);
+  const tuple = generator.forBlock['procedures_callreturn'](block, generator)!;
   return tuple[0] + '\n';
-};
+}
 
-export function procedures_ifreturn(block, generator) {
+export function procedures_ifreturn(block: Block, generator: PythonGenerator) {
   // Conditionally return value from a procedure.
   const condition =
     generator.valueToCode(block, 'CONDITION', Order.NONE) || 'False';
@@ -119,15 +136,15 @@ export function procedures_ifreturn(block, generator) {
     // Inject any statement suffix here since the regular one at the end
     // will not get executed if the return is triggered.
     code += generator.prefixLines(
-        generator.injectId(
+      generator.injectId(generator.STATEMENT_SUFFIX, block),
-          generator.STATEMENT_SUFFIX, block), generator.INDENT);
+      generator.INDENT,
+    );
   }
-  if (block.hasReturnValue_) {
+  if ((block as IfReturnBlock).hasReturnValue_) {
-    const value =
+    const value = generator.valueToCode(block, 'VALUE', Order.NONE) || 'None';
-        generator.valueToCode(block, 'VALUE', Order.NONE) || 'None';
     code += generator.INDENT + 'return ' + value + '\n';
   } else {
     code += generator.INDENT + 'return\n';
   }
   return code;
-};
+}

generators/python/python_generator.ts

@@ -5,49 +5,48 @@
  */
 
 /**
- * @fileoverview Helper functions for generating Python for blocks.
+ * @file Python code generator class, including helper methods for
- * @suppress {checkTypes|globalThis}
+ * generating Python for blocks.
  */
 
 // Former goog.module ID: Blockly.Python
 
 import * as stringUtils from '../../core/utils/string.js';
 import * as Variables from '../../core/variables.js';
-// import type {Block} from '../../core/block.js';
+import type {Block} from '../../core/block.js';
 import {CodeGenerator} from '../../core/generator.js';
 import {Names} from '../../core/names.js';
-// import type {Workspace} from '../../core/workspace.js';
+import type {Workspace} from '../../core/workspace.js';
 import {inputTypes} from '../../core/inputs/input_types.js';
 
-
 /**
  * Order of operation ENUMs.
  * http://docs.python.org/reference/expressions.html#summary
- * @enum {number}
  */
-export const Order = {
+// prettier-ignore
-  ATOMIC: 0,             // 0 "" ...
+export enum Order {
-  COLLECTION: 1,         // tuples, lists, dictionaries
+  ATOMIC = 0,             // 0 "" ...
-  STRING_CONVERSION: 1,  // `expression...`
+  COLLECTION = 1,         // tuples, lists, dictionaries
-  MEMBER: 2.1,           // . []
+  STRING_CONVERSION = 1,  // `expression...`
-  FUNCTION_CALL: 2.2,    // ()
+  MEMBER = 2.1,           // . []
-  EXPONENTIATION: 3,     // **
+  FUNCTION_CALL = 2.2,    // ()
-  UNARY_SIGN: 4,         // + -
+  EXPONENTIATION = 3,     // **
-  BITWISE_NOT: 4,        // ~
+  UNARY_SIGN = 4,         // + -
-  MULTIPLICATIVE: 5,     // * / // %
+  BITWISE_NOT = 4,        // ~
-  ADDITIVE: 6,           // + -
+  MULTIPLICATIVE = 5,     // * / // %
-  BITWISE_SHIFT: 7,      // << >>
+  ADDITIVE = 6,           // + -
-  BITWISE_AND: 8,        // &
+  BITWISE_SHIFT = 7,      // << >>
-  BITWISE_XOR: 9,        // ^
+  BITWISE_AND = 8,        // &
-  BITWISE_OR: 10,        // |
+  BITWISE_XOR = 9,        // ^
-  RELATIONAL: 11,        // in, not in, is, is not, >, >=, <>, !=, ==
+  BITWISE_OR = 10,        // |
-  LOGICAL_NOT: 12,       // not
+  RELATIONAL = 11,        // in, not in, is, is not, >, >=, <>, !=, ==
-  LOGICAL_AND: 13,       // and
+  LOGICAL_NOT = 12,       // not
-  LOGICAL_OR: 14,        // or
+  LOGICAL_AND = 13,       // and
-  CONDITIONAL: 15,       // if else
+  LOGICAL_OR = 14,        // or
-  LAMBDA: 16,            // lambda
+  CONDITIONAL = 15,       // if else
-  NONE: 99,              // (...)
+  LAMBDA = 16,            // lambda
-};
+  NONE = 99,              // (...)
+}
 
 /**
  * PythonScript code generator class.
@@ -55,9 +54,8 @@ export const Order = {
 export class PythonGenerator extends CodeGenerator {
   /**
    * List of outer-inner pairings that do NOT require parentheses.
-   * @type {!Array<!Array<number>>}
    */
-  ORDER_OVERRIDES = [
+  ORDER_OVERRIDES: number[][] = [
     // (foo()).bar -> foo().bar
     // (foo())[0] -> foo()[0]
     [Order.FUNCTION_CALL, Order.MEMBER],
@@ -77,11 +75,17 @@ export class PythonGenerator extends CodeGenerator {
     // a and (b and c) -> a and b and c
     [Order.LOGICAL_AND, Order.LOGICAL_AND],
     // a or (b or c) -> a or b or c
-    [Order.LOGICAL_OR, Order.LOGICAL_OR]
+    [Order.LOGICAL_OR, Order.LOGICAL_OR],
   ];
 
-  constructor(name) {
+  /**
-    super(name ?? 'Python');
+   * Empty loops or conditionals are not allowed in Python.
+   */
+  PASS: string = ''; // Initialised by init().
+
+  /** @param name Name of the language the generator is for. */
+  constructor(name = 'Python') {
+    super(name);
     this.isInitialized = false;
 
     // Copy Order values onto instance for backwards compatibility
@@ -92,7 +96,16 @@ export class PythonGenerator extends CodeGenerator {
     // replace data properties with get accessors that call
     // deprecate.warn().)
     for (const key in Order) {
-      this['ORDER_' + key] = Order[key];
+      // Must assign Order[key] to a temporary to get the type guard to work;
+      // see https://github.com/microsoft/TypeScript/issues/10530.
+      const value = Order[key];
+      // Skip reverse-lookup entries in the enum.  Due to
+      // https://github.com/microsoft/TypeScript/issues/55713 this (as
+      // of TypeScript 5.5.2) actually narrows the type of value to
+      // never - but that still allows the following assignment to
+      // succeed.
+      if (typeof value === 'string') continue;
+      (this as unknown as Record<string, Order>)['ORDER_' + key] = value;
     }
 
     // List of illegal variable names.  This is not intended to be a
@@ -139,21 +152,18 @@ export class PythonGenerator extends CodeGenerator {
         'map,max,memoryview,min,next,object,oct,open,ord,pow,print,property,' +
         'quit,range,raw_input,reduce,reload,repr,reversed,round,set,setattr,' +
         'slice,sorted,staticmethod,str,sum,super,tuple,type,unichr,unicode,' +
-      'vars,xrange,zip'
+        'vars,xrange,zip',
     );
   }
 
   /**
    * Initialise the database of variable names.
-   * @param {!Workspace} workspace Workspace to generate code from.
+   *
-   * @this {CodeGenerator}
+   * @param workspace Workspace to generate code from.
    */
-  init(workspace) {
+  init(workspace: Workspace) {
     super.init(workspace);
 
-    /**
-     * Empty loops or conditionals are not allowed in Python.
-     */
     this.PASS = this.INDENT + 'pass\n';
 
     if (!this.nameDB_) {
@@ -172,15 +182,14 @@ export class PythonGenerator extends CodeGenerator {
     for (let i = 0; i < devVarList.length; i++) {
       defvars.push(
         this.nameDB_.getName(devVarList[i], Names.DEVELOPER_VARIABLE_TYPE) +
-          ' = None');
+          ' = None',
+      );
     }
 
     // Add user variables, but only ones that are being used.
     const variables = Variables.allUsedVarModels(workspace);
     for (let i = 0; i < variables.length; i++) {
-      defvars.push(
+      defvars.push(this.getVariableName(variables[i].getId()) + ' = None');
-          this.getVariableName(variables[i].getId()) +
-          ' = None');
     }
 
     this.definitions_['variables'] = defvars.join('\n');
@@ -189,10 +198,11 @@ export class PythonGenerator extends CodeGenerator {
 
   /**
    * Prepend the generated code with import statements and variable definitions.
-   * @param {string} code Generated code.
+   *
-   * @return {string} Completed code.
+   * @param code Generated code.
+   * @returns Completed code.
    */
-  finish(code) {
+  finish(code: string): string {
     // Convert the definitions dictionary into a list.
     const imports = [];
     const definitions = [];
@@ -208,7 +218,7 @@ export class PythonGenerator extends CodeGenerator {
     code = super.finish(code);
     this.isInitialized = false;
 
-    this.nameDB_.reset();
+    this.nameDB_!.reset();
     const allDefs = imports.join('\n') + '\n\n' + definitions.join('\n\n');
     return allDefs.replace(/\n\n+/g, '\n\n').replace(/\n*$/, '\n\n\n') + code;
   }
@@ -216,28 +226,30 @@ export class PythonGenerator extends CodeGenerator {
   /**
    * Naked values are top-level blocks with outputs that aren't plugged into
    * anything.
-   * @param {string} line Line of generated code.
+   *
-   * @return {string} Legal line of code.
+   * @param line Line of generated code.
+   * @returns Legal line of code.
    */
-  scrubNakedValue(line) {
+  scrubNakedValue(line: string): string {
     return line + '\n';
   }
 
   /**
    * Encode a string as a properly escaped Python string, complete with quotes.
-   * @param {string} string Text to encode.
+   *
-   * @return {string} Python string.
+   * @param string Text to encode.
+   * @returns Python string.
    */
-  quote_(string) {
+  quote_(string: string): string {
     string = string.replace(/\\/g, '\\\\').replace(/\n/g, '\\\n');
 
     // Follow the CPython behaviour of repr() for a non-byte string.
-    let quote = '\'';
+    let quote = "'";
-    if (string.indexOf('\'') !== -1) {
+    if (string.indexOf("'") !== -1) {
       if (string.indexOf('"') === -1) {
         quote = '"';
       } else {
-        string = string.replace(/'/g, '\\\'');
+        string = string.replace(/'/g, "\\'");
       }
     }
     return quote + string + quote;
@@ -246,27 +258,29 @@ export class PythonGenerator extends CodeGenerator {
   /**
    * Encode a string as a properly escaped multiline Python string, complete
    * with quotes.
-   * @param {string} string Text to encode.
+   *
-   * @return {string} Python string.
+   * @param string Text to encode.
+   * @returns Python string.
    */
-  multiline_quote_(string) {
+  multiline_quote_(string: string): string {
     const lines = string.split(/\n/g).map(this.quote_);
     // Join with the following, plus a newline:
     // + '\n' +
-    return lines.join(' + \'\\n\' + \n');
+    return lines.join(" + '\\n' + \n");
   }
 
   /**
    * Common tasks for generating Python from blocks.
    * Handles comments for the specified block and any connected value blocks.
    * Calls any statements following this block.
-   * @param {!Block} block The current block.
+   *
-   * @param {string} code The Python code created for this block.
+   * @param block The current block.
-   * @param {boolean=} opt_thisOnly True to generate code for only this statement.
+   * @param code The Python code created for this block.
-   * @return {string} Python code with comments and subsequent blocks added.
+   * @param thisOnly True to generate code for only this statement.
-   * @protected
+   * @returns Python code with comments and subsequent blocks added.
+
    */
-  scrub_(block, code, opt_thisOnly) {
+  scrub_(block: Block, code: string, thisOnly = false): string {
     let commentCode = '';
     // Only collect comments for blocks that aren't inline.
     if (!block.outputConnection || !block.outputConnection.targetConnection) {
@@ -280,7 +294,7 @@ export class PythonGenerator extends CodeGenerator {
       // Don't collect comments for nested statements.
       for (let i = 0; i < block.inputList.length; i++) {
         if (block.inputList[i].type === inputTypes.VALUE) {
-          const childBlock = block.inputList[i].connection.targetBlock();
+          const childBlock = block.inputList[i].connection!.targetBlock();
           if (childBlock) {
             comment = this.allNestedComments(childBlock);
             if (comment) {
@@ -290,33 +304,40 @@ export class PythonGenerator extends CodeGenerator {
         }
       }
     }
-    const nextBlock = block.nextConnection && block.nextConnection.targetBlock();
+    const nextBlock =
-    const nextCode = opt_thisOnly ? '' : this.blockToCode(nextBlock);
+      block.nextConnection && block.nextConnection.targetBlock();
+    const nextCode = thisOnly ? '' : this.blockToCode(nextBlock);
     return commentCode + code + nextCode;
   }
 
   /**
    * Gets a property and adjusts the value, taking into account indexing.
    * If a static int, casts to an integer, otherwise returns a code string.
-   * @param {!Block} block The block.
+   *
-   * @param {string} atId The property ID of the element to get.
+   * @param block The block.
-   * @param {number=} opt_delta Value to add.
+   * @param atId The ID of the input block to get (and adjust) the value of.
-   * @param {boolean=} opt_negate Whether to negate the value.
+   * @param delta Value to add.
-   * @return {string|number}
+   * @param negate Whether to negate the value.
+   * @returns The adjusted value.
    */
-  getAdjustedInt(block, atId, opt_delta, opt_negate) {
+  getAdjustedInt(
-    let delta = opt_delta || 0;
+    block: Block,
+    atId: string,
+    delta = 0,
+    negate = false,
+  ): string | number {
     if (block.workspace.options.oneBasedIndex) {
       delta--;
     }
     const defaultAtIndex = block.workspace.options.oneBasedIndex ? '1' : '0';
-    const atOrder = delta ? this.ORDER_ADDITIVE : this.ORDER_NONE;
+    const atOrder = delta ? Order.ADDITIVE : Order.NONE;
-    let at = this.valueToCode(block, atId, atOrder) || defaultAtIndex;
+    let at: string | number =
+      this.valueToCode(block, atId, atOrder) || defaultAtIndex;
 
     if (stringUtils.isNumber(at)) {
       // If the index is a naked number, adjust it right now.
       at = parseInt(at, 10) + delta;
-      if (opt_negate) {
+      if (negate) {
         at = -at;
       }
     } else {
@@ -328,7 +349,7 @@ export class PythonGenerator extends CodeGenerator {
       } else {
         at = 'int(' + at + ')';
       }
-      if (opt_negate) {
+      if (negate) {
         at = '-' + at;
       }
     }

generators/python/text.ts

@@ -11,23 +11,30 @@
 // Former goog.module ID: Blockly.Python.texts
 
 import * as stringUtils from '../../core/utils/string.js';
+import type {Block} from '../../core/block.js';
+import type {JoinMutatorBlock} from '../../blocks/text.js';
 import {NameType} from '../../core/names.js';
 import {Order} from './python_generator.js';
+import type {PythonGenerator} from './python_generator.js';
 
-
+export function text(
-export function text(block, generator) {
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Text value.
   const code = generator.quote_(block.getFieldValue('TEXT'));
   return [code, Order.ATOMIC];
-};
+}
 
-export function text_multiline(block, generator) {
+export function text_multiline(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Text value.
   const code = generator.multiline_quote_(block.getFieldValue('TEXT'));
-  const order =
+  const order = code.indexOf('+') !== -1 ? Order.ADDITIVE : Order.ATOMIC;
-      code.indexOf('+') !== -1 ? Order.ADDITIVE : Order.ATOMIC;
   return [code, order];
-};
+}
 
 /**
  * Regular expression to detect a single-quoted string literal.
@@ -37,95 +44,113 @@ const strRegExp = /^\s*'([^']|\\')*'\s*$/;
 /**
  * Enclose the provided value in 'str(...)' function.
  * Leave string literals alone.
- * @param {string} value Code evaluating to a value.
+ *
- * @return {Array<string|number>} Array containing code evaluating to a string
+ * @param value Code evaluating to a value.
+ * @returns Array containing code evaluating to a string
  *     and
  *    the order of the returned code.[string, number]
  */
-const forceString = function(value) {
+const forceString = function (value: string): [string, Order] {
   if (strRegExp.test(value)) {
     return [value, Order.ATOMIC];
   }
   return ['str(' + value + ')', Order.FUNCTION_CALL];
 };
 
-export function text_join(block, generator) {
+export function text_join(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
+  const joinBlock = block as JoinMutatorBlock;
   // Create a string made up of any number of elements of any type.
   // Should we allow joining by '-' or ',' or any other characters?
-  switch (block.itemCount_) {
+  switch (joinBlock.itemCount_) {
     case 0:
       return ["''", Order.ATOMIC];
     case 1: {
-      const element =
+      const element = generator.valueToCode(block, 'ADD0', Order.NONE) || "''";
-          generator.valueToCode(block, 'ADD0', Order.NONE) || "''";
       const codeAndOrder = forceString(element);
       return codeAndOrder;
     }
     case 2: {
-      const element0 =
+      const element0 = generator.valueToCode(block, 'ADD0', Order.NONE) || "''";
-          generator.valueToCode(block, 'ADD0', Order.NONE) || "''";
+      const element1 = generator.valueToCode(block, 'ADD1', Order.NONE) || "''";
-      const element1 =
-          generator.valueToCode(block, 'ADD1', Order.NONE) || "''";
       const code = forceString(element0)[0] + ' + ' + forceString(element1)[0];
       return [code, Order.ADDITIVE];
     }
     default: {
       const elements = [];
-      for (let i = 0; i < block.itemCount_; i++) {
+      for (let i = 0; i < joinBlock.itemCount_; i++) {
         elements[i] =
           generator.valueToCode(block, 'ADD' + i, Order.NONE) || "''";
       }
-      const tempVar =
+      const tempVar = generator.nameDB_!.getDistinctName(
-          generator.nameDB_.getDistinctName('x', NameType.VARIABLE);
+        'x',
-      const code = '\'\'.join([str(' + tempVar + ') for ' + tempVar + ' in [' +
+        NameType.VARIABLE,
-          elements.join(', ') + ']])';
+      );
+      const code =
+        "''.join([str(" +
+        tempVar +
+        ') for ' +
+        tempVar +
+        ' in [' +
+        elements.join(', ') +
+        ']])';
       return [code, Order.FUNCTION_CALL];
     }
   }
-};
+}
 
-export function text_append(block, generator) {
+export function text_append(block: Block, generator: PythonGenerator) {
   // Append to a variable in place.
-  const varName =
+  const varName = generator.getVariableName(block.getFieldValue('VAR'));
-      generator.getVariableName(block.getFieldValue('VAR'));
   const value = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
   return varName + ' = str(' + varName + ') + ' + forceString(value)[0] + '\n';
-};
+}
 
-export function text_length(block, generator) {
+export function text_length(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Is the string null or array empty?
   const text = generator.valueToCode(block, 'VALUE', Order.NONE) || "''";
   return ['len(' + text + ')', Order.FUNCTION_CALL];
-};
+}
 
-export function text_isEmpty(block, generator) {
+export function text_isEmpty(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Is the string null or array empty?
   const text = generator.valueToCode(block, 'VALUE', Order.NONE) || "''";
   const code = 'not len(' + text + ')';
   return [code, Order.LOGICAL_NOT];
-};
+}
 
-export function text_indexOf(block, generator) {
+export function text_indexOf(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Search the text for a substring.
   // Should we allow for non-case sensitive???
   const operator = block.getFieldValue('END') === 'FIRST' ? 'find' : 'rfind';
-  const substring =
+  const substring = generator.valueToCode(block, 'FIND', Order.NONE) || "''";
-      generator.valueToCode(block, 'FIND', Order.NONE) || "''";
+  const text = generator.valueToCode(block, 'VALUE', Order.MEMBER) || "''";
-  const text =
-      generator.valueToCode(block, 'VALUE', Order.MEMBER) || "''";
   const code = text + '.' + operator + '(' + substring + ')';
   if (block.workspace.options.oneBasedIndex) {
     return [code + ' + 1', Order.ADDITIVE];
   }
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function text_charAt(block, generator) {
+export function text_charAt(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Get letter at index.
   // Note: Until January 2013 this block did not have the WHERE input.
   const where = block.getFieldValue('WHERE') || 'FROM_START';
-  const textOrder =
+  const textOrder = where === 'RANDOM' ? Order.NONE : Order.MEMBER;
-      (where === 'RANDOM') ? Order.NONE : Order.MEMBER;
   const text = generator.valueToCode(block, 'VALUE', textOrder) || "''";
   switch (where) {
     case 'FIRST': {
@@ -147,26 +172,33 @@ export function text_charAt(block, generator) {
       return [code, Order.MEMBER];
     }
     case 'RANDOM': {
-      generator.definitions_['import_random'] = 'import random';
+      // TODO(#7600): find better approach than casting to any to override
-      const functionName =
+      // CodeGenerator declaring .definitions protected (here and below).
-          generator.provideFunction_('text_random_letter', `
+      (generator as AnyDuringMigration).definitions_['import_random'] =
+        'import random';
+      const functionName = generator.provideFunction_(
+        'text_random_letter',
+        `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(text):
   x = int(random.random() * len(text))
   return text[x]
-`);
+`,
+      );
       const code = functionName + '(' + text + ')';
       return [code, Order.FUNCTION_CALL];
     }
   }
   throw Error('Unhandled option (text_charAt).');
-};
+}
 
-export function text_getSubstring(block, generator) {
+export function text_getSubstring(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Get substring.
   const where1 = block.getFieldValue('WHERE1');
   const where2 = block.getFieldValue('WHERE2');
-  const text =
+  const text = generator.valueToCode(block, 'STRING', Order.MEMBER) || "''";
-      generator.valueToCode(block, 'STRING', Order.MEMBER) || "''";
   let at1;
   switch (where1) {
     case 'FROM_START':
@@ -195,7 +227,8 @@ export function text_getSubstring(block, generator) {
       // Ensure that if the result calculated is 0 that sub-sequence will
       // include all elements as expected.
       if (!stringUtils.isNumber(String(at2))) {
-        generator.definitions_['import_sys'] = 'import sys';
+        (generator as AnyDuringMigration).definitions_['import_sys'] =
+          'import sys';
         at2 += ' or sys.maxsize';
       } else if (at2 === 0) {
         at2 = '';
@@ -209,49 +242,63 @@ export function text_getSubstring(block, generator) {
   }
   const code = text + '[' + at1 + ' : ' + at2 + ']';
   return [code, Order.MEMBER];
-};
+}
 
-export function text_changeCase(block, generator) {
+export function text_changeCase(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Change capitalization.
   const OPERATORS = {
     'UPPERCASE': '.upper()',
     'LOWERCASE': '.lower()',
-    'TITLECASE': '.title()'
+    'TITLECASE': '.title()',
   };
-  const operator = OPERATORS[block.getFieldValue('CASE')];
+  type OperatorOption = keyof typeof OPERATORS;
+  const operator = OPERATORS[block.getFieldValue('CASE') as OperatorOption];
   const text = generator.valueToCode(block, 'TEXT', Order.MEMBER) || "''";
   const code = text + operator;
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function text_trim(block, generator) {
+export function text_trim(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Trim spaces.
   const OPERATORS = {
     'LEFT': '.lstrip()',
     'RIGHT': '.rstrip()',
-    'BOTH': '.strip()'
+    'BOTH': '.strip()',
   };
-  const operator = OPERATORS[block.getFieldValue('MODE')];
+  type OperatorOption = keyof typeof OPERATORS;
+  const operator = OPERATORS[block.getFieldValue('MODE') as OperatorOption];
   const text = generator.valueToCode(block, 'TEXT', Order.MEMBER) || "''";
   const code = text + operator;
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function text_print(block, generator) {
+export function text_print(block: Block, generator: PythonGenerator) {
   // Print statement.
   const msg = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
   return 'print(' + msg + ')\n';
-};
+}
 
-export function text_prompt_ext(block, generator) {
+export function text_prompt_ext(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   // Prompt function.
-  const functionName = generator.provideFunction_('text_prompt', `
+  const functionName = generator.provideFunction_(
+    'text_prompt',
+    `
 def ${generator.FUNCTION_NAME_PLACEHOLDER_}(msg):
   try:
     return raw_input(msg)
   except NameError:
     return input(msg)
-`);
+`,
+  );
   let msg;
   if (block.getField('TEXT')) {
     // Internal message.
@@ -266,27 +313,36 @@ def ${generator.FUNCTION_NAME_PLACEHOLDER_}(msg):
     code = 'float(' + code + ')';
   }
   return [code, Order.FUNCTION_CALL];
-};
+}
 
 export const text_prompt = text_prompt_ext;
 
-export function text_count(block, generator) {
+export function text_count(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   const text = generator.valueToCode(block, 'TEXT', Order.MEMBER) || "''";
   const sub = generator.valueToCode(block, 'SUB', Order.NONE) || "''";
   const code = text + '.count(' + sub + ')';
   return [code, Order.FUNCTION_CALL];
-};
+}
 
-export function text_replace(block, generator) {
+export function text_replace(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   const text = generator.valueToCode(block, 'TEXT', Order.MEMBER) || "''";
   const from = generator.valueToCode(block, 'FROM', Order.NONE) || "''";
   const to = generator.valueToCode(block, 'TO', Order.NONE) || "''";
   const code = text + '.replace(' + from + ', ' + to + ')';
   return [code, Order.MEMBER];
-};
+}
 
-export function text_reverse(block, generator) {
+export function text_reverse(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
   const text = generator.valueToCode(block, 'TEXT', Order.MEMBER) || "''";
   const code = text + '[::-1]';
   return [code, Order.MEMBER];
-};
+}

generators/python/variables.js

@@ -1,30 +0,0 @@
-/**
- * @license
- * Copyright 2012 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Generating Python for variable blocks.
- */
-
-// Former goog.module ID: Blockly.Python.variables
-
-import {Order} from './python_generator.js';
-
-
-export function variables_get(block, generator) {
-  // Variable getter.
-  const code =
-      generator.getVariableName(block.getFieldValue('VAR'));
-  return [code, Order.ATOMIC];
-};
-
-export function variables_set(block, generator) {
-  // Variable setter.
-  const argument0 =
-      generator.valueToCode(block, 'VALUE', Order.NONE) || '0';
-  const varName =
-      generator.getVariableName(block.getFieldValue('VAR'));
-  return varName + ' = ' + argument0 + '\n';
-};

generators/python/variables.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating Python for variable blocks.
+ */
+
+// Former goog.module ID: Blockly.Python.variables
+
+import type {Block} from '../../core/block.js';
+import type {PythonGenerator} from './python_generator.js';
+import {Order} from './python_generator.js';
+
+export function variables_get(
+  block: Block,
+  generator: PythonGenerator,
+): [string, Order] {
+  // Variable getter.
+  const code = generator.getVariableName(block.getFieldValue('VAR'));
+  return [code, Order.ATOMIC];
+}
+
+export function variables_set(block: Block, generator: PythonGenerator) {
+  // Variable setter.
+  const argument0 = generator.valueToCode(block, 'VALUE', Order.NONE) || '0';
+  const varName = generator.getVariableName(block.getFieldValue('VAR'));
+  return varName + ' = ' + argument0 + '\n';
+}

generators/python/variables_dynamic.ts

@@ -10,7 +10,6 @@
 
 // Former goog.module ID: Blockly.Python.variablesDynamic
 
-
 // generator is dynamically typed.
 export {
   variables_get as variables_get_dynamic,