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

generators/javascript/colour.js

@@ -14,16 +14,16 @@ goog.declareModuleId('Blockly.JavaScript.colour');
 import {Order, javascriptGenerator} from '../javascript.js';
 
 
-javascriptGenerator.forBlock['colour_picker'] = function(block) {
+javascriptGenerator.forBlock['colour_picker'] = function(block, generator) {
   // Colour picker.
-  const code = javascriptGenerator.quote_(block.getFieldValue('COLOUR'));
+  const code = generator.quote_(block.getFieldValue('COLOUR'));
   return [code, Order.ATOMIC];
 };
 
-javascriptGenerator.forBlock['colour_random'] = function(block) {
+javascriptGenerator.forBlock['colour_random'] = function(block, generator) {
   // Generate a random colour.
-  const functionName = javascriptGenerator.provideFunction_('colourRandom', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}() {
+  const functionName = generator.provideFunction_('colourRandom', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}() {
   var num = Math.floor(Math.random() * Math.pow(2, 24));
   return '#' + ('00000' + num.toString(16)).substr(-6);
 }
@@ -32,15 +32,15 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}() {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['colour_rgb'] = function(block) {
+javascriptGenerator.forBlock['colour_rgb'] = function(block, generator) {
   // Compose a colour from RGB components expressed as percentages.
-  const red = javascriptGenerator.valueToCode(block, 'RED', Order.NONE) || 0;
+  const red = generator.valueToCode(block, 'RED', Order.NONE) || 0;
   const green =
-      javascriptGenerator.valueToCode(block, 'GREEN', Order.NONE) || 0;
+      generator.valueToCode(block, 'GREEN', Order.NONE) || 0;
   const blue =
-      javascriptGenerator.valueToCode(block, 'BLUE', Order.NONE) || 0;
-  const functionName = javascriptGenerator.provideFunction_('colourRgb', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(r, g, b) {
+      generator.valueToCode(block, 'BLUE', Order.NONE) || 0;
+  const functionName = generator.provideFunction_('colourRgb', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(r, g, b) {
   r = Math.max(Math.min(Number(r), 100), 0) * 2.55;
   g = Math.max(Math.min(Number(g), 100), 0) * 2.55;
   b = Math.max(Math.min(Number(b), 100), 0) * 2.55;
@@ -54,16 +54,16 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(r, g, b) {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['colour_blend'] = function(block) {
+javascriptGenerator.forBlock['colour_blend'] = function(block, generator) {
   // Blend two colours together.
-  const c1 = javascriptGenerator.valueToCode(block, 'COLOUR1', Order.NONE) ||
+  const c1 = generator.valueToCode(block, 'COLOUR1', Order.NONE) ||
       "'#000000'";
-  const c2 = javascriptGenerator.valueToCode(block, 'COLOUR2', Order.NONE) ||
+  const c2 = generator.valueToCode(block, 'COLOUR2', Order.NONE) ||
       "'#000000'";
   const ratio =
-      javascriptGenerator.valueToCode(block, 'RATIO', Order.NONE) || 0.5;
-  const functionName = javascriptGenerator.provideFunction_('colourBlend', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(c1, c2, ratio) {
+      generator.valueToCode(block, 'RATIO', Order.NONE) || 0.5;
+  const functionName = generator.provideFunction_('colourBlend', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(c1, c2, ratio) {
   ratio = Math.max(Math.min(Number(ratio), 1), 0);
   var r1 = parseInt(c1.substring(1, 3), 16);
   var g1 = parseInt(c1.substring(3, 5), 16);

generators/javascript/lists.js

@@ -16,27 +16,27 @@ import {NameType} from '../../core/names.js';
 import {Order, javascriptGenerator} from '../javascript.js';
 
 
-javascriptGenerator.forBlock['lists_create_empty'] = function(block) {
+javascriptGenerator.forBlock['lists_create_empty'] = function(block, generator) {
   // Create an empty list.
   return ['[]', Order.ATOMIC];
 };
 
-javascriptGenerator.forBlock['lists_create_with'] = function(block) {
+javascriptGenerator.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] =
-        javascriptGenerator.valueToCode(block, 'ADD' + i, Order.NONE) ||
+        generator.valueToCode(block, 'ADD' + i, Order.NONE) ||
         'null';
   }
   const code = '[' + elements.join(', ') + ']';
   return [code, Order.ATOMIC];
 };
 
-javascriptGenerator.forBlock['lists_repeat'] = function(block) {
+javascriptGenerator.forBlock['lists_repeat'] = function(block, generator) {
   // Create a list with one element repeated.
-  const functionName = javascriptGenerator.provideFunction_('listsRepeat', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(value, n) {
+  const functionName = generator.provideFunction_('listsRepeat', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(value, n) {
   var array = [];
   for (var i = 0; i < n; i++) {
     array[i] = value;
@@ -45,35 +45,35 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(value, n) {
 }
 `);
   const element =
-      javascriptGenerator.valueToCode(block, 'ITEM', Order.NONE) || 'null';
+      generator.valueToCode(block, 'ITEM', Order.NONE) || 'null';
   const repeatCount =
-      javascriptGenerator.valueToCode(block, 'NUM', Order.NONE) || '0';
+      generator.valueToCode(block, 'NUM', Order.NONE) || '0';
   const code = functionName + '(' + element + ', ' + repeatCount + ')';
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['lists_length'] = function(block) {
+javascriptGenerator.forBlock['lists_length'] = function(block, generator) {
   // String or array length.
   const list =
-      javascriptGenerator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
+      generator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
   return [list + '.length', Order.MEMBER];
 };
 
-javascriptGenerator.forBlock['lists_isEmpty'] = function(block) {
+javascriptGenerator.forBlock['lists_isEmpty'] = function(block, generator) {
   // Is the string null or array empty?
   const list =
-      javascriptGenerator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
+      generator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
   return ['!' + list + '.length', Order.LOGICAL_NOT];
 };
 
-javascriptGenerator.forBlock['lists_indexOf'] = function(block) {
+javascriptGenerator.forBlock['lists_indexOf'] = function(block, generator) {
   // Find an item in the list.
   const operator =
       block.getFieldValue('END') === 'FIRST' ? 'indexOf' : 'lastIndexOf';
   const item =
-      javascriptGenerator.valueToCode(block, 'FIND', Order.NONE) || "''";
+      generator.valueToCode(block, 'FIND', Order.NONE) || "''";
   const list =
-      javascriptGenerator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
+      generator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
   const code = list + '.' + operator + '(' + item + ')';
   if (block.workspace.options.oneBasedIndex) {
     return [code + ' + 1', Order.ADDITION];
@@ -81,7 +81,7 @@ javascriptGenerator.forBlock['lists_indexOf'] = function(block) {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['lists_getIndex'] = function(block) {
+javascriptGenerator.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';
@@ -89,7 +89,7 @@ javascriptGenerator.forBlock['lists_getIndex'] = function(block) {
   const listOrder =
       (where === 'RANDOM') ? Order.NONE : Order.MEMBER;
   const list =
-      javascriptGenerator.valueToCode(block, 'VALUE', listOrder) || '[]';
+      generator.valueToCode(block, 'VALUE', listOrder) || '[]';
 
   switch (where) {
     case ('FIRST'):
@@ -115,7 +115,7 @@ javascriptGenerator.forBlock['lists_getIndex'] = function(block) {
       }
       break;
     case ('FROM_START'): {
-      const at = javascriptGenerator.getAdjusted(block, 'AT');
+      const at = generator.getAdjusted(block, 'AT');
       if (mode === 'GET') {
         const code = list + '[' + at + ']';
         return [code, Order.MEMBER];
@@ -128,7 +128,7 @@ javascriptGenerator.forBlock['lists_getIndex'] = function(block) {
       break;
     }
     case ('FROM_END'): {
-      const at = javascriptGenerator.getAdjusted(block, 'AT', 1, true);
+      const at = generator.getAdjusted(block, 'AT', 1, true);
       if (mode === 'GET') {
         const code = list + '.slice(' + at + ')[0]';
         return [code, Order.FUNCTION_CALL];
@@ -142,8 +142,8 @@ javascriptGenerator.forBlock['lists_getIndex'] = function(block) {
     }
     case ('RANDOM'): {
       const functionName =
-          javascriptGenerator.provideFunction_('listsGetRandomItem', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(list, remove) {
+          generator.provideFunction_('listsGetRandomItem', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(list, remove) {
   var x = Math.floor(Math.random() * list.length);
   if (remove) {
     return list.splice(x, 1)[0];
@@ -164,15 +164,15 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(list, remove) {
   throw Error('Unhandled combination (lists_getIndex).');
 };
 
-javascriptGenerator.forBlock['lists_setIndex'] = function(block) {
+javascriptGenerator.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 =
-      javascriptGenerator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
+      generator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
   const mode = block.getFieldValue('MODE') || 'GET';
   const where = block.getFieldValue('WHERE') || 'FROM_START';
   const value =
-      javascriptGenerator.valueToCode(block, 'TO', Order.ASSIGNMENT) ||
+      generator.valueToCode(block, 'TO', Order.ASSIGNMENT) ||
       'null';
   // Cache non-trivial values to variables to prevent repeated look-ups.
   // Closure, which accesses and modifies 'list'.
@@ -181,7 +181,7 @@ javascriptGenerator.forBlock['lists_setIndex'] = function(block) {
       return '';
     }
     const listVar =
-        javascriptGenerator.nameDB_.getDistinctName(
+        generator.nameDB_.getDistinctName(
           'tmpList', NameType.VARIABLE);
     const code = 'var ' + listVar + ' = ' + list + ';\n';
     list = listVar;
@@ -205,7 +205,7 @@ javascriptGenerator.forBlock['lists_setIndex'] = function(block) {
       }
       break;
     case ('FROM_START'): {
-      const at = javascriptGenerator.getAdjusted(block, 'AT');
+      const at = generator.getAdjusted(block, 'AT');
       if (mode === 'SET') {
         return list + '[' + at + '] = ' + value + ';\n';
       } else if (mode === 'INSERT') {
@@ -214,7 +214,7 @@ javascriptGenerator.forBlock['lists_setIndex'] = function(block) {
       break;
     }
     case ('FROM_END'): {
-      const at = javascriptGenerator.getAdjusted(
+      const at = generator.getAdjusted(
           block, 'AT', 1, false, Order.SUBTRACTION);
       let code = cacheList();
       if (mode === 'SET') {
@@ -230,7 +230,7 @@ javascriptGenerator.forBlock['lists_setIndex'] = function(block) {
     case ('RANDOM'): {
       let code = cacheList();
       const xVar =
-          javascriptGenerator.nameDB_.getDistinctName(
+          generator.nameDB_.getDistinctName(
             'tmpX', NameType.VARIABLE);
       code += 'var ' + xVar + ' = Math.floor(Math.random() * ' + list +
           '.length);\n';
@@ -266,10 +266,10 @@ const getSubstringIndex = function(listName, where, opt_at) {
   }
 };
 
-javascriptGenerator.forBlock['lists_getSublist'] = function(block) {
+javascriptGenerator.forBlock['lists_getSublist'] = function(block, generator) {
   // Get sublist.
   const list =
-      javascriptGenerator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
+      generator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
   const where1 = block.getFieldValue('WHERE1');
   const where2 = block.getFieldValue('WHERE2');
   let code;
@@ -283,10 +283,10 @@ javascriptGenerator.forBlock['lists_getSublist'] = function(block) {
     let at1;
     switch (where1) {
       case 'FROM_START':
-        at1 = javascriptGenerator.getAdjusted(block, 'AT1');
+        at1 = generator.getAdjusted(block, 'AT1');
         break;
       case 'FROM_END':
-        at1 = javascriptGenerator.getAdjusted(
+        at1 = generator.getAdjusted(
             block, 'AT1', 1, false, Order.SUBTRACTION);
         at1 = list + '.length - ' + at1;
         break;
@@ -299,10 +299,10 @@ javascriptGenerator.forBlock['lists_getSublist'] = function(block) {
     let at2;
     switch (where2) {
       case 'FROM_START':
-        at2 = javascriptGenerator.getAdjusted(block, 'AT2', 1);
+        at2 = generator.getAdjusted(block, 'AT2', 1);
         break;
       case 'FROM_END':
-        at2 = javascriptGenerator.getAdjusted(
+        at2 = generator.getAdjusted(
             block, 'AT2', 0, false, Order.SUBTRACTION);
         at2 = list + '.length - ' + at2;
         break;
@@ -314,8 +314,8 @@ javascriptGenerator.forBlock['lists_getSublist'] = function(block) {
     }
     code = list + '.slice(' + at1 + ', ' + at2 + ')';
   } else {
-    const at1 = javascriptGenerator.getAdjusted(block, 'AT1');
-    const at2 = javascriptGenerator.getAdjusted(block, 'AT2');
+    const at1 = generator.getAdjusted(block, 'AT1');
+    const at2 = generator.getAdjusted(block, 'AT2');
     const wherePascalCase = {
       'FIRST': 'First',
       'LAST': 'Last',
@@ -328,9 +328,9 @@ javascriptGenerator.forBlock['lists_getSublist'] = function(block) {
         (where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : '';
     const at2Param =
         (where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : '';
-    const functionName = javascriptGenerator.provideFunction_(
+    const functionName = generator.provideFunction_(
         'subsequence' + wherePascalCase[where1] + wherePascalCase[where2], `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}) {
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}) {
   var start = ${getSubstringIndex('sequence', where1, 'at1')};
   var end = ${getSubstringIndex('sequence', where2, 'at2')} + 1;
   return sequence.slice(start, end);
@@ -346,16 +346,16 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['lists_sort'] = function(block) {
+javascriptGenerator.forBlock['lists_sort'] = function(block, generator) {
   // Block for sorting a list.
   const list =
-      javascriptGenerator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) ||
+      generator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) ||
       '[]';
   const direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
   const type = block.getFieldValue('TYPE');
   const getCompareFunctionName =
-      javascriptGenerator.provideFunction_('listsGetSortCompare', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(type, direction) {
+      generator.provideFunction_('listsGetSortCompare', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(type, direction) {
   var compareFuncs = {
     'NUMERIC': function(a, b) {
         return Number(a) - Number(b); },
@@ -375,11 +375,11 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(type, direction) {
   ];
 };
 
-javascriptGenerator.forBlock['lists_split'] = function(block) {
+javascriptGenerator.forBlock['lists_split'] = function(block, generator) {
   // Block for splitting text into a list, or joining a list into text.
-  let input = javascriptGenerator.valueToCode(block, 'INPUT', Order.MEMBER);
+  let input = generator.valueToCode(block, 'INPUT', Order.MEMBER);
   const delimiter =
-      javascriptGenerator.valueToCode(block, 'DELIM', Order.NONE) || "''";
+      generator.valueToCode(block, 'DELIM', Order.NONE) || "''";
   const mode = block.getFieldValue('MODE');
   let functionName;
   if (mode === 'SPLIT') {
@@ -399,10 +399,10 @@ javascriptGenerator.forBlock['lists_split'] = function(block) {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['lists_reverse'] = function(block) {
+javascriptGenerator.forBlock['lists_reverse'] = function(block, generator) {
   // Block for reversing a list.
   const list =
-      javascriptGenerator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) ||
+      generator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) ||
       '[]';
   const code = list + '.slice().reverse()';
   return [code, Order.FUNCTION_CALL];

generators/javascript/logic.js

@@ -14,25 +14,25 @@ goog.declareModuleId('Blockly.JavaScript.logic');
 import {Order, javascriptGenerator} from '../javascript.js';
 
 
-javascriptGenerator.forBlock['controls_if'] = function(block) {
+javascriptGenerator.forBlock['controls_if'] = function(block, generator) {
   // If/elseif/else condition.
   let n = 0;
   let code = '';
-  if (javascriptGenerator.STATEMENT_PREFIX) {
+  if (generator.STATEMENT_PREFIX) {
     // Automatic prefix insertion is switched off for this block.  Add manually.
-    code += javascriptGenerator.injectId(
-        javascriptGenerator.STATEMENT_PREFIX, block);
+    code += generator.injectId(
+        generator.STATEMENT_PREFIX, block);
   }
   do {
     const conditionCode =
-        javascriptGenerator.valueToCode(block, 'IF' + n, Order.NONE) ||
+        generator.valueToCode(block, 'IF' + n, Order.NONE) ||
         'false';
-    let branchCode = javascriptGenerator.statementToCode(block, 'DO' + n);
-    if (javascriptGenerator.STATEMENT_SUFFIX) {
-      branchCode = javascriptGenerator.prefixLines(
-          javascriptGenerator.injectId(
-            javascriptGenerator.STATEMENT_SUFFIX, block),
-          javascriptGenerator.INDENT) +
+    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 + ') {\n' +
@@ -40,13 +40,13 @@ javascriptGenerator.forBlock['controls_if'] = function(block) {
     n++;
   } while (block.getInput('IF' + n));
 
-  if (block.getInput('ELSE') || javascriptGenerator.STATEMENT_SUFFIX) {
-    let branchCode = javascriptGenerator.statementToCode(block, 'ELSE');
-    if (javascriptGenerator.STATEMENT_SUFFIX) {
-      branchCode = javascriptGenerator.prefixLines(
-          javascriptGenerator.injectId(
-            javascriptGenerator.STATEMENT_SUFFIX, block),
-          javascriptGenerator.INDENT) +
+  if (block.getInput('ELSE') || generator.STATEMENT_SUFFIX) {
+    let branchCode = generator.statementToCode(block, 'ELSE');
+    if (generator.STATEMENT_SUFFIX) {
+      branchCode = generator.prefixLines(
+          generator.injectId(
+            generator.STATEMENT_SUFFIX, block),
+          generator.INDENT) +
           branchCode;
     }
     code += ' else {\n' + branchCode + '}';
@@ -57,7 +57,7 @@ javascriptGenerator.forBlock['controls_if'] = function(block) {
 javascriptGenerator.forBlock['controls_ifelse'] =
     javascriptGenerator.forBlock['controls_if'];
 
-javascriptGenerator.forBlock['logic_compare'] = function(block) {
+javascriptGenerator.forBlock['logic_compare'] = function(block, generator) {
   // Comparison operator.
   const OPERATORS =
       {'EQ': '==', 'NEQ': '!=', 'LT': '<', 'LTE': '<=', 'GT': '>', 'GTE': '>='};
@@ -65,19 +65,19 @@ javascriptGenerator.forBlock['logic_compare'] = function(block) {
   const order = (operator === '==' || operator === '!=') ?
       Order.EQUALITY :
       Order.RELATIONAL;
-  const argument0 = javascriptGenerator.valueToCode(block, 'A', order) || '0';
-  const argument1 = javascriptGenerator.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];
 };
 
-javascriptGenerator.forBlock['logic_operation'] = function(block) {
+javascriptGenerator.forBlock['logic_operation'] = function(block, generator) {
   // Operations 'and', 'or'.
   const operator = (block.getFieldValue('OP') === 'AND') ? '&&' : '||';
   const order = (operator === '&&') ? Order.LOGICAL_AND :
                                       Order.LOGICAL_OR;
-  let argument0 = javascriptGenerator.valueToCode(block, 'A', order);
-  let argument1 = javascriptGenerator.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';
@@ -96,36 +96,36 @@ javascriptGenerator.forBlock['logic_operation'] = function(block) {
   return [code, order];
 };
 
-javascriptGenerator.forBlock['logic_negate'] = function(block) {
+javascriptGenerator.forBlock['logic_negate'] = function(block, generator) {
   // Negation.
   const order = Order.LOGICAL_NOT;
   const argument0 =
-      javascriptGenerator.valueToCode(block, 'BOOL', order) || 'true';
+      generator.valueToCode(block, 'BOOL', order) || 'true';
   const code = '!' + argument0;
   return [code, order];
 };
 
-javascriptGenerator.forBlock['logic_boolean'] = function(block) {
+javascriptGenerator.forBlock['logic_boolean'] = function(block, generator) {
   // Boolean values true and false.
   const code = (block.getFieldValue('BOOL') === 'TRUE') ? 'true' : 'false';
   return [code, Order.ATOMIC];
 };
 
-javascriptGenerator.forBlock['logic_null'] = function(block) {
+javascriptGenerator.forBlock['logic_null'] = function(block, generator) {
   // Null data type.
   return ['null', Order.ATOMIC];
 };
 
-javascriptGenerator.forBlock['logic_ternary'] = function(block) {
+javascriptGenerator.forBlock['logic_ternary'] = function(block, generator) {
   // Ternary operator.
   const value_if =
-      javascriptGenerator.valueToCode(block, 'IF', Order.CONDITIONAL) ||
+      generator.valueToCode(block, 'IF', Order.CONDITIONAL) ||
       'false';
   const value_then =
-      javascriptGenerator.valueToCode(block, 'THEN', Order.CONDITIONAL) ||
+      generator.valueToCode(block, 'THEN', Order.CONDITIONAL) ||
       'null';
   const value_else =
-      javascriptGenerator.valueToCode(block, 'ELSE', Order.CONDITIONAL) ||
+      generator.valueToCode(block, 'ELSE', Order.CONDITIONAL) ||
       'null';
   const code = value_if + ' ? ' + value_then + ' : ' + value_else;
   return [code, Order.CONDITIONAL];

generators/javascript/loops.js

@@ -16,7 +16,7 @@ import {NameType} from '../../core/names.js';
 import {Order, javascriptGenerator} from '../javascript.js';
 
 
-javascriptGenerator.forBlock['controls_repeat_ext'] = function(block) {
+javascriptGenerator.forBlock['controls_repeat_ext'] = function(block, generator) {
   // Repeat n times.
   let repeats;
   if (block.getField('TIMES')) {
@@ -25,18 +25,18 @@ javascriptGenerator.forBlock['controls_repeat_ext'] = function(block) {
   } else {
     // External number.
     repeats =
-        javascriptGenerator.valueToCode(block, 'TIMES', Order.ASSIGNMENT) ||
+        generator.valueToCode(block, 'TIMES', Order.ASSIGNMENT) ||
         '0';
   }
-  let branch = javascriptGenerator.statementToCode(block, 'DO');
-  branch = javascriptGenerator.addLoopTrap(branch, block);
+  let branch = generator.statementToCode(block, 'DO');
+  branch = generator.addLoopTrap(branch, block);
   let code = '';
   const loopVar =
-      javascriptGenerator.nameDB_.getDistinctName('count', NameType.VARIABLE);
+      generator.nameDB_.getDistinctName('count', NameType.VARIABLE);
   let endVar = repeats;
   if (!repeats.match(/^\w+$/) && !stringUtils.isNumber(repeats)) {
     endVar =
-        javascriptGenerator.nameDB_.getDistinctName(
+        generator.nameDB_.getDistinctName(
           'repeat_end', NameType.VARIABLE);
     code += 'var ' + endVar + ' = ' + repeats + ';\n';
   }
@@ -48,35 +48,35 @@ javascriptGenerator.forBlock['controls_repeat_ext'] = function(block) {
 javascriptGenerator.forBlock['controls_repeat'] =
     javascriptGenerator.forBlock['controls_repeat_ext'];
 
-javascriptGenerator.forBlock['controls_whileUntil'] = function(block) {
+javascriptGenerator.forBlock['controls_whileUntil'] = function(block, generator) {
   // Do while/until loop.
   const until = block.getFieldValue('MODE') === 'UNTIL';
   let argument0 =
-      javascriptGenerator.valueToCode(
+      generator.valueToCode(
           block, 'BOOL',
           until ? Order.LOGICAL_NOT : Order.NONE) ||
       'false';
-  let branch = javascriptGenerator.statementToCode(block, 'DO');
-  branch = javascriptGenerator.addLoopTrap(branch, block);
+  let branch = generator.statementToCode(block, 'DO');
+  branch = generator.addLoopTrap(branch, block);
   if (until) {
     argument0 = '!' + argument0;
   }
   return 'while (' + argument0 + ') {\n' + branch + '}\n';
 };
 
-javascriptGenerator.forBlock['controls_for'] = function(block) {
+javascriptGenerator.forBlock['controls_for'] = function(block, generator) {
   // For loop.
   const variable0 =
-      javascriptGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
         block.getFieldValue('VAR'), NameType.VARIABLE);
   const argument0 =
-      javascriptGenerator.valueToCode(block, 'FROM', Order.ASSIGNMENT) || '0';
+      generator.valueToCode(block, 'FROM', Order.ASSIGNMENT) || '0';
   const argument1 =
-      javascriptGenerator.valueToCode(block, 'TO', Order.ASSIGNMENT) || '0';
+      generator.valueToCode(block, 'TO', Order.ASSIGNMENT) || '0';
   const increment =
-      javascriptGenerator.valueToCode(block, 'BY', Order.ASSIGNMENT) || '1';
-  let branch = javascriptGenerator.statementToCode(block, 'DO');
-  branch = javascriptGenerator.addLoopTrap(branch, block);
+      generator.valueToCode(block, 'BY', Order.ASSIGNMENT) || '1';
+  let branch = generator.statementToCode(block, 'DO');
+  branch = generator.addLoopTrap(branch, block);
   let code;
   if (stringUtils.isNumber(argument0) && stringUtils.isNumber(argument1) &&
       stringUtils.isNumber(increment)) {
@@ -96,19 +96,19 @@ javascriptGenerator.forBlock['controls_for'] = function(block) {
     // Cache non-trivial values to variables to prevent repeated look-ups.
     let startVar = argument0;
     if (!argument0.match(/^\w+$/) && !stringUtils.isNumber(argument0)) {
-      startVar = javascriptGenerator.nameDB_.getDistinctName(
+      startVar = generator.nameDB_.getDistinctName(
           variable0 + '_start', NameType.VARIABLE);
       code += 'var ' + startVar + ' = ' + argument0 + ';\n';
     }
     let endVar = argument1;
     if (!argument1.match(/^\w+$/) && !stringUtils.isNumber(argument1)) {
-      endVar = javascriptGenerator.nameDB_.getDistinctName(
+      endVar = generator.nameDB_.getDistinctName(
           variable0 + '_end', NameType.VARIABLE);
       code += 'var ' + endVar + ' = ' + argument1 + ';\n';
     }
     // Determine loop direction at start, in case one of the bounds
     // changes during loop execution.
-    const incVar = javascriptGenerator.nameDB_.getDistinctName(
+    const incVar = generator.nameDB_.getDistinctName(
         variable0 + '_inc', NameType.VARIABLE);
     code += 'var ' + incVar + ' = ';
     if (stringUtils.isNumber(increment)) {
@@ -117,7 +117,7 @@ javascriptGenerator.forBlock['controls_for'] = function(block) {
       code += 'Math.abs(' + increment + ');\n';
     }
     code += 'if (' + startVar + ' > ' + endVar + ') {\n';
-    code += javascriptGenerator.INDENT + incVar + ' = -' + incVar + ';\n';
+    code += generator.INDENT + incVar + ' = -' + incVar + ';\n';
     code += '}\n';
     code += 'for (' + variable0 + ' = ' + startVar + '; ' + incVar +
         ' >= 0 ? ' + variable0 + ' <= ' + endVar + ' : ' + variable0 +
@@ -127,54 +127,54 @@ javascriptGenerator.forBlock['controls_for'] = function(block) {
   return code;
 };
 
-javascriptGenerator.forBlock['controls_forEach'] = function(block) {
+javascriptGenerator.forBlock['controls_forEach'] = function(block, generator) {
   // For each loop.
   const variable0 =
-      javascriptGenerator.nameDB_.getName(
+      generator.nameDB_.getName(
         block.getFieldValue('VAR'), NameType.VARIABLE);
   const argument0 =
-      javascriptGenerator.valueToCode(block, 'LIST', Order.ASSIGNMENT) ||
+      generator.valueToCode(block, 'LIST', Order.ASSIGNMENT) ||
       '[]';
-  let branch = javascriptGenerator.statementToCode(block, 'DO');
-  branch = javascriptGenerator.addLoopTrap(branch, block);
+  let branch = generator.statementToCode(block, 'DO');
+  branch = generator.addLoopTrap(branch, block);
   let code = '';
   // Cache non-trivial values to variables to prevent repeated look-ups.
   let listVar = argument0;
   if (!argument0.match(/^\w+$/)) {
-    listVar = javascriptGenerator.nameDB_.getDistinctName(
+    listVar = generator.nameDB_.getDistinctName(
         variable0 + '_list', NameType.VARIABLE);
     code += 'var ' + listVar + ' = ' + argument0 + ';\n';
   }
-  const indexVar = javascriptGenerator.nameDB_.getDistinctName(
+  const indexVar = generator.nameDB_.getDistinctName(
       variable0 + '_index', NameType.VARIABLE);
-  branch = javascriptGenerator.INDENT + variable0 + ' = ' + listVar +
+  branch = generator.INDENT + variable0 + ' = ' + listVar +
       '[' + indexVar + '];\n' + branch;
   code += 'for (var ' + indexVar + ' in ' + listVar + ') {\n' + branch + '}\n';
   return code;
 };
 
-javascriptGenerator.forBlock['controls_flow_statements'] = function(block) {
+javascriptGenerator.forBlock['controls_flow_statements'] = function(block, generator) {
   // Flow statements: continue, break.
   let xfix = '';
-  if (javascriptGenerator.STATEMENT_PREFIX) {
+  if (generator.STATEMENT_PREFIX) {
     // Automatic prefix insertion is switched off for this block.  Add manually.
-    xfix += javascriptGenerator.injectId(
-        javascriptGenerator.STATEMENT_PREFIX, block);
+    xfix += generator.injectId(
+        generator.STATEMENT_PREFIX, block);
   }
-  if (javascriptGenerator.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 += javascriptGenerator.injectId(
-        javascriptGenerator.STATEMENT_SUFFIX, block);
+    xfix += generator.injectId(
+        generator.STATEMENT_SUFFIX, block);
   }
-  if (javascriptGenerator.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 += javascriptGenerator.injectId(
-          javascriptGenerator.STATEMENT_PREFIX, loop);
+      xfix += generator.injectId(
+          generator.STATEMENT_PREFIX, loop);
     }
   }
   switch (block.getFieldValue('FLOW')) {

generators/javascript/math.js

@@ -16,7 +16,7 @@ import {NameType} from '../../core/names.js';
 import {Order, javascriptGenerator} from '../javascript.js';
 
 
-javascriptGenerator.forBlock['math_number'] = function(block) {
+javascriptGenerator.forBlock['math_number'] = function(block, generator) {
   // Numeric value.
   const code = Number(block.getFieldValue('NUM'));
   const order = code >= 0 ? Order.ATOMIC :
@@ -24,7 +24,7 @@ javascriptGenerator.forBlock['math_number'] = function(block) {
   return [code, order];
 };
 
-javascriptGenerator.forBlock['math_arithmetic'] = function(block) {
+javascriptGenerator.forBlock['math_arithmetic'] = function(block, generator) {
   // Basic arithmetic operators, and power.
   const OPERATORS = {
     'ADD': [' + ', Order.ADDITION],
@@ -36,8 +36,8 @@ javascriptGenerator.forBlock['math_arithmetic'] = function(block) {
   const tuple = OPERATORS[block.getFieldValue('OP')];
   const operator = tuple[0];
   const order = tuple[1];
-  const argument0 = javascriptGenerator.valueToCode(block, 'A', order) || '0';
-  const argument1 = javascriptGenerator.valueToCode(block, 'B', order) || '0';
+  const argument0 = generator.valueToCode(block, 'A', order) || '0';
+  const argument1 = generator.valueToCode(block, 'B', order) || '0';
   let code;
   // Power in JavaScript requires a special case since it has no operator.
   if (!operator) {
@@ -48,14 +48,14 @@ javascriptGenerator.forBlock['math_arithmetic'] = function(block) {
   return [code, order];
 };
 
-javascriptGenerator.forBlock['math_single'] = function(block) {
+javascriptGenerator.forBlock['math_single'] = function(block, generator) {
   // Math operators with single operand.
   const operator = block.getFieldValue('OP');
   let code;
   let arg;
   if (operator === 'NEG') {
     // Negation is a special case given its different operator precedence.
-    arg = javascriptGenerator.valueToCode(block, 'NUM',
+    arg = generator.valueToCode(block, 'NUM',
         Order.UNARY_NEGATION) || '0';
     if (arg[0] === '-') {
       // --3 is not legal in JS.
@@ -65,10 +65,10 @@ javascriptGenerator.forBlock['math_single'] = function(block) {
     return [code, Order.UNARY_NEGATION];
   }
   if (operator === 'SIN' || operator === 'COS' || operator === 'TAN') {
-    arg = javascriptGenerator.valueToCode(block, 'NUM',
+    arg = generator.valueToCode(block, 'NUM',
         Order.DIVISION) || '0';
   } else {
-    arg = javascriptGenerator.valueToCode(block, 'NUM',
+    arg = generator.valueToCode(block, 'NUM',
         Order.NONE) || '0';
   }
   // First, handle cases which generate values that don't need parentheses
@@ -132,7 +132,7 @@ javascriptGenerator.forBlock['math_single'] = function(block) {
   return [code, Order.DIVISION];
 };
 
-javascriptGenerator.forBlock['math_constant'] = function(block) {
+javascriptGenerator.forBlock['math_constant'] = function(block, generator) {
   // Constants: PI, E, the Golden Ratio, sqrt(2), 1/sqrt(2), INFINITY.
   const CONSTANTS = {
     'PI': ['Math.PI', Order.MEMBER],
@@ -145,7 +145,7 @@ javascriptGenerator.forBlock['math_constant'] = function(block) {
   return CONSTANTS[block.getFieldValue('CONSTANT')];
 };
 
-javascriptGenerator.forBlock['math_number_property'] = function(block) {
+javascriptGenerator.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 = {
@@ -163,13 +163,13 @@ javascriptGenerator.forBlock['math_number_property'] = function(block) {
   const dropdownProperty = block.getFieldValue('PROPERTY');
   const [suffix, inputOrder, outputOrder] = PROPERTIES[dropdownProperty];
   const numberToCheck =
-      javascriptGenerator.valueToCode(block, 'NUMBER_TO_CHECK', inputOrder) ||
+      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 = javascriptGenerator.provideFunction_('mathIsPrime', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(n) {
+    const functionName = generator.provideFunction_('mathIsPrime', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(n) {
   // https://en.wikipedia.org/wiki/Primality_test#Naive_methods
   if (n == 2 || n == 3) {
     return true;
@@ -190,7 +190,7 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(n) {
 `);
     code = functionName + '(' + numberToCheck + ')';
   } else if (dropdownProperty === 'DIVISIBLE_BY') {
-    const divisor = javascriptGenerator.valueToCode(block, 'DIVISOR',
+    const divisor = generator.valueToCode(block, 'DIVISOR',
         Order.MODULUS) || '0';
     code = numberToCheck + ' % ' + divisor + ' === 0';
   } else {
@@ -199,11 +199,11 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(n) {
   return [code, outputOrder];
 };
 
-javascriptGenerator.forBlock['math_change'] = function(block) {
+javascriptGenerator.forBlock['math_change'] = function(block, generator) {
   // Add to a variable in place.
-  const argument0 = javascriptGenerator.valueToCode(block, 'DELTA',
+  const argument0 = generator.valueToCode(block, 'DELTA',
       Order.ADDITION) || '0';
-  const varName = javascriptGenerator.nameDB_.getName(
+  const varName = generator.nameDB_.getName(
       block.getFieldValue('VAR'), NameType.VARIABLE);
   return varName + ' = (typeof ' + varName + ' === \'number\' ? ' + varName +
       ' : 0) + ' + argument0 + ';\n';
@@ -216,43 +216,43 @@ javascriptGenerator.forBlock['math_round'] =
 javascriptGenerator.forBlock['math_trig'] =
     javascriptGenerator.forBlock['math_single'];
 
-javascriptGenerator.forBlock['math_on_list'] = function(block) {
+javascriptGenerator.forBlock['math_on_list'] = function(block, generator) {
   // Math functions for lists.
   const func = block.getFieldValue('OP');
   let list;
   let code;
   switch (func) {
     case 'SUM':
-      list = javascriptGenerator.valueToCode(block, 'LIST',
+      list = generator.valueToCode(block, 'LIST',
           Order.MEMBER) || '[]';
       code = list + '.reduce(function(x, y) {return x + y;}, 0)';
       break;
     case 'MIN':
-      list = javascriptGenerator.valueToCode(block, 'LIST',
+      list = generator.valueToCode(block, 'LIST',
           Order.NONE) || '[]';
       code = 'Math.min.apply(null, ' + list + ')';
       break;
     case 'MAX':
-      list = javascriptGenerator.valueToCode(block, 'LIST',
+      list = generator.valueToCode(block, 'LIST',
           Order.NONE) || '[]';
       code = 'Math.max.apply(null, ' + list + ')';
       break;
     case 'AVERAGE': {
       // mathMean([null,null,1,3]) === 2.0.
-      const functionName = javascriptGenerator.provideFunction_('mathMean', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(myList) {
+      const functionName = generator.provideFunction_('mathMean', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(myList) {
   return myList.reduce(function(x, y) {return x + y;}, 0) / myList.length;
 }
 `);
-      list = javascriptGenerator.valueToCode(block, 'LIST',
+      list = generator.valueToCode(block, 'LIST',
           Order.NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
     }
     case 'MEDIAN': {
       // mathMedian([null,null,1,3]) === 2.0.
-      const functionName = javascriptGenerator.provideFunction_('mathMedian', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(myList) {
+      const functionName = generator.provideFunction_('mathMedian', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(myList) {
   var localList = myList.filter(function (x) {return typeof x === 'number';});
   if (!localList.length) return null;
   localList.sort(function(a, b) {return b - a;});
@@ -263,7 +263,7 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(myList) {
   }
 }
 `);
-      list = javascriptGenerator.valueToCode(block, 'LIST',
+      list = generator.valueToCode(block, 'LIST',
           Order.NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
@@ -272,8 +272,8 @@ function ${javascriptGenerator.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 = javascriptGenerator.provideFunction_('mathModes', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(values) {
+      const functionName = generator.provideFunction_('mathModes', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(values) {
   var modes = [];
   var counts = [];
   var maxCount = 0;
@@ -302,15 +302,15 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(values) {
   return modes;
 }
 `);
-      list = javascriptGenerator.valueToCode(block, 'LIST',
+      list = generator.valueToCode(block, 'LIST',
           Order.NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
     }
     case 'STD_DEV': {
       const functionName =
-          javascriptGenerator.provideFunction_('mathStandardDeviation', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(numbers) {
+          generator.provideFunction_('mathStandardDeviation', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(numbers) {
   var n = numbers.length;
   if (!n) return null;
   var mean = numbers.reduce(function(x, y) {return x + y;}) / n;
@@ -322,20 +322,20 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(numbers) {
   return Math.sqrt(variance);
 }
 `);
-      list = javascriptGenerator.valueToCode(block, 'LIST',
+      list = generator.valueToCode(block, 'LIST',
           Order.NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
     }
     case 'RANDOM': {
       const functionName =
-          javascriptGenerator.provideFunction_('mathRandomList', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(list) {
+          generator.provideFunction_('mathRandomList', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(list) {
   var x = Math.floor(Math.random() * list.length);
   return list[x];
 }
 `);
-      list = javascriptGenerator.valueToCode(block, 'LIST',
+      list = generator.valueToCode(block, 'LIST',
           Order.NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
@@ -346,37 +346,37 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(list) {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['math_modulo'] = function(block) {
+javascriptGenerator.forBlock['math_modulo'] = function(block, generator) {
   // Remainder computation.
-  const argument0 = javascriptGenerator.valueToCode(block, 'DIVIDEND',
+  const argument0 = generator.valueToCode(block, 'DIVIDEND',
       Order.MODULUS) || '0';
-  const argument1 = javascriptGenerator.valueToCode(block, 'DIVISOR',
+  const argument1 = generator.valueToCode(block, 'DIVISOR',
       Order.MODULUS) || '0';
   const code = argument0 + ' % ' + argument1;
   return [code, Order.MODULUS];
 };
 
-javascriptGenerator.forBlock['math_constrain'] = function(block) {
+javascriptGenerator.forBlock['math_constrain'] = function(block, generator) {
   // Constrain a number between two limits.
-  const argument0 = javascriptGenerator.valueToCode(block, 'VALUE',
+  const argument0 = generator.valueToCode(block, 'VALUE',
       Order.NONE) || '0';
-  const argument1 = javascriptGenerator.valueToCode(block, 'LOW',
+  const argument1 = generator.valueToCode(block, 'LOW',
       Order.NONE) || '0';
-  const argument2 = javascriptGenerator.valueToCode(block, 'HIGH',
+  const argument2 = generator.valueToCode(block, 'HIGH',
       Order.NONE) || 'Infinity';
   const code = 'Math.min(Math.max(' + argument0 + ', ' + argument1 + '), ' +
       argument2 + ')';
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['math_random_int'] = function(block) {
+javascriptGenerator.forBlock['math_random_int'] = function(block, generator) {
   // Random integer between [X] and [Y].
-  const argument0 = javascriptGenerator.valueToCode(block, 'FROM',
+  const argument0 = generator.valueToCode(block, 'FROM',
       Order.NONE) || '0';
-  const argument1 = javascriptGenerator.valueToCode(block, 'TO',
+  const argument1 = generator.valueToCode(block, 'TO',
       Order.NONE) || '0';
-  const functionName = javascriptGenerator.provideFunction_('mathRandomInt', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(a, b) {
+  const functionName = generator.provideFunction_('mathRandomInt', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(a, b) {
   if (a > b) {
     // Swap a and b to ensure a is smaller.
     var c = a;
@@ -390,16 +390,16 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(a, b) {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['math_random_float'] = function(block) {
+javascriptGenerator.forBlock['math_random_float'] = function(block, generator) {
   // Random fraction between 0 and 1.
   return ['Math.random()', Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['math_atan2'] = function(block) {
+javascriptGenerator.forBlock['math_atan2'] = function(block, generator) {
   // Arctangent of point (X, Y) in degrees from -180 to 180.
-  const argument0 = javascriptGenerator.valueToCode(block, 'X',
+  const argument0 = generator.valueToCode(block, 'X',
       Order.NONE) || '0';
-  const argument1 = javascriptGenerator.valueToCode(block, 'Y',
+  const argument1 = generator.valueToCode(block, 'Y',
       Order.NONE) || '0';
   return ['Math.atan2(' + argument1 + ', ' + argument0 + ') / Math.PI * 180',
       Order.DIVISION];

generators/javascript/procedures.js

@@ -15,51 +15,51 @@ import {NameType} from '../../core/names.js';
 import {Order, javascriptGenerator} from '../javascript.js';
 
 
-javascriptGenerator.forBlock['procedures_defreturn'] = function(block) {
+javascriptGenerator.forBlock['procedures_defreturn'] = function(block, generator) {
   // Define a procedure with a return value.
-  const funcName = javascriptGenerator.nameDB_.getName(
+  const funcName = generator.nameDB_.getName(
       block.getFieldValue('NAME'), NameType.PROCEDURE);
   let xfix1 = '';
-  if (javascriptGenerator.STATEMENT_PREFIX) {
-    xfix1 += javascriptGenerator.injectId(
-        javascriptGenerator.STATEMENT_PREFIX, block);
+  if (generator.STATEMENT_PREFIX) {
+    xfix1 += generator.injectId(
+        generator.STATEMENT_PREFIX, block);
   }
-  if (javascriptGenerator.STATEMENT_SUFFIX) {
-    xfix1 += javascriptGenerator.injectId(
-        javascriptGenerator.STATEMENT_SUFFIX, block);
+  if (generator.STATEMENT_SUFFIX) {
+    xfix1 += generator.injectId(
+        generator.STATEMENT_SUFFIX, block);
   }
   if (xfix1) {
-    xfix1 = javascriptGenerator.prefixLines(xfix1, javascriptGenerator.INDENT);
+    xfix1 = generator.prefixLines(xfix1, generator.INDENT);
   }
   let loopTrap = '';
-  if (javascriptGenerator.INFINITE_LOOP_TRAP) {
-    loopTrap = javascriptGenerator.prefixLines(
-        javascriptGenerator.injectId(
-          javascriptGenerator.INFINITE_LOOP_TRAP, block),
-        javascriptGenerator.INDENT);
+  if (generator.INFINITE_LOOP_TRAP) {
+    loopTrap = generator.prefixLines(
+        generator.injectId(
+          generator.INFINITE_LOOP_TRAP, block),
+        generator.INDENT);
   }
-  const branch = javascriptGenerator.statementToCode(block, 'STACK');
+  const branch = generator.statementToCode(block, 'STACK');
   let returnValue =
-      javascriptGenerator.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.
     xfix2 = xfix1;
   }
   if (returnValue) {
-    returnValue = javascriptGenerator.INDENT + 'return ' + returnValue + ';\n';
+    returnValue = generator.INDENT + 'return ' + returnValue + ';\n';
   }
   const args = [];
   const variables = block.getVars();
   for (let i = 0; i < variables.length; i++) {
     args[i] =
-        javascriptGenerator.nameDB_.getName(variables[i], NameType.VARIABLE);
+        generator.nameDB_.getName(variables[i], NameType.VARIABLE);
   }
   let code = 'function ' + funcName + '(' + args.join(', ') + ') {\n' + xfix1 +
       loopTrap + branch + xfix2 + returnValue + '}';
-  code = javascriptGenerator.scrub_(block, code);
+  code = generator.scrub_(block, code);
   // Add % so as not to collide with helper functions in definitions list.
-  javascriptGenerator.definitions_['%' + funcName] = code;
+  generator.definitions_['%' + funcName] = code;
   return null;
 };
 
@@ -68,56 +68,48 @@ javascriptGenerator.forBlock['procedures_defreturn'] = function(block) {
 javascriptGenerator.forBlock['procedures_defnoreturn'] =
     javascriptGenerator.forBlock['procedures_defreturn'];
 
-javascriptGenerator.forBlock['procedures_callreturn'] = function(block) {
+javascriptGenerator.forBlock['procedures_callreturn'] = function(block, generator) {
   // Call a procedure with a return value.
-  const funcName = javascriptGenerator.nameDB_.getName(
+  const funcName = generator.nameDB_.getName(
       block.getFieldValue('NAME'), NameType.PROCEDURE);
   const args = [];
   const variables = block.getVars();
   for (let i = 0; i < variables.length; i++) {
-    args[i] = javascriptGenerator.valueToCode(block, 'ARG' + i, Order.NONE) ||
+    args[i] = generator.valueToCode(block, 'ARG' + i, Order.NONE) ||
         'null';
   }
   const code = funcName + '(' + args.join(', ') + ')';
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['procedures_callnoreturn'] = function(block) {
+javascriptGenerator.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 = javascriptGenerator.forBlock['procedures_callreturn'](block);
+  const tuple = generator.forBlock['procedures_callreturn'](block, generator);
   return tuple[0] + ';\n';
 };
 
-javascriptGenerator.forBlock['procedures_callnoreturn'] = function(block) {
-  // 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 = javascriptGenerator.forBlock['procedures_callreturn'](block);
-  return tuple[0] + ';\n';
-};
-
-javascriptGenerator.forBlock['procedures_ifreturn'] = function(block) {
+javascriptGenerator.forBlock['procedures_ifreturn'] = function(block, generator) {
   // Conditionally return value from a procedure.
   const condition =
-      javascriptGenerator.valueToCode(block, 'CONDITION', Order.NONE) ||
+      generator.valueToCode(block, 'CONDITION', Order.NONE) ||
       'false';
   let code = 'if (' + condition + ') {\n';
-  if (javascriptGenerator.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 += javascriptGenerator.prefixLines(
-        javascriptGenerator.injectId(
-          javascriptGenerator.STATEMENT_SUFFIX, block),
-        javascriptGenerator.INDENT);
+    code += generator.prefixLines(
+        generator.injectId(
+          generator.STATEMENT_SUFFIX, block),
+        generator.INDENT);
   }
   if (block.hasReturnValue_) {
     const value =
-        javascriptGenerator.valueToCode(block, 'VALUE', Order.NONE) || 'null';
-    code += javascriptGenerator.INDENT + 'return ' + value + ';\n';
+        generator.valueToCode(block, 'VALUE', Order.NONE) || 'null';
+    code += generator.INDENT + 'return ' + value + ';\n';
   } else {
-    code += javascriptGenerator.INDENT + 'return;\n';
+    code += generator.INDENT + 'return;\n';
   }
   code += '}\n';
   return code;

generators/javascript/text.js

@@ -53,36 +53,36 @@ const getSubstringIndex = function(stringName, where, opt_at) {
   }
 };
 
-javascriptGenerator.forBlock['text'] = function(block) {
+javascriptGenerator.forBlock['text'] = function(block, generator) {
   // Text value.
-  const code = javascriptGenerator.quote_(block.getFieldValue('TEXT'));
+  const code = generator.quote_(block.getFieldValue('TEXT'));
   return [code, Order.ATOMIC];
 };
 
-javascriptGenerator.forBlock['text_multiline'] = function(block) {
+javascriptGenerator.forBlock['text_multiline'] = function(block, generator) {
   // Text value.
   const code =
-      javascriptGenerator.multiline_quote_(block.getFieldValue('TEXT'));
+      generator.multiline_quote_(block.getFieldValue('TEXT'));
   const order = code.indexOf('+') !== -1 ? Order.ADDITION :
       Order.ATOMIC;
   return [code, order];
 };
 
-javascriptGenerator.forBlock['text_join'] = function(block) {
+javascriptGenerator.forBlock['text_join'] = function(block, generator) {
   // Create a string made up of any number of elements of any type.
   switch (block.itemCount_) {
     case 0:
       return ["''", Order.ATOMIC];
     case 1: {
-      const element = javascriptGenerator.valueToCode(block, 'ADD0',
+      const element = generator.valueToCode(block, 'ADD0',
           Order.NONE) || "''";
       const codeAndOrder = forceString(element);
       return codeAndOrder;
     }
     case 2: {
-      const element0 = javascriptGenerator.valueToCode(block, 'ADD0',
+      const element0 = generator.valueToCode(block, 'ADD0',
           Order.NONE) || "''";
-      const element1 = javascriptGenerator.valueToCode(block, 'ADD1',
+      const element1 = generator.valueToCode(block, 'ADD1',
           Order.NONE) || "''";
       const code = forceString(element0)[0] +
           ' + ' + forceString(element1)[0];
@@ -91,7 +91,7 @@ javascriptGenerator.forBlock['text_join'] = function(block) {
     default: {
       const elements = new Array(block.itemCount_);
       for (let i = 0; i < block.itemCount_; i++) {
-        elements[i] = javascriptGenerator.valueToCode(block, 'ADD' + i,
+        elements[i] = generator.valueToCode(block, 'ADD' + i,
             Order.NONE) || "''";
       }
       const code = '[' + elements.join(',') + '].join(\'\')';
@@ -100,38 +100,38 @@ javascriptGenerator.forBlock['text_join'] = function(block) {
   }
 };
 
-javascriptGenerator.forBlock['text_append'] = function(block) {
+javascriptGenerator.forBlock['text_append'] = function(block, generator) {
   // Append to a variable in place.
-  const varName = javascriptGenerator.nameDB_.getName(
+  const varName = generator.nameDB_.getName(
       block.getFieldValue('VAR'), NameType.VARIABLE);
-  const value = javascriptGenerator.valueToCode(block, 'TEXT',
+  const value = generator.valueToCode(block, 'TEXT',
       Order.NONE) || "''";
   const code = varName + ' += ' +
       forceString(value)[0] + ';\n';
   return code;
 };
 
-javascriptGenerator.forBlock['text_length'] = function(block) {
+javascriptGenerator.forBlock['text_length'] = function(block, generator) {
   // String or array length.
-  const text = javascriptGenerator.valueToCode(block, 'VALUE',
+  const text = generator.valueToCode(block, 'VALUE',
       Order.MEMBER) || "''";
   return [text + '.length', Order.MEMBER];
 };
 
-javascriptGenerator.forBlock['text_isEmpty'] = function(block) {
+javascriptGenerator.forBlock['text_isEmpty'] = function(block, generator) {
   // Is the string null or array empty?
-  const text = javascriptGenerator.valueToCode(block, 'VALUE',
+  const text = generator.valueToCode(block, 'VALUE',
       Order.MEMBER) || "''";
   return ['!' + text + '.length', Order.LOGICAL_NOT];
 };
 
-javascriptGenerator.forBlock['text_indexOf'] = function(block) {
+javascriptGenerator.forBlock['text_indexOf'] = function(block, generator) {
   // Search the text for a substring.
   const operator = block.getFieldValue('END') === 'FIRST' ?
       'indexOf' : 'lastIndexOf';
-  const substring = javascriptGenerator.valueToCode(block, 'FIND',
+  const substring = generator.valueToCode(block, 'FIND',
       Order.NONE) || "''";
-  const text = javascriptGenerator.valueToCode(block, 'VALUE',
+  const text = generator.valueToCode(block, 'VALUE',
       Order.MEMBER) || "''";
   const code = text + '.' + operator + '(' + substring + ')';
   // Adjust index if using one-based indices.
@@ -141,14 +141,14 @@ javascriptGenerator.forBlock['text_indexOf'] = function(block) {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['text_charAt'] = function(block) {
+javascriptGenerator.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 textOrder = (where === 'RANDOM') ? Order.NONE :
       Order.MEMBER;
   const text =
-      javascriptGenerator.valueToCode(block, 'VALUE', textOrder) || "''";
+      generator.valueToCode(block, 'VALUE', textOrder) || "''";
   switch (where) {
     case 'FIRST': {
       const code = text + '.charAt(0)';
@@ -159,20 +159,20 @@ javascriptGenerator.forBlock['text_charAt'] = function(block) {
       return [code, Order.FUNCTION_CALL];
     }
     case 'FROM_START': {
-      const at = javascriptGenerator.getAdjusted(block, 'AT');
+      const at = generator.getAdjusted(block, 'AT');
       // Adjust index if using one-based indices.
       const code = text + '.charAt(' + at + ')';
       return [code, Order.FUNCTION_CALL];
     }
     case 'FROM_END': {
-      const at = javascriptGenerator.getAdjusted(block, 'AT', 1, true);
+      const at = generator.getAdjusted(block, 'AT', 1, true);
       const code = text + '.slice(' + at + ').charAt(0)';
       return [code, Order.FUNCTION_CALL];
     }
     case 'RANDOM': {
       const functionName =
-          javascriptGenerator.provideFunction_('textRandomLetter', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(text) {
+          generator.provideFunction_('textRandomLetter', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(text) {
   var x = Math.floor(Math.random() * text.length);
   return text[x];
 }
@@ -184,7 +184,7 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(text) {
   throw Error('Unhandled option (text_charAt).');
 };
 
-javascriptGenerator.forBlock['text_getSubstring'] = function(block) {
+javascriptGenerator.forBlock['text_getSubstring'] = function(block, generator) {
   // Get substring.
   const where1 = block.getFieldValue('WHERE1');
   const where2 = block.getFieldValue('WHERE2');
@@ -193,7 +193,7 @@ javascriptGenerator.forBlock['text_getSubstring'] = function(block) {
   const textOrder = requiresLengthCall ? Order.MEMBER :
       Order.NONE;
   const text =
-      javascriptGenerator.valueToCode(block, 'STRING', textOrder) || "''";
+      generator.valueToCode(block, 'STRING', textOrder) || "''";
   let code;
   if (where1 === 'FIRST' && where2 === 'LAST') {
     code = text;
@@ -204,10 +204,10 @@ javascriptGenerator.forBlock['text_getSubstring'] = function(block) {
     let at1;
     switch (where1) {
       case 'FROM_START':
-        at1 = javascriptGenerator.getAdjusted(block, 'AT1');
+        at1 = generator.getAdjusted(block, 'AT1');
         break;
       case 'FROM_END':
-        at1 = javascriptGenerator.getAdjusted(block, 'AT1', 1, false,
+        at1 = generator.getAdjusted(block, 'AT1', 1, false,
             Order.SUBTRACTION);
         at1 = text + '.length - ' + at1;
         break;
@@ -220,10 +220,10 @@ javascriptGenerator.forBlock['text_getSubstring'] = function(block) {
     let at2;
     switch (where2) {
       case 'FROM_START':
-        at2 = javascriptGenerator.getAdjusted(block, 'AT2', 1);
+        at2 = generator.getAdjusted(block, 'AT2', 1);
         break;
       case 'FROM_END':
-        at2 = javascriptGenerator.getAdjusted(block, 'AT2', 0, false,
+        at2 = generator.getAdjusted(block, 'AT2', 0, false,
             Order.SUBTRACTION);
         at2 = text + '.length - ' + at2;
         break;
@@ -235,8 +235,8 @@ javascriptGenerator.forBlock['text_getSubstring'] = function(block) {
     }
     code = text + '.slice(' + at1 + ', ' + at2 + ')';
   } else {
-    const at1 = javascriptGenerator.getAdjusted(block, 'AT1');
-    const at2 = javascriptGenerator.getAdjusted(block, 'AT2');
+    const at1 = generator.getAdjusted(block, 'AT1');
+    const at2 = generator.getAdjusted(block, 'AT2');
     const wherePascalCase = {'FIRST': 'First', 'LAST': 'Last',
       'FROM_START': 'FromStart', 'FROM_END': 'FromEnd'};
     // The value for 'FROM_END' and'FROM_START' depends on `at` so
@@ -245,9 +245,9 @@ javascriptGenerator.forBlock['text_getSubstring'] = function(block) {
         (where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : '';
     const at2Param =
         (where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : '';
-    const functionName = javascriptGenerator.provideFunction_(
+    const functionName = generator.provideFunction_(
         'subsequence' + wherePascalCase[where1] + wherePascalCase[where2], `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}) {
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}) {
   var start = ${getSubstringIndex('sequence', where1, 'at1')};
   var end = ${getSubstringIndex('sequence', where2, 'at2')} + 1;
   return sequence.slice(start, end);
@@ -263,7 +263,7 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['text_changeCase'] = function(block) {
+javascriptGenerator.forBlock['text_changeCase'] = function(block, generator) {
   // Change capitalization.
   const OPERATORS = {
     'UPPERCASE': '.toUpperCase()',
@@ -273,16 +273,16 @@ javascriptGenerator.forBlock['text_changeCase'] = function(block) {
   const operator = OPERATORS[block.getFieldValue('CASE')];
   const textOrder = operator ? Order.MEMBER : Order.NONE;
   const text =
-      javascriptGenerator.valueToCode(block, 'TEXT', textOrder) || "''";
+      generator.valueToCode(block, 'TEXT', textOrder) || "''";
   let code;
   if (operator) {
-    // Upper and lower case are functions built into javascriptGenerator.
+    // Upper and lower case are functions built into generator.
     code = text + operator;
   } else {
     // Title case is not a native JavaScript function.  Define one.
     const functionName =
-        javascriptGenerator.provideFunction_('textToTitleCase', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(str) {
+        generator.provideFunction_('textToTitleCase', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(str) {
   return str.replace(/\\S+/g,
       function(txt) {return txt[0].toUpperCase() + txt.substring(1).toLowerCase();});
 }
@@ -292,7 +292,7 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(str) {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['text_trim'] = function(block) {
+javascriptGenerator.forBlock['text_trim'] = function(block, generator) {
   // Trim spaces.
   const OPERATORS = {
     'LEFT': ".replace(/^[\\s\\xa0]+/, '')",
@@ -300,27 +300,27 @@ javascriptGenerator.forBlock['text_trim'] = function(block) {
     'BOTH': '.trim()',
   };
   const operator = OPERATORS[block.getFieldValue('MODE')];
-  const text = javascriptGenerator.valueToCode(block, 'TEXT',
+  const text = generator.valueToCode(block, 'TEXT',
       Order.MEMBER) || "''";
   return [text + operator, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['text_print'] = function(block) {
+javascriptGenerator.forBlock['text_print'] = function(block, generator) {
   // Print statement.
-  const msg = javascriptGenerator.valueToCode(block, 'TEXT',
+  const msg = generator.valueToCode(block, 'TEXT',
       Order.NONE) || "''";
   return 'window.alert(' + msg + ');\n';
 };
 
-javascriptGenerator.forBlock['text_prompt_ext'] = function(block) {
+javascriptGenerator.forBlock['text_prompt_ext'] = function(block, generator) {
   // Prompt function.
   let msg;
   if (block.getField('TEXT')) {
     // Internal message.
-    msg = javascriptGenerator.quote_(block.getFieldValue('TEXT'));
+    msg = generator.quote_(block.getFieldValue('TEXT'));
   } else {
     // External message.
-    msg = javascriptGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
+    msg = generator.valueToCode(block, 'TEXT', Order.NONE) || "''";
   }
   let code = 'window.prompt(' + msg + ')';
   const toNumber = block.getFieldValue('TYPE') === 'NUMBER';
@@ -333,13 +333,13 @@ javascriptGenerator.forBlock['text_prompt_ext'] = function(block) {
 javascriptGenerator.forBlock['text_prompt'] =
     javascriptGenerator.forBlock['text_prompt_ext'];
 
-javascriptGenerator.forBlock['text_count'] = function(block) {
-  const text = javascriptGenerator.valueToCode(block, 'TEXT',
+javascriptGenerator.forBlock['text_count'] = function(block, generator) {
+  const text = generator.valueToCode(block, 'TEXT',
       Order.NONE) || "''";
-  const sub = javascriptGenerator.valueToCode(block, 'SUB',
+  const sub = generator.valueToCode(block, 'SUB',
       Order.NONE) || "''";
-  const functionName = javascriptGenerator.provideFunction_('textCount', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle) {
+  const functionName = generator.provideFunction_('textCount', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle) {
   if (needle.length === 0) {
     return haystack.length + 1;
   } else {
@@ -351,16 +351,16 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle) {
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['text_replace'] = function(block) {
-  const text = javascriptGenerator.valueToCode(block, 'TEXT',
+javascriptGenerator.forBlock['text_replace'] = function(block, generator) {
+  const text = generator.valueToCode(block, 'TEXT',
       Order.NONE) || "''";
-  const from = javascriptGenerator.valueToCode(block, 'FROM',
+  const from = generator.valueToCode(block, 'FROM',
       Order.NONE) || "''";
-  const to = javascriptGenerator.valueToCode(block, 'TO', Order.NONE) || "''";
+  const to = generator.valueToCode(block, 'TO', Order.NONE) || "''";
   // The regex escaping code below is taken from the implementation of
   // goog.string.regExpEscape.
-  const functionName = javascriptGenerator.provideFunction_('textReplace', `
-function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle, replacement) {
+  const functionName = generator.provideFunction_('textReplace', `
+function ${generator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle, replacement) {
   needle = needle.replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g, '\\\\$1')
                  .replace(/\\x08/g, '\\\\x08');
   return haystack.replace(new RegExp(needle, 'g'), replacement);
@@ -370,8 +370,8 @@ function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle, rep
   return [code, Order.FUNCTION_CALL];
 };
 
-javascriptGenerator.forBlock['text_reverse'] = function(block) {
-  const text = javascriptGenerator.valueToCode(block, 'TEXT',
+javascriptGenerator.forBlock['text_reverse'] = function(block, generator) {
+  const text = generator.valueToCode(block, 'TEXT',
       Order.MEMBER) || "''";
   const code = text + ".split('').reverse().join('')";
   return [code, Order.FUNCTION_CALL];

generators/javascript/variables.js

@@ -15,18 +15,18 @@ import {NameType} from '../../core/names.js';
 import {Order, javascriptGenerator} from '../javascript.js';
 
 
-javascriptGenerator.forBlock['variables_get'] = function(block) {
+javascriptGenerator.forBlock['variables_get'] = function(block, generator) {
   // Variable getter.
-  const code = javascriptGenerator.nameDB_.getName(block.getFieldValue('VAR'),
+  const code = generator.nameDB_.getName(block.getFieldValue('VAR'),
       NameType.VARIABLE);
   return [code, Order.ATOMIC];
 };
 
-javascriptGenerator.forBlock['variables_set'] = function(block) {
+javascriptGenerator.forBlock['variables_set'] = function(block, generator) {
   // Variable setter.
-  const argument0 = javascriptGenerator.valueToCode(
+  const argument0 = generator.valueToCode(
                         block, 'VALUE', Order.ASSIGNMENT) || '0';
-  const varName = javascriptGenerator.nameDB_.getName(
+  const varName = generator.nameDB_.getName(
       block.getFieldValue('VAR'), NameType.VARIABLE);
   return varName + ' = ' + argument0 + ';\n';
 };