refactor(generators)!: Pass this CodeGenerator to individual generator functions (#7168)

* feat(generators): Pass this CodeGenerator to generator functions This implements option 1A of proposal 1 of #7086. This commit is not by itself a breaking change, except in the unlikely event that developers' custom generator functions take an (optional) second argument of a dfferent type. * feat(generators): Accept generator argument in block functions Accept a CodeGenerator instance as parameter two of every per-block-type generator function. * fix(generators): Pass generator when calling other generator functions Make sure to pass generator to any other block functions that are called recursively. * refactor(generators)!: Use generator argument in generator functions Refactor per-block-type generator functions to use the provided generator argument to make recursive calls, rather than depending on the closed-over <lang>Generator instance. This allows generator functions to be moved between CodeGenerator instances (of the same language, at least). This commit was created by search-and-replace and addresses most but not all recursive references; remaining uses will require manual attention and will be dealt with in a following commit. BREAKING CHANGE: This commit makes the generator functions we provide dependent on the new generator parameter. Although CodeGenerator.prototype.blockToCode has been modified to supply this, so this change will not affect most developers, this change will be a breaking change where developers make direct calls to these generator functions without supplying the generator parameter. See previous commit for an example of the update required. * refactor(generators): Manual fix for remaining uses of langGenerator Manually replace remaining uses of <lang>Generator in block generator functions. * fix(generators): Delete duplicate procedures_callnoreturn generator For some reason the generator function for procedures_callnoreturn appears twice in generators/javascript/procedures.js. Delete the first copy (since the second one overwrote it anyway). * chore(generators): Format
2026-01-30 20:20:09 +01:00 · 2023-06-14 23:25:36 +01:00
parent 12b91ae49c
commit a3458871db
44 changed files with 1474 additions and 1477 deletions
--- a/generators/lua/colour.js
+++ b/generators/lua/colour.js
@@ -14,39 +14,39 @@ goog.declareModuleId('Blockly.Lua.colour');
 import {luaGenerator, Order} from '../lua.js';


-luaGenerator.forBlock['colour_picker'] = function(block) {
+luaGenerator.forBlock['colour_picker'] = function(block, generator) {
  // Colour picker.
-  const code = luaGenerator.quote_(block.getFieldValue('COLOUR'));
+  const code = generator.quote_(block.getFieldValue('COLOUR'));
  return [code, Order.ATOMIC];
 };

-luaGenerator.forBlock['colour_random'] = function(block) {
+luaGenerator.forBlock['colour_random'] = function(block, generator) {
  // Generate a random colour.
  const code = 'string.format("#%06x", math.random(0, 2^24 - 1))';
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['colour_rgb'] = function(block) {
+luaGenerator.forBlock['colour_rgb'] = function(block, generator) {
  // Compose a colour from RGB components expressed as percentages.
-  const functionName = luaGenerator.provideFunction_('colour_rgb', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(r, g, b)
+  const functionName = generator.provideFunction_('colour_rgb', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(r, g, b)
  r = math.floor(math.min(100, math.max(0, r)) * 2.55 + .5)
  g = math.floor(math.min(100, math.max(0, g)) * 2.55 + .5)
  b = math.floor(math.min(100, math.max(0, b)) * 2.55 + .5)
  return string.format("#%02x%02x%02x", r, g, b)
 end
 `);
-  const r = luaGenerator.valueToCode(block, 'RED', Order.NONE) || 0;
-  const g = luaGenerator.valueToCode(block, 'GREEN', Order.NONE) || 0;
-  const b = luaGenerator.valueToCode(block, 'BLUE', Order.NONE) || 0;
+  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.HIGH];
 };

-luaGenerator.forBlock['colour_blend'] = function(block) {
+luaGenerator.forBlock['colour_blend'] = function(block, generator) {
  // Blend two colours together.
-  const functionName = luaGenerator.provideFunction_('colour_blend', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(colour1, colour2, ratio)
+  const functionName = generator.provideFunction_('colour_blend', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(colour1, colour2, ratio)
  local r1 = tonumber(string.sub(colour1, 2, 3), 16)
  local r2 = tonumber(string.sub(colour2, 2, 3), 16)
  local g1 = tonumber(string.sub(colour1, 4, 5), 16)
@@ -61,10 +61,10 @@ function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(colour1, colour2, ratio)
 end
 `);
  const colour1 =
-      luaGenerator.valueToCode(block, 'COLOUR1', Order.NONE) || "'#000000'";
+      generator.valueToCode(block, 'COLOUR1', Order.NONE) || "'#000000'";
  const colour2 =
-      luaGenerator.valueToCode(block, 'COLOUR2', Order.NONE) || "'#000000'";
-  const ratio = luaGenerator.valueToCode(block, 'RATIO', Order.NONE) || 0;
+      generator.valueToCode(block, 'COLOUR2', Order.NONE) || "'#000000'";
+  const ratio = generator.valueToCode(block, 'RATIO', Order.NONE) || 0;
  const code =
      functionName + '(' + colour1 + ', ' + colour2 + ', ' + ratio + ')';
  return [code, Order.HIGH];
--- a/generators/lua/lists.js
+++ b/generators/lua/lists.js
@@ -15,26 +15,26 @@ import {NameType} from '../../core/names.js';
 import {luaGenerator, Order} from '../lua.js';


-luaGenerator.forBlock['lists_create_empty'] = function(block) {
+luaGenerator.forBlock['lists_create_empty'] = function(block, generator) {
  // Create an empty list.
  return ['{}', Order.HIGH];
 };

-luaGenerator.forBlock['lists_create_with'] = function(block) {
+luaGenerator.forBlock['lists_create_with'] = function(block, generator) {
  // Create a list with any number of elements of any type.
  const elements = new Array(block.itemCount_);
  for (let i = 0; i < block.itemCount_; i++) {
    elements[i] =
-        luaGenerator.valueToCode(block, 'ADD' + i, Order.NONE) || 'None';
+        generator.valueToCode(block, 'ADD' + i, Order.NONE) || 'None';
  }
  const code = '{' + elements.join(', ') + '}';
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['lists_repeat'] = function(block) {
+luaGenerator.forBlock['lists_repeat'] = function(block, generator) {
  // Create a list with one element repeated.
-  const functionName = luaGenerator.provideFunction_('create_list_repeated', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(item, count)
+  const functionName = generator.provideFunction_('create_list_repeated', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(item, count)
  local t = {}
  for i = 1, count do
    table.insert(t, item)
@@ -42,33 +42,33 @@ function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(item, count)
  return t
 end
  `);
-  const element = luaGenerator.valueToCode(block, 'ITEM', Order.NONE) || 'None';
-  const repeatCount = luaGenerator.valueToCode(block, 'NUM', Order.NONE) || '0';
+  const element = generator.valueToCode(block, 'ITEM', Order.NONE) || 'None';
+  const repeatCount = generator.valueToCode(block, 'NUM', Order.NONE) || '0';
  const code = functionName + '(' + element + ', ' + repeatCount + ')';
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['lists_length'] = function(block) {
+luaGenerator.forBlock['lists_length'] = function(block, generator) {
  // String or array length.
-  const list = luaGenerator.valueToCode(block, 'VALUE', Order.UNARY) || '{}';
+  const list = generator.valueToCode(block, 'VALUE', Order.UNARY) || '{}';
  return ['#' + list, Order.UNARY];
 };

-luaGenerator.forBlock['lists_isEmpty'] = function(block) {
+luaGenerator.forBlock['lists_isEmpty'] = function(block, generator) {
  // Is the string null or array empty?
-  const list = luaGenerator.valueToCode(block, 'VALUE', Order.UNARY) || '{}';
+  const list = generator.valueToCode(block, 'VALUE', Order.UNARY) || '{}';
  const code = '#' + list + ' == 0';
  return [code, Order.RELATIONAL];
 };

-luaGenerator.forBlock['lists_indexOf'] = function(block) {
+luaGenerator.forBlock['lists_indexOf'] = function(block, generator) {
  // Find an item in the list.
-  const item = luaGenerator.valueToCode(block, 'FIND', Order.NONE) || "''";
-  const list = luaGenerator.valueToCode(block, 'VALUE', Order.NONE) || '{}';
+  const item = generator.valueToCode(block, 'FIND', Order.NONE) || "''";
+  const list = generator.valueToCode(block, 'VALUE', Order.NONE) || '{}';
  let functionName;
  if (block.getFieldValue('END') === 'FIRST') {
-    functionName = luaGenerator.provideFunction_('first_index', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t, elem)
+    functionName = generator.provideFunction_('first_index', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t, elem)
  for k, v in ipairs(t) do
    if v == elem then
      return k
@@ -78,8 +78,8 @@ function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t, elem)
 end
 `);
  } else {
-    functionName = luaGenerator.provideFunction_('last_index', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t, elem)
+    functionName = generator.provideFunction_('last_index', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t, elem)
  for i = #t, 1, -1 do
    if t[i] == elem then
      return i
@@ -114,12 +114,12 @@ const getListIndex = function(listName, where, opt_at) {
  }
 };

-luaGenerator.forBlock['lists_getIndex'] = function(block) {
+luaGenerator.forBlock['lists_getIndex'] = function(block, generator) {
  // 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 list = luaGenerator.valueToCode(block, 'VALUE', Order.HIGH) || '({})';
+  const list = generator.valueToCode(block, 'VALUE', Order.HIGH) || '({})';

  // If `list` would be evaluated more than once (which is the case for LAST,
  // FROM_END, and RANDOM) and is non-trivial, make sure to access it only once.
@@ -130,21 +130,21 @@ luaGenerator.forBlock['lists_getIndex'] = function(block) {
      // We can use multiple statements.
      const atOrder =
          (where === 'FROM_END') ? Order.ADDITIVE : Order.NONE;
-      let at = luaGenerator.valueToCode(block, 'AT', atOrder) || '1';
+      let at = generator.valueToCode(block, 'AT', atOrder) || '1';
      const listVar =
-          luaGenerator.nameDB_.getDistinctName('tmp_list', NameType.VARIABLE);
+          generator.nameDB_.getDistinctName('tmp_list', NameType.VARIABLE);
      at = getListIndex(listVar, where, at);
      const code = listVar + ' = ' + list + '\n' +
          'table.remove(' + listVar + ', ' + at + ')\n';
      return code;
    } else {
      // We need to create a procedure to avoid reevaluating values.
-      const at = luaGenerator.valueToCode(block, 'AT', Order.NONE) || '1';
+      const at = generator.valueToCode(block, 'AT', Order.NONE) || '1';
      let functionName;
      if (mode === 'GET') {
-        functionName = luaGenerator.provideFunction_(
+        functionName = generator.provideFunction_(
          'list_get_' + where.toLowerCase(), [
-          'function ' + luaGenerator.FUNCTION_NAME_PLACEHOLDER_ + '(t' +
+          'function ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(t' +
              // The value for 'FROM_END' and'FROM_START' depends on `at` so
              // we add it as a parameter.
              ((where === 'FROM_END' || where === 'FROM_START') ? ', at)' :
@@ -153,9 +153,9 @@ luaGenerator.forBlock['lists_getIndex'] = function(block) {
        ]);
      } else {  // `mode` === 'GET_REMOVE'
        functionName =
-            luaGenerator.provideFunction_(
+            generator.provideFunction_(
              'list_remove_' + where.toLowerCase(), [
-              'function ' + luaGenerator.FUNCTION_NAME_PLACEHOLDER_ + '(t' +
+              'function ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(t' +
                  // The value for 'FROM_END' and'FROM_START' depends on `at` so
                  // we add it as a parameter.
                  ((where === 'FROM_END' || where === 'FROM_START') ? ', at)' :
@@ -178,7 +178,7 @@ luaGenerator.forBlock['lists_getIndex'] = function(block) {
    const atOrder = (mode === 'GET' && where === 'FROM_END') ?
        Order.ADDITIVE :
        Order.NONE;
-    let at = luaGenerator.valueToCode(block, 'AT', atOrder) || '1';
+    let at = generator.valueToCode(block, 'AT', atOrder) || '1';
    at = getListIndex(list, where, at);
    if (mode === 'GET') {
      const code = list + '[' + at + ']';
@@ -194,14 +194,14 @@ luaGenerator.forBlock['lists_getIndex'] = function(block) {
  }
 };

-luaGenerator.forBlock['lists_setIndex'] = function(block) {
+luaGenerator.forBlock['lists_setIndex'] = function(block, generator) {
  // Set element at index.
  // Note: Until February 2013 this block did not have MODE or WHERE inputs.
-  let list = luaGenerator.valueToCode(block, 'LIST', Order.HIGH) || '{}';
+  let list = generator.valueToCode(block, 'LIST', Order.HIGH) || '{}';
  const mode = block.getFieldValue('MODE') || 'SET';
  const where = block.getFieldValue('WHERE') || 'FROM_START';
-  const at = luaGenerator.valueToCode(block, 'AT', Order.ADDITIVE) || '1';
-  const value = luaGenerator.valueToCode(block, 'TO', Order.NONE) || 'None';
+  const at = generator.valueToCode(block, 'AT', Order.ADDITIVE) || '1';
+  const value = generator.valueToCode(block, 'TO', Order.NONE) || 'None';

  let code = '';
  // If `list` would be evaluated more than once (which is the case for LAST,
@@ -211,7 +211,7 @@ luaGenerator.forBlock['lists_setIndex'] = function(block) {
    // `list` is an expression, so we may not evaluate it more than once.
    // We can use multiple statements.
    const listVar =
-        luaGenerator.nameDB_.getDistinctName('tmp_list', NameType.VARIABLE);
+        generator.nameDB_.getDistinctName('tmp_list', NameType.VARIABLE);
    code = listVar + ' = ' + list + '\n';
    list = listVar;
  }
@@ -227,13 +227,13 @@ luaGenerator.forBlock['lists_setIndex'] = function(block) {
  return code + '\n';
 };

-luaGenerator.forBlock['lists_getSublist'] = function(block) {
+luaGenerator.forBlock['lists_getSublist'] = function(block, generator) {
  // Get sublist.
-  const list = luaGenerator.valueToCode(block, 'LIST', Order.NONE) || '{}';
+  const list = generator.valueToCode(block, 'LIST', Order.NONE) || '{}';
  const where1 = block.getFieldValue('WHERE1');
  const where2 = block.getFieldValue('WHERE2');
-  const at1 = luaGenerator.valueToCode(block, 'AT1', Order.NONE) || '1';
-  const at2 = luaGenerator.valueToCode(block, 'AT2', Order.NONE) || '1';
+  const at1 = generator.valueToCode(block, 'AT1', Order.NONE) || '1';
+  const at2 = generator.valueToCode(block, 'AT2', Order.NONE) || '1';

  // The value for 'FROM_END' and'FROM_START' depends on `at` so
  // we add it as a parameter.
@@ -241,9 +241,9 @@ luaGenerator.forBlock['lists_getSublist'] = function(block) {
      (where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : '';
  const at2Param =
      (where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : '';
-  const functionName = luaGenerator.provideFunction_(
+  const functionName = generator.provideFunction_(
      'list_sublist_' + where1.toLowerCase() + '_' + where2.toLowerCase(), `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(source${at1Param}${at2Param})
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(source${at1Param}${at2Param})
  local t = {}
  local start = ${getListIndex('source', where1, 'at1')}
  local finish = ${getListIndex('source', where2, 'at2')}
@@ -262,14 +262,14 @@ end
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['lists_sort'] = function(block) {
+luaGenerator.forBlock['lists_sort'] = function(block, generator) {
  // Block for sorting a list.
-  const list = luaGenerator.valueToCode(block, 'LIST', Order.NONE) || '{}';
+  const list = generator.valueToCode(block, 'LIST', Order.NONE) || '{}';
  const direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
  const type = block.getFieldValue('TYPE');

-  const functionName = luaGenerator.provideFunction_('list_sort', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(list, typev, direction)
+  const functionName = generator.provideFunction_('list_sort', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(list, typev, direction)
  local t = {}
  for n,v in pairs(list) do table.insert(t, v) end
  local compareFuncs = {
@@ -296,19 +296,19 @@ end
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['lists_split'] = function(block) {
+luaGenerator.forBlock['lists_split'] = function(block, generator) {
  // Block for splitting text into a list, or joining a list into text.
-  let input = luaGenerator.valueToCode(block, 'INPUT', Order.NONE);
+  let input = generator.valueToCode(block, 'INPUT', Order.NONE);
  const delimiter =
-      luaGenerator.valueToCode(block, 'DELIM', Order.NONE) || "''";
+      generator.valueToCode(block, 'DELIM', Order.NONE) || "''";
  const mode = block.getFieldValue('MODE');
  let functionName;
  if (mode === 'SPLIT') {
    if (!input) {
      input = "''";
    }
-    functionName = luaGenerator.provideFunction_('list_string_split', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(input, delim)
+    functionName = generator.provideFunction_('list_string_split', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(input, delim)
  local t = {}
  local pos = 1
  while true do
@@ -336,11 +336,11 @@ end
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['lists_reverse'] = function(block) {
+luaGenerator.forBlock['lists_reverse'] = function(block, generator) {
  // Block for reversing a list.
-  const list = luaGenerator.valueToCode(block, 'LIST', Order.NONE) || '{}';
-  const functionName = luaGenerator.provideFunction_('list_reverse', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(input)
+  const list = generator.valueToCode(block, 'LIST', Order.NONE) || '{}';
+  const functionName = generator.provideFunction_('list_reverse', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(input)
  local reversed = {}
  for i = #input, 1, -1 do
    table.insert(reversed, input[i])
--- a/generators/lua/logic.js
+++ b/generators/lua/logic.js
@@ -14,36 +14,36 @@ goog.declareModuleId('Blockly.Lua.logic');
 import {luaGenerator, Order} from '../lua.js';


-luaGenerator.forBlock['controls_if'] = function(block) {
+luaGenerator.forBlock['controls_if'] = function(block, generator) {
  // If/elseif/else condition.
  let n = 0;
  let code = '';
-  if (luaGenerator.STATEMENT_PREFIX) {
+  if (generator.STATEMENT_PREFIX) {
    // Automatic prefix insertion is switched off for this block.  Add manually.
-    code += luaGenerator.injectId(luaGenerator.STATEMENT_PREFIX, block);
+    code += generator.injectId(generator.STATEMENT_PREFIX, block);
  }
  do {
    const conditionCode =
-        luaGenerator.valueToCode(block, 'IF' + n, Order.NONE) || 'false';
-    let branchCode = luaGenerator.statementToCode(block, 'DO' + n);
-    if (luaGenerator.STATEMENT_SUFFIX) {
-      branchCode = luaGenerator.prefixLines(
-          luaGenerator.injectId(luaGenerator.STATEMENT_SUFFIX, block),
-          luaGenerator.INDENT) + branchCode;
+        generator.valueToCode(block, 'IF' + n, Order.NONE) || 'false';
+    let branchCode = generator.statementToCode(block, 'DO' + n);
+    if (generator.STATEMENT_SUFFIX) {
+      branchCode = generator.prefixLines(
+          generator.injectId(generator.STATEMENT_SUFFIX, block),
+          generator.INDENT) + branchCode;
    }
    code +=
        (n > 0 ? 'else' : '') + 'if ' + conditionCode + ' then\n' + branchCode;
    n++;
  } while (block.getInput('IF' + n));

-  if (block.getInput('ELSE') || luaGenerator.STATEMENT_SUFFIX) {
-    let branchCode = luaGenerator.statementToCode(block, 'ELSE');
-    if (luaGenerator.STATEMENT_SUFFIX) {
+  if (block.getInput('ELSE') || generator.STATEMENT_SUFFIX) {
+    let branchCode = generator.statementToCode(block, 'ELSE');
+    if (generator.STATEMENT_SUFFIX) {
      branchCode =
-          luaGenerator.prefixLines(
-            luaGenerator.injectId(
-              luaGenerator.STATEMENT_SUFFIX, block),
-            luaGenerator.INDENT) +
+          generator.prefixLines(
+            generator.injectId(
+              generator.STATEMENT_SUFFIX, block),
+            generator.INDENT) +
          branchCode;
    }
    code += 'else\n' + branchCode;
@@ -53,25 +53,25 @@ luaGenerator.forBlock['controls_if'] = function(block) {

 luaGenerator.forBlock['controls_ifelse'] = luaGenerator.forBlock['controls_if'];

-luaGenerator.forBlock['logic_compare'] = function(block) {
+luaGenerator.forBlock['logic_compare'] = function(block, generator) {
  // Comparison operator.
  const OPERATORS =
      {'EQ': '==', 'NEQ': '~=', 'LT': '<', 'LTE': '<=', 'GT': '>', 'GTE': '>='};
  const operator = OPERATORS[block.getFieldValue('OP')];
  const argument0 =
-        luaGenerator.valueToCode(block, 'A', Order.RELATIONAL) || '0';
+        generator.valueToCode(block, 'A', Order.RELATIONAL) || '0';
  const argument1 =
-        luaGenerator.valueToCode(block, 'B', Order.RELATIONAL) || '0';
+        generator.valueToCode(block, 'B', Order.RELATIONAL) || '0';
  const code = argument0 + ' ' + operator + ' ' + argument1;
  return [code, Order.RELATIONAL];
 };

-luaGenerator.forBlock['logic_operation'] = function(block) {
+luaGenerator.forBlock['logic_operation'] = function(block, generator) {
  // Operations 'and', 'or'.
  const operator = (block.getFieldValue('OP') === 'AND') ? 'and' : 'or';
  const order = (operator === 'and') ? Order.AND : Order.OR;
-  let argument0 = luaGenerator.valueToCode(block, 'A', order);
-  let argument1 = luaGenerator.valueToCode(block, 'B', order);
+  let argument0 = generator.valueToCode(block, 'A', order);
+  let argument1 = generator.valueToCode(block, 'B', order);
  if (!argument0 && !argument1) {
    // If there are no arguments, then the return value is false.
    argument0 = 'false';
@@ -90,31 +90,31 @@ luaGenerator.forBlock['logic_operation'] = function(block) {
  return [code, order];
 };

-luaGenerator.forBlock['logic_negate'] = function(block) {
+luaGenerator.forBlock['logic_negate'] = function(block, generator) {
  // Negation.
  const argument0 =
-        luaGenerator.valueToCode(block, 'BOOL', Order.UNARY) || 'true';
+        generator.valueToCode(block, 'BOOL', Order.UNARY) || 'true';
  const code = 'not ' + argument0;
  return [code, Order.UNARY];
 };

-luaGenerator.forBlock['logic_boolean'] = function(block) {
+luaGenerator.forBlock['logic_boolean'] = function(block, generator) {
  // Boolean values true and false.
  const code = (block.getFieldValue('BOOL') === 'TRUE') ? 'true' : 'false';
  return [code, Order.ATOMIC];
 };

-luaGenerator.forBlock['logic_null'] = function(block) {
+luaGenerator.forBlock['logic_null'] = function(block, generator) {
  // Null data type.
  return ['nil', Order.ATOMIC];
 };

-luaGenerator.forBlock['logic_ternary'] = function(block) {
+luaGenerator.forBlock['logic_ternary'] = function(block, generator) {
  // Ternary operator.
-  const value_if = luaGenerator.valueToCode(block, 'IF', Order.AND) || 'false';
+  const value_if = generator.valueToCode(block, 'IF', Order.AND) || 'false';
  const value_then =
-        luaGenerator.valueToCode(block, 'THEN', Order.AND) || 'nil';
-  const value_else = luaGenerator.valueToCode(block, 'ELSE', Order.OR) || 'nil';
+        generator.valueToCode(block, 'THEN', Order.AND) || 'nil';
+  const value_else = generator.valueToCode(block, 'ELSE', Order.OR) || 'nil';
  const code = value_if + ' and ' + value_then + ' or ' + value_else;
  return [code, Order.OR];
 };
--- a/generators/lua/loops.js
+++ b/generators/lua/loops.js
@@ -31,18 +31,19 @@ const CONTINUE_STATEMENT = 'goto continue\n';
 * blockToCode.
 *
 * @param {string} branch Generated code of the loop body
+ * @param {string} indent Whitespace by which to indent a continue statement.
 * @return {string} Generated label or '' if unnecessary
 */
-const addContinueLabel = function(branch) {
+function addContinueLabel(branch, indent) {
  if (branch.indexOf(CONTINUE_STATEMENT) !== -1) {
    // False positives are possible (e.g. a string literal), but are harmless.
-    return branch + luaGenerator.INDENT + '::continue::\n';
+    return branch + indent + '::continue::\n';
  } else {
    return branch;
  }
 };

-luaGenerator.forBlock['controls_repeat_ext'] = function(block) {
+luaGenerator.forBlock['controls_repeat_ext'] = function(block, generator) {
  // Repeat n times.
  let repeats;
  if (block.getField('TIMES')) {
@@ -50,17 +51,17 @@ luaGenerator.forBlock['controls_repeat_ext'] = function(block) {
    repeats = String(Number(block.getFieldValue('TIMES')));
  } else {
    // External number.
-    repeats = luaGenerator.valueToCode(block, 'TIMES', Order.NONE) || '0';
+    repeats = generator.valueToCode(block, 'TIMES', Order.NONE) || '0';
  }
  if (stringUtils.isNumber(repeats)) {
    repeats = parseInt(repeats, 10);
  } else {
    repeats = 'math.floor(' + repeats + ')';
  }
-  let branch = luaGenerator.statementToCode(block, 'DO');
-  branch = luaGenerator.addLoopTrap(branch, block);
-  branch = addContinueLabel(branch);
-  const loopVar = luaGenerator.nameDB_.getDistinctName('count', NameType.VARIABLE);
+  let branch = generator.statementToCode(block, 'DO');
+  branch = generator.addLoopTrap(branch, block);
+  branch = addContinueLabel(branch, generator.INDENT);
+  const loopVar = generator.nameDB_.getDistinctName('count', NameType.VARIABLE);
  const code =
      'for ' + loopVar + ' = 1, ' + repeats + ' do\n' + branch + 'end\n';
  return code;
@@ -69,33 +70,33 @@ luaGenerator.forBlock['controls_repeat_ext'] = function(block) {
 luaGenerator.forBlock['controls_repeat'] =
    luaGenerator.forBlock['controls_repeat_ext'];

-luaGenerator.forBlock['controls_whileUntil'] = function(block) {
+luaGenerator.forBlock['controls_whileUntil'] = function(block, generator) {
  // Do while/until loop.
  const until = block.getFieldValue('MODE') === 'UNTIL';
  let argument0 =
-      luaGenerator.valueToCode(
+      generator.valueToCode(
          block, 'BOOL', until ? Order.UNARY : Order.NONE) ||
      'false';
-  let branch = luaGenerator.statementToCode(block, 'DO');
-  branch = luaGenerator.addLoopTrap(branch, block);
-  branch = addContinueLabel(branch);
+  let branch = generator.statementToCode(block, 'DO');
+  branch = generator.addLoopTrap(branch, block);
+  branch = addContinueLabel(branch, generator.INDENT);
  if (until) {
    argument0 = 'not ' + argument0;
  }
  return 'while ' + argument0 + ' do\n' + branch + 'end\n';
 };

-luaGenerator.forBlock['controls_for'] = function(block) {
+luaGenerator.forBlock['controls_for'] = function(block, generator) {
  // For loop.
  const variable0 =
-      luaGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
        block.getFieldValue('VAR'), NameType.VARIABLE);
-  const startVar = luaGenerator.valueToCode(block, 'FROM', Order.NONE) || '0';
-  const endVar = luaGenerator.valueToCode(block, 'TO', Order.NONE) || '0';
-  const increment = luaGenerator.valueToCode(block, 'BY', Order.NONE) || '1';
-  let branch = luaGenerator.statementToCode(block, 'DO');
-  branch = luaGenerator.addLoopTrap(branch, block);
-  branch = addContinueLabel(branch);
+  const startVar = generator.valueToCode(block, 'FROM', Order.NONE) || '0';
+  const endVar = generator.valueToCode(block, 'TO', Order.NONE) || '0';
+  const increment = generator.valueToCode(block, 'BY', Order.NONE) || '1';
+  let branch = generator.statementToCode(block, 'DO');
+  branch = generator.addLoopTrap(branch, block);
+  branch = addContinueLabel(branch, generator.INDENT);
  let code = '';
  let incValue;
  if (stringUtils.isNumber(startVar) && stringUtils.isNumber(endVar) &&
@@ -109,7 +110,7 @@ luaGenerator.forBlock['controls_for'] = function(block) {
    // Determine loop direction at start, in case one of the bounds
    // changes during loop execution.
    incValue =
-        luaGenerator.nameDB_.getDistinctName(
+        generator.nameDB_.getDistinctName(
          variable0 + '_inc', NameType.VARIABLE);
    code += incValue + ' = ';
    if (stringUtils.isNumber(increment)) {
@@ -118,7 +119,7 @@ luaGenerator.forBlock['controls_for'] = function(block) {
      code += 'math.abs(' + increment + ')\n';
    }
    code += 'if (' + startVar + ') > (' + endVar + ') then\n';
-    code += luaGenerator.INDENT + incValue + ' = -' + incValue + '\n';
+    code += generator.INDENT + incValue + ' = -' + incValue + '\n';
    code += 'end\n';
  }
  code +=
@@ -127,39 +128,39 @@ luaGenerator.forBlock['controls_for'] = function(block) {
  return code;
 };

-luaGenerator.forBlock['controls_forEach'] = function(block) {
+luaGenerator.forBlock['controls_forEach'] = function(block, generator) {
  // For each loop.
  const variable0 =
-      luaGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
        block.getFieldValue('VAR'), NameType.VARIABLE);
-  const argument0 = luaGenerator.valueToCode(block, 'LIST', Order.NONE) || '{}';
-  let branch = luaGenerator.statementToCode(block, 'DO');
-  branch = luaGenerator.addLoopTrap(branch, block);
-  branch = addContinueLabel(branch);
+  const argument0 = generator.valueToCode(block, 'LIST', Order.NONE) || '{}';
+  let branch = generator.statementToCode(block, 'DO');
+  branch = generator.addLoopTrap(branch, block);
+  branch = addContinueLabel(branch, generator.INDENT);
  const code = 'for _, ' + variable0 + ' in ipairs(' + argument0 + ') do \n' +
      branch + 'end\n';
  return code;
 };

-luaGenerator.forBlock['controls_flow_statements'] = function(block) {
+luaGenerator.forBlock['controls_flow_statements'] = function(block, generator) {
  // Flow statements: continue, break.
  let xfix = '';
-  if (luaGenerator.STATEMENT_PREFIX) {
+  if (generator.STATEMENT_PREFIX) {
    // Automatic prefix insertion is switched off for this block.  Add manually.
-    xfix += luaGenerator.injectId(luaGenerator.STATEMENT_PREFIX, block);
+    xfix += generator.injectId(generator.STATEMENT_PREFIX, block);
  }
-  if (luaGenerator.STATEMENT_SUFFIX) {
+  if (generator.STATEMENT_SUFFIX) {
    // Inject any statement suffix here since the regular one at the end
    // will not get executed if the break/continue is triggered.
-    xfix += luaGenerator.injectId(luaGenerator.STATEMENT_SUFFIX, block);
+    xfix += generator.injectId(generator.STATEMENT_SUFFIX, block);
  }
-  if (luaGenerator.STATEMENT_PREFIX) {
+  if (generator.STATEMENT_PREFIX) {
    const loop = block.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.
      // In the case of 'break', a prefix is needed due to the loop's suffix.
-      xfix += luaGenerator.injectId(luaGenerator.STATEMENT_PREFIX, loop);
+      xfix += generator.injectId(generator.STATEMENT_PREFIX, loop);
    }
  }
  switch (block.getFieldValue('FLOW')) {
--- a/generators/lua/math.js
+++ b/generators/lua/math.js
@@ -15,14 +15,14 @@ import {NameType} from '../../core/names.js';
 import {luaGenerator, Order} from '../lua.js';


-luaGenerator.forBlock['math_number'] = function(block) {
+luaGenerator.forBlock['math_number'] = function(block, generator) {
  // Numeric value.
  const code = Number(block.getFieldValue('NUM'));
  const order = code < 0 ? Order.UNARY : Order.ATOMIC;
  return [code, order];
 };

-luaGenerator.forBlock['math_arithmetic'] = function(block) {
+luaGenerator.forBlock['math_arithmetic'] = function(block, generator) {
  // Basic arithmetic operators, and power.
  const OPERATORS = {
    'ADD': [' + ', Order.ADDITIVE],
@@ -34,29 +34,29 @@ luaGenerator.forBlock['math_arithmetic'] = function(block) {
  const tuple = OPERATORS[block.getFieldValue('OP')];
  const operator = tuple[0];
  const order = tuple[1];
-  const argument0 = luaGenerator.valueToCode(block, 'A', order) || '0';
-  const argument1 = luaGenerator.valueToCode(block, 'B', order) || '0';
+  const argument0 = generator.valueToCode(block, 'A', order) || '0';
+  const argument1 = generator.valueToCode(block, 'B', order) || '0';
  const code = argument0 + operator + argument1;
  return [code, order];
 };

-luaGenerator.forBlock['math_single'] = function(block) {
+luaGenerator.forBlock['math_single'] = function(block, generator) {
  // Math operators with single operand.
  const operator = block.getFieldValue('OP');
  let arg;
  if (operator === 'NEG') {
    // Negation is a special case given its different operator precedence.
-    arg = luaGenerator.valueToCode(block, 'NUM', Order.UNARY) || '0';
+    arg = generator.valueToCode(block, 'NUM', Order.UNARY) || '0';
    return ['-' + arg, Order.UNARY];
  }
  if (operator === 'POW10') {
-    arg = luaGenerator.valueToCode(block, 'NUM', Order.EXPONENTIATION) || '0';
+    arg = generator.valueToCode(block, 'NUM', Order.EXPONENTIATION) || '0';
    return ['10 ^ ' + arg, Order.EXPONENTIATION];
  }
  if (operator === 'ROUND') {
-    arg = luaGenerator.valueToCode(block, 'NUM', Order.ADDITIVE) || '0';
+    arg = generator.valueToCode(block, 'NUM', Order.ADDITIVE) || '0';
  } else {
-    arg = luaGenerator.valueToCode(block, 'NUM', Order.NONE) || '0';
+    arg = generator.valueToCode(block, 'NUM', Order.NONE) || '0';
  }

  let code;
@@ -110,7 +110,7 @@ luaGenerator.forBlock['math_single'] = function(block) {
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['math_constant'] = function(block) {
+luaGenerator.forBlock['math_constant'] = function(block, generator) {
  // Constants: PI, E, the Golden Ratio, sqrt(2), 1/sqrt(2), INFINITY.
  const CONSTANTS = {
    'PI': ['math.pi', Order.HIGH],
@@ -123,7 +123,7 @@ luaGenerator.forBlock['math_constant'] = function(block) {
  return CONSTANTS[block.getFieldValue('CONSTANT')];
 };

-luaGenerator.forBlock['math_number_property'] = function(block) {
+luaGenerator.forBlock['math_number_property'] = function(block, generator) {
  // 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 = {
@@ -137,13 +137,13 @@ luaGenerator.forBlock['math_number_property'] = function(block) {
  };
  const dropdownProperty = block.getFieldValue('PROPERTY');
  const [suffix, inputOrder, outputOrder] = PROPERTIES[dropdownProperty];
-  const numberToCheck = luaGenerator.valueToCode(block, 'NUMBER_TO_CHECK',
+  const numberToCheck = 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.
-    const functionName = luaGenerator.provideFunction_('math_isPrime', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(n)
+    const functionName = generator.provideFunction_('math_isPrime', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(n)
  -- https://en.wikipedia.org/wiki/Primality_test#Naive_methods
  if n == 2 or n == 3 then
    return true
@@ -164,9 +164,9 @@ end
 `);
    code = functionName + '(' + numberToCheck + ')';
  } else if (dropdownProperty === 'DIVISIBLE_BY') {
-    const divisor = luaGenerator.valueToCode(block, 'DIVISOR',
+    const divisor = generator.valueToCode(block, 'DIVISOR',
        Order.MULTIPLICATIVE) || '0';
-    // If 'divisor' is some code that evals to 0, luaGenerator will produce a nan.
+    // If 'divisor' is some code that evals to 0, generator will produce a nan.
    // Let's produce nil if we can determine this at compile-time.
    if (divisor === '0') {
      return ['nil', Order.ATOMIC];
@@ -181,12 +181,12 @@ end
  return [code, outputOrder];
 };

-luaGenerator.forBlock['math_change'] = function(block) {
+luaGenerator.forBlock['math_change'] = function(block, generator) {
  // Add to a variable in place.
  const argument0 =
-      luaGenerator.valueToCode(block, 'DELTA', Order.ADDITIVE) || '0';
+      generator.valueToCode(block, 'DELTA', Order.ADDITIVE) || '0';
  const varName =
-      luaGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
        block.getFieldValue('VAR'), NameType.VARIABLE);
  return varName + ' = ' + varName + ' + ' + argument0 + '\n';
 };
@@ -196,16 +196,16 @@ luaGenerator.forBlock['math_round'] = luaGenerator.forBlock['math_single'];
 // Trigonometry functions have a single operand.
 luaGenerator.forBlock['math_trig'] = luaGenerator.forBlock['math_single'];

-luaGenerator.forBlock['math_on_list'] = function(block) {
+luaGenerator.forBlock['math_on_list'] = function(block, generator) {
  // Math functions for lists.
  const func = block.getFieldValue('OP');
-  const list = luaGenerator.valueToCode(block, 'LIST', Order.NONE) || '{}';
+  const list = generator.valueToCode(block, 'LIST', Order.NONE) || '{}';
  let functionName;

  // Functions needed in more than one case.
  function provideSum() {
-    return luaGenerator.provideFunction_('math_sum', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t)
+    return generator.provideFunction_('math_sum', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t)
  local result = 0
  for _, v in ipairs(t) do
    result = result + v
@@ -222,8 +222,8 @@ end

    case 'MIN':
      // Returns 0 for the empty list.
-      functionName = luaGenerator.provideFunction_('math_min', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t)
+      functionName = generator.provideFunction_('math_min', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t)
  if #t == 0 then
    return 0
  end
@@ -240,8 +240,8 @@ end

    case 'AVERAGE':
      // Returns 0 for the empty list.
-      functionName = luaGenerator.provideFunction_('math_average', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t)
+      functionName = generator.provideFunction_('math_average', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t)
  if #t == 0 then
    return 0
  end
@@ -252,8 +252,8 @@ end

    case 'MAX':
      // Returns 0 for the empty list.
-      functionName = luaGenerator.provideFunction_('math_max', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t)
+      functionName = generator.provideFunction_('math_max', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t)
  if #t == 0 then
    return 0
  end
@@ -270,8 +270,8 @@ end

    case 'MEDIAN':
      // This operation excludes non-numbers.
-      functionName = luaGenerator.provideFunction_('math_median', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t)
+      functionName = generator.provideFunction_('math_median', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t)
  -- Source: http://lua-users.org/wiki/SimpleStats
  if #t == 0 then
    return 0
@@ -295,9 +295,9 @@ end
    case 'MODE':
      // As a list of numbers can contain more than one mode,
      // the returned result is provided as an array.
-      // The luaGenerator version includes non-numbers.
-      functionName = luaGenerator.provideFunction_('math_modes', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t)
+      // The generator version includes non-numbers.
+      functionName = generator.provideFunction_('math_modes', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t)
  -- Source: http://lua-users.org/wiki/SimpleStats
  local counts = {}
  for _, v in ipairs(t) do
@@ -325,8 +325,8 @@ end
      break;

    case 'STD_DEV':
-      functionName = luaGenerator.provideFunction_('math_standard_deviation', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t)
+      functionName = generator.provideFunction_('math_standard_deviation', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t)
  local m
  local vm
  local total = 0
@@ -347,8 +347,8 @@ end
      break;

    case 'RANDOM':
-      functionName = luaGenerator.provideFunction_('math_random_list', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(t)
+      functionName = generator.provideFunction_('math_random_list', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(t)
  if #t == 0 then
    return nil
  end
@@ -363,45 +363,45 @@ end
  return [functionName + '(' + list + ')', Order.HIGH];
 };

-luaGenerator.forBlock['math_modulo'] = function(block) {
+luaGenerator.forBlock['math_modulo'] = function(block, generator) {
  // Remainder computation.
  const argument0 =
-      luaGenerator.valueToCode(block, 'DIVIDEND', Order.MULTIPLICATIVE) || '0';
+      generator.valueToCode(block, 'DIVIDEND', Order.MULTIPLICATIVE) || '0';
  const argument1 =
-      luaGenerator.valueToCode(block, 'DIVISOR', Order.MULTIPLICATIVE) || '0';
+      generator.valueToCode(block, 'DIVISOR', Order.MULTIPLICATIVE) || '0';
  const code = argument0 + ' % ' + argument1;
  return [code, Order.MULTIPLICATIVE];
 };

-luaGenerator.forBlock['math_constrain'] = function(block) {
+luaGenerator.forBlock['math_constrain'] = function(block, generator) {
  // Constrain a number between two limits.
-  const argument0 = luaGenerator.valueToCode(block, 'VALUE', Order.NONE) || '0';
+  const argument0 = generator.valueToCode(block, 'VALUE', Order.NONE) || '0';
  const argument1 =
-      luaGenerator.valueToCode(block, 'LOW', Order.NONE) || '-math.huge';
+      generator.valueToCode(block, 'LOW', Order.NONE) || '-math.huge';
  const argument2 =
-      luaGenerator.valueToCode(block, 'HIGH', Order.NONE) || 'math.huge';
+      generator.valueToCode(block, 'HIGH', Order.NONE) || 'math.huge';
  const code = 'math.min(math.max(' + argument0 + ', ' + argument1 + '), ' +
      argument2 + ')';
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['math_random_int'] = function(block) {
+luaGenerator.forBlock['math_random_int'] = function(block, generator) {
  // Random integer between [X] and [Y].
-  const argument0 = luaGenerator.valueToCode(block, 'FROM', Order.NONE) || '0';
-  const argument1 = luaGenerator.valueToCode(block, 'TO', Order.NONE) || '0';
+  const argument0 = generator.valueToCode(block, 'FROM', Order.NONE) || '0';
+  const argument1 = generator.valueToCode(block, 'TO', Order.NONE) || '0';
  const code = 'math.random(' + argument0 + ', ' + argument1 + ')';
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['math_random_float'] = function(block) {
+luaGenerator.forBlock['math_random_float'] = function(block, generator) {
  // Random fraction between 0 and 1.
  return ['math.random()', Order.HIGH];
 };

-luaGenerator.forBlock['math_atan2'] = function(block) {
+luaGenerator.forBlock['math_atan2'] = function(block, generator) {
  // Arctangent of point (X, Y) in degrees from -180 to 180.
-  const argument0 = luaGenerator.valueToCode(block, 'X', Order.NONE) || '0';
-  const argument1 = luaGenerator.valueToCode(block, 'Y', Order.NONE) || '0';
+  const argument0 = generator.valueToCode(block, 'X', Order.NONE) || '0';
+  const argument1 = generator.valueToCode(block, 'Y', Order.NONE) || '0';
  return [
    'math.deg(math.atan2(' + argument1 + ', ' + argument0 + '))', Order.HIGH
  ];
--- a/generators/lua/procedures.js
+++ b/generators/lua/procedures.js
@@ -15,49 +15,49 @@ import {NameType} from '../../core/names.js';
 import {luaGenerator, Order} from '../lua.js';


-luaGenerator.forBlock['procedures_defreturn'] = function(block) {
+luaGenerator.forBlock['procedures_defreturn'] = function(block, generator) {
  // Define a procedure with a return value.
  const funcName =
-      luaGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
        block.getFieldValue('NAME'), NameType.PROCEDURE);
  let xfix1 = '';
-  if (luaGenerator.STATEMENT_PREFIX) {
-    xfix1 += luaGenerator.injectId(luaGenerator.STATEMENT_PREFIX, block);
+  if (generator.STATEMENT_PREFIX) {
+    xfix1 += generator.injectId(generator.STATEMENT_PREFIX, block);
  }
-  if (luaGenerator.STATEMENT_SUFFIX) {
-    xfix1 += luaGenerator.injectId(luaGenerator.STATEMENT_SUFFIX, block);
+  if (generator.STATEMENT_SUFFIX) {
+    xfix1 += generator.injectId(generator.STATEMENT_SUFFIX, block);
  }
  if (xfix1) {
-    xfix1 = luaGenerator.prefixLines(xfix1, luaGenerator.INDENT);
+    xfix1 = generator.prefixLines(xfix1, generator.INDENT);
  }
  let loopTrap = '';
-  if (luaGenerator.INFINITE_LOOP_TRAP) {
-    loopTrap = luaGenerator.prefixLines(
-        luaGenerator.injectId(
-          luaGenerator.INFINITE_LOOP_TRAP, block), luaGenerator.INDENT);
+  if (generator.INFINITE_LOOP_TRAP) {
+    loopTrap = generator.prefixLines(
+        generator.injectId(
+          generator.INFINITE_LOOP_TRAP, block), generator.INDENT);
  }
-  let branch = luaGenerator.statementToCode(block, 'STACK');
-  let returnValue = luaGenerator.valueToCode(block, 'RETURN', Order.NONE) || '';
+  let branch = generator.statementToCode(block, 'STACK');
+  let returnValue = generator.valueToCode(block, 'RETURN', Order.NONE) || '';
  let xfix2 = '';
  if (branch && returnValue) {
    // After executing the function body, revisit this block for the return.
    xfix2 = xfix1;
  }
  if (returnValue) {
-    returnValue = luaGenerator.INDENT + 'return ' + returnValue + '\n';
+    returnValue = generator.INDENT + 'return ' + returnValue + '\n';
  } else if (!branch) {
    branch = '';
  }
  const args = [];
  const variables = block.getVars();
  for (let i = 0; i < variables.length; i++) {
-    args[i] = luaGenerator.nameDB_.getName(variables[i], NameType.VARIABLE);
+    args[i] = generator.nameDB_.getName(variables[i], NameType.VARIABLE);
  }
  let code = 'function ' + funcName + '(' + args.join(', ') + ')\n' + xfix1 +
      loopTrap + branch + xfix2 + returnValue + 'end\n';
-  code = luaGenerator.scrub_(block, code);
+  code = generator.scrub_(block, code);
  // Add % so as not to collide with helper functions in definitions list.
-  luaGenerator.definitions_['%' + funcName] = code;
+  generator.definitions_['%' + funcName] = code;
  return null;
 };

@@ -66,46 +66,46 @@ luaGenerator.forBlock['procedures_defreturn'] = function(block) {
 luaGenerator.forBlock['procedures_defnoreturn'] =
    luaGenerator.forBlock['procedures_defreturn'];

-luaGenerator.forBlock['procedures_callreturn'] = function(block) {
+luaGenerator.forBlock['procedures_callreturn'] = function(block, generator) {
  // Call a procedure with a return value.
  const funcName =
-      luaGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
        block.getFieldValue('NAME'), NameType.PROCEDURE);
  const args = [];
  const variables = block.getVars();
  for (let i = 0; i < variables.length; i++) {
-    args[i] = luaGenerator.valueToCode(block, 'ARG' + i, Order.NONE) || 'nil';
+    args[i] = generator.valueToCode(block, 'ARG' + i, Order.NONE) || 'nil';
  }
  const code = funcName + '(' + args.join(', ') + ')';
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['procedures_callnoreturn'] = function(block) {
+luaGenerator.forBlock['procedures_callnoreturn'] = function(block, generator) {
  // 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 = luaGenerator.forBlock['procedures_callreturn'](block);
+  const tuple = generator.forBlock['procedures_callreturn'](block, generator);
  return tuple[0] + '\n';
 };

-luaGenerator.forBlock['procedures_ifreturn'] = function(block) {
+luaGenerator.forBlock['procedures_ifreturn'] = function(block, generator) {
  // Conditionally return value from a procedure.
  const condition =
-      luaGenerator.valueToCode(block, 'CONDITION', Order.NONE) || 'false';
+      generator.valueToCode(block, 'CONDITION', Order.NONE) || 'false';
  let code = 'if ' + condition + ' then\n';
-  if (luaGenerator.STATEMENT_SUFFIX) {
+  if (generator.STATEMENT_SUFFIX) {
    // Inject any statement suffix here since the regular one at the end
    // will not get executed if the return is triggered.
    code +=
-        luaGenerator.prefixLines(
-          luaGenerator.injectId(luaGenerator.STATEMENT_SUFFIX, block),
-          luaGenerator.INDENT);
+        generator.prefixLines(
+          generator.injectId(generator.STATEMENT_SUFFIX, block),
+          generator.INDENT);
  }
  if (block.hasReturnValue_) {
-    const value = luaGenerator.valueToCode(block, 'VALUE', Order.NONE) || 'nil';
-    code += luaGenerator.INDENT + 'return ' + value + '\n';
+    const value = generator.valueToCode(block, 'VALUE', Order.NONE) || 'nil';
+    code += generator.INDENT + 'return ' + value + '\n';
  } else {
-    code += luaGenerator.INDENT + 'return\n';
+    code += generator.INDENT + 'return\n';
  }
  code += 'end\n';
  return code;
--- a/generators/lua/text.js
+++ b/generators/lua/text.js
@@ -15,76 +15,76 @@ import {NameType} from '../../core/names.js';
 import {luaGenerator, Order} from '../lua.js';


-luaGenerator.forBlock['text'] = function(block) {
+luaGenerator.forBlock['text'] = function(block, generator) {
  // Text value.
-  const code = luaGenerator.quote_(block.getFieldValue('TEXT'));
+  const code = generator.quote_(block.getFieldValue('TEXT'));
  return [code, Order.ATOMIC];
 };

-luaGenerator.forBlock['text_multiline'] = function(block) {
+luaGenerator.forBlock['text_multiline'] = function(block, generator) {
  // Text value.
-  const code = luaGenerator.multiline_quote_(block.getFieldValue('TEXT'));
+  const code = generator.multiline_quote_(block.getFieldValue('TEXT'));
  const order =
      code.indexOf('..') !== -1 ? Order.CONCATENATION : Order.ATOMIC;
  return [code, order];
 };

-luaGenerator.forBlock['text_join'] = function(block) {
+luaGenerator.forBlock['text_join'] = function(block, generator) {
  // Create a string made up of any number of elements of any type.
  if (block.itemCount_ === 0) {
    return ["''", Order.ATOMIC];
  } else if (block.itemCount_ === 1) {
-    const element = luaGenerator.valueToCode(block, 'ADD0', Order.NONE) || "''";
+    const element = generator.valueToCode(block, 'ADD0', Order.NONE) || "''";
    const code = 'tostring(' + element + ')';
    return [code, Order.HIGH];
  } else if (block.itemCount_ === 2) {
    const element0 =
-        luaGenerator.valueToCode(block, 'ADD0', Order.CONCATENATION) || "''";
+        generator.valueToCode(block, 'ADD0', Order.CONCATENATION) || "''";
    const element1 =
-        luaGenerator.valueToCode(block, 'ADD1', Order.CONCATENATION) || "''";
+        generator.valueToCode(block, 'ADD1', Order.CONCATENATION) || "''";
    const code = element0 + ' .. ' + element1;
    return [code, Order.CONCATENATION];
  } else {
    const elements = [];
    for (let i = 0; i < block.itemCount_; i++) {
      elements[i] =
-          luaGenerator.valueToCode(block, 'ADD' + i, Order.NONE) || "''";
+          generator.valueToCode(block, 'ADD' + i, Order.NONE) || "''";
    }
    const code = 'table.concat({' + elements.join(', ') + '})';
    return [code, Order.HIGH];
  }
 };

-luaGenerator.forBlock['text_append'] = function(block) {
+luaGenerator.forBlock['text_append'] = function(block, generator) {
  // Append to a variable in place.
  const varName =
-      luaGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
        block.getFieldValue('VAR'), NameType.VARIABLE);
  const value =
-      luaGenerator.valueToCode(block, 'TEXT', Order.CONCATENATION) || "''";
+      generator.valueToCode(block, 'TEXT', Order.CONCATENATION) || "''";
  return varName + ' = ' + varName + ' .. ' + value + '\n';
 };

-luaGenerator.forBlock['text_length'] = function(block) {
+luaGenerator.forBlock['text_length'] = function(block, generator) {
  // String or array length.
-  const text = luaGenerator.valueToCode(block, 'VALUE', Order.UNARY) || "''";
+  const text = generator.valueToCode(block, 'VALUE', Order.UNARY) || "''";
  return ['#' + text, Order.UNARY];
 };

-luaGenerator.forBlock['text_isEmpty'] = function(block) {
+luaGenerator.forBlock['text_isEmpty'] = function(block, generator) {
  // Is the string null or array empty?
-  const text = luaGenerator.valueToCode(block, 'VALUE', Order.UNARY) || "''";
+  const text = generator.valueToCode(block, 'VALUE', Order.UNARY) || "''";
  return ['#' + text + ' == 0', Order.RELATIONAL];
 };

-luaGenerator.forBlock['text_indexOf'] = function(block) {
+luaGenerator.forBlock['text_indexOf'] = function(block, generator) {
  // Search the text for a substring.
-  const substring = luaGenerator.valueToCode(block, 'FIND', Order.NONE) || "''";
-  const text = luaGenerator.valueToCode(block, 'VALUE', Order.NONE) || "''";
+  const substring = generator.valueToCode(block, 'FIND', Order.NONE) || "''";
+  const text = generator.valueToCode(block, 'VALUE', Order.NONE) || "''";
  let functionName;
  if (block.getFieldValue('END') === 'FIRST') {
-    functionName = luaGenerator.provideFunction_('firstIndexOf', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(str, substr)
+    functionName = generator.provideFunction_('firstIndexOf', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(str, substr)
  local i = string.find(str, substr, 1, true)
  if i == nil then
    return 0
@@ -93,8 +93,8 @@ function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(str, substr)
 end
 `);
  } else {
-    functionName = luaGenerator.provideFunction_('lastIndexOf', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(str, substr)
+    functionName = generator.provideFunction_('lastIndexOf', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(str, substr)
  local i = string.find(string.reverse(str), string.reverse(substr), 1, true)
  if i then
    return #str + 2 - i - #substr
@@ -107,17 +107,17 @@ end
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['text_charAt'] = function(block) {
+luaGenerator.forBlock['text_charAt'] = function(block, generator) {
  // Get letter at index.
  // Note: Until January 2013 this block did not have the WHERE input.
  const where = block.getFieldValue('WHERE') || 'FROM_START';
  const atOrder = (where === 'FROM_END') ? Order.UNARY : Order.NONE;
-  const at = luaGenerator.valueToCode(block, 'AT', atOrder) || '1';
-  const text = luaGenerator.valueToCode(block, 'VALUE', Order.NONE) || "''";
+  const at = generator.valueToCode(block, 'AT', atOrder) || '1';
+  const text = generator.valueToCode(block, 'VALUE', Order.NONE) || "''";
  let code;
  if (where === 'RANDOM') {
-    const functionName = luaGenerator.provideFunction_('text_random_letter', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(str)
+    const functionName = generator.provideFunction_('text_random_letter', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(str)
  local index = math.random(string.len(str))
  return string.sub(str, index, index)
 end
@@ -142,8 +142,8 @@ end
      code = 'string.sub(' + text + ', ' + start + ', ' + start + ')';
    } else {
      // use function to avoid reevaluation
-      const functionName = luaGenerator.provideFunction_('text_char_at', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(str, index)
+      const functionName = generator.provideFunction_('text_char_at', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(str, index)
  return string.sub(str, index, index)
 end
 `);
@@ -153,14 +153,14 @@ end
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['text_getSubstring'] = function(block) {
+luaGenerator.forBlock['text_getSubstring'] = function(block, generator) {
  // Get substring.
-  const text = luaGenerator.valueToCode(block, 'STRING', Order.NONE) || "''";
+  const text = generator.valueToCode(block, 'STRING', Order.NONE) || "''";

  // Get start index.
  const where1 = block.getFieldValue('WHERE1');
  const at1Order = (where1 === 'FROM_END') ? Order.UNARY : Order.NONE;
-  const at1 = luaGenerator.valueToCode(block, 'AT1', at1Order) || '1';
+  const at1 = generator.valueToCode(block, 'AT1', at1Order) || '1';
  let start;
  if (where1 === 'FIRST') {
    start = 1;
@@ -175,7 +175,7 @@ luaGenerator.forBlock['text_getSubstring'] = function(block) {
  // Get end index.
  const where2 = block.getFieldValue('WHERE2');
  const at2Order = (where2 === 'FROM_END') ? Order.UNARY : Order.NONE;
-  const at2 = luaGenerator.valueToCode(block, 'AT2', at2Order) || '1';
+  const at2 = generator.valueToCode(block, 'AT2', at2Order) || '1';
  let end;
  if (where2 === 'LAST') {
    end = -1;
@@ -190,10 +190,10 @@ luaGenerator.forBlock['text_getSubstring'] = function(block) {
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['text_changeCase'] = function(block) {
+luaGenerator.forBlock['text_changeCase'] = function(block, generator) {
  // Change capitalization.
  const operator = block.getFieldValue('CASE');
-  const text = luaGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
+  const text = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
  let functionName;
  if (operator === 'UPPERCASE') {
    functionName = 'string.upper';
@@ -203,8 +203,8 @@ luaGenerator.forBlock['text_changeCase'] = function(block) {
    // There are shorter versions at
    // http://lua-users.org/wiki/SciteTitleCase
    // that do not preserve whitespace.
-    functionName = luaGenerator.provideFunction_('text_titlecase', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(str)
+    functionName = generator.provideFunction_('text_titlecase', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(str)
  local buf = {}
  local inWord = false
  for i = 1, #str do
@@ -227,34 +227,34 @@ end
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['text_trim'] = function(block) {
+luaGenerator.forBlock['text_trim'] = function(block, generator) {
  // Trim spaces.
  const OPERATORS = {LEFT: '^%s*(,-)', RIGHT: '(.-)%s*$', BOTH: '^%s*(.-)%s*$'};
  const operator = OPERATORS[block.getFieldValue('MODE')];
-  const text = luaGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
+  const text = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
  const code = 'string.gsub(' + text + ', "' + operator + '", "%1")';
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['text_print'] = function(block) {
+luaGenerator.forBlock['text_print'] = function(block, generator) {
  // Print statement.
-  const msg = luaGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
+  const msg = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
  return 'print(' + msg + ')\n';
 };

-luaGenerator.forBlock['text_prompt_ext'] = function(block) {
+luaGenerator.forBlock['text_prompt_ext'] = function(block, generator) {
  // Prompt function.
  let msg;
  if (block.getField('TEXT')) {
    // Internal message.
-    msg = luaGenerator.quote_(block.getFieldValue('TEXT'));
+    msg = generator.quote_(block.getFieldValue('TEXT'));
  } else {
    // External message.
-    msg = luaGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
+    msg = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
  }

-  const functionName = luaGenerator.provideFunction_('text_prompt', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(msg)
+  const functionName = generator.provideFunction_('text_prompt', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(msg)
  io.write(msg)
  io.flush()
  return io.read()
@@ -271,11 +271,11 @@ end

 luaGenerator.forBlock['text_prompt'] = luaGenerator.forBlock['text_prompt_ext'];

-luaGenerator.forBlock['text_count'] = function(block) {
-  const text = luaGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
-  const sub = luaGenerator.valueToCode(block, 'SUB', Order.NONE) || "''";
-  const functionName = luaGenerator.provideFunction_('text_count', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle)
+luaGenerator.forBlock['text_count'] = function(block, generator) {
+  const text = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
+  const sub = generator.valueToCode(block, 'SUB', Order.NONE) || "''";
+  const functionName = generator.provideFunction_('text_count', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle)
  if #needle == 0 then
    return #haystack + 1
  end
@@ -296,12 +296,12 @@ end
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['text_replace'] = function(block) {
-  const text = luaGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
-  const from = luaGenerator.valueToCode(block, 'FROM', Order.NONE) || "''";
-  const to = luaGenerator.valueToCode(block, 'TO', Order.NONE) || "''";
-  const functionName = luaGenerator.provideFunction_('text_replace', `
-function ${luaGenerator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle, replacement)
+luaGenerator.forBlock['text_replace'] = function(block, generator) {
+  const text = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
+  const from = generator.valueToCode(block, 'FROM', Order.NONE) || "''";
+  const to = generator.valueToCode(block, 'TO', Order.NONE) || "''";
+  const functionName = generator.provideFunction_('text_replace', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle, replacement)
  local buf = {}
  local i = 1
  while i <= #haystack do
@@ -322,8 +322,8 @@ end
  return [code, Order.HIGH];
 };

-luaGenerator.forBlock['text_reverse'] = function(block) {
-  const text = luaGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
+luaGenerator.forBlock['text_reverse'] = function(block, generator) {
+  const text = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
  const code = 'string.reverse(' + text + ')';
  return [code, Order.HIGH];
 };
--- a/generators/lua/variables.js
+++ b/generators/lua/variables.js
@@ -15,19 +15,19 @@ import {NameType} from '../../core/names.js';
 import {luaGenerator, Order} from '../lua.js';


-luaGenerator.forBlock['variables_get'] = function(block) {
+luaGenerator.forBlock['variables_get'] = function(block, generator) {
  // Variable getter.
  const code =
-      luaGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
        block.getFieldValue('VAR'), NameType.VARIABLE);
  return [code, Order.ATOMIC];
 };

-luaGenerator.forBlock['variables_set'] = function(block) {
+luaGenerator.forBlock['variables_set'] = function(block, generator) {
  // Variable setter.
-  const argument0 = luaGenerator.valueToCode(block, 'VALUE', Order.NONE) || '0';
+  const argument0 = generator.valueToCode(block, 'VALUE', Order.NONE) || '0';
  const varName =
-      luaGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
        block.getFieldValue('VAR'), NameType.VARIABLE);
  return varName + ' = ' + argument0 + '\n';
 };