blockly 7.20211209.4 → 8.0.0

package/core/generator.js

@@ -29,390 +29,508 @@ const {Workspace} = goog.requireType('Blockly.Workspace');
 
 /**
  * Class for a code generator that translates the blocks into a language.
- * @param {string} name Language name of this generator.
- * @constructor
+ * @unrestricted
  * @alias Blockly.Generator
  */
-const Generator = function(name) {
-  this.name_ = name;
-  this.FUNCTION_NAME_PLACEHOLDER_REGEXP_ =
-      new RegExp(this.FUNCTION_NAME_PLACEHOLDER_, 'g');
-};
+class Generator {
+  /**
+   * @param {string} name Language name of this generator.
+   */
+  constructor(name) {
+    this.name_ = name;
 
-/**
- * Arbitrary code to inject into locations that risk causing infinite loops.
- * Any instances of '%1' will be replaced by the block ID that failed.
- * E.g. '  checkTimeout(%1);\n'
- * @type {?string}
- */
-Generator.prototype.INFINITE_LOOP_TRAP = null;
+    /**
+     * This is used as a placeholder in functions defined using
+     * Generator.provideFunction_.  It must not be legal code that could
+     * legitimately appear in a function definition (or comment), and it must
+     * not confuse the regular expression parser.
+     * @type {string}
+     * @protected
+     */
+    this.FUNCTION_NAME_PLACEHOLDER_ = '{leCUI8hutHZI4480Dc}';
 
-/**
- * Arbitrary code to inject before every statement.
- * Any instances of '%1' will be replaced by the block ID of the statement.
- * E.g. 'highlight(%1);\n'
- * @type {?string}
- */
-Generator.prototype.STATEMENT_PREFIX = null;
+    this.FUNCTION_NAME_PLACEHOLDER_REGEXP_ =
+        new RegExp(this.FUNCTION_NAME_PLACEHOLDER_, 'g');
 
-/**
- * Arbitrary code to inject after every statement.
- * Any instances of '%1' will be replaced by the block ID of the statement.
- * E.g. 'highlight(%1);\n'
- * @type {?string}
- */
-Generator.prototype.STATEMENT_SUFFIX = null;
+    /**
+     * Arbitrary code to inject into locations that risk causing infinite loops.
+     * Any instances of '%1' will be replaced by the block ID that failed.
+     * E.g. '  checkTimeout(%1);\n'
+     * @type {?string}
+     */
+    this.INFINITE_LOOP_TRAP = null;
 
-/**
- * The method of indenting.  Defaults to two spaces, but language generators
- * may override this to increase indent or change to tabs.
- * @type {string}
- */
-Generator.prototype.INDENT = '  ';
+    /**
+     * Arbitrary code to inject before every statement.
+     * Any instances of '%1' will be replaced by the block ID of the statement.
+     * E.g. 'highlight(%1);\n'
+     * @type {?string}
+     */
+    this.STATEMENT_PREFIX = null;
 
-/**
- * Maximum length for a comment before wrapping.  Does not account for
- * indenting level.
- * @type {number}
- */
-Generator.prototype.COMMENT_WRAP = 60;
+    /**
+     * Arbitrary code to inject after every statement.
+     * Any instances of '%1' will be replaced by the block ID of the statement.
+     * E.g. 'highlight(%1);\n'
+     * @type {?string}
+     */
+    this.STATEMENT_SUFFIX = null;
 
-/**
- * List of outer-inner pairings that do NOT require parentheses.
- * @type {!Array<!Array<number>>}
- */
-Generator.prototype.ORDER_OVERRIDES = [];
+    /**
+     * The method of indenting.  Defaults to two spaces, but language generators
+     * may override this to increase indent or change to tabs.
+     * @type {string}
+     */
+    this.INDENT = '  ';
 
-/**
- * Whether the init method has been called.
- * Generators that set this flag to false after creation and true in init
- * will cause blockToCode to emit a warning if the generator has not been
- * initialized. If this flag is untouched, it will have no effect.
- * @type {?boolean}
- */
-Generator.prototype.isInitialized = null;
+    /**
+     * Maximum length for a comment before wrapping.  Does not account for
+     * indenting level.
+     * @type {number}
+     */
+    this.COMMENT_WRAP = 60;
 
-/**
- * Generate code for all blocks in the workspace to the specified language.
- * @param {!Workspace=} workspace Workspace to generate code from.
- * @return {string} Generated code.
- */
-Generator.prototype.workspaceToCode = function(workspace) {
-  if (!workspace) {
-    // Backwards compatibility from before there could be multiple workspaces.
-    console.warn('No workspace specified in workspaceToCode call.  Guessing.');
-    workspace = common.getMainWorkspace();
+    /**
+     * List of outer-inner pairings that do NOT require parentheses.
+     * @type {!Array<!Array<number>>}
+     */
+    this.ORDER_OVERRIDES = [];
+
+    /**
+     * Whether the init method has been called.
+     * Generators that set this flag to false after creation and true in init
+     * will cause blockToCode to emit a warning if the generator has not been
+     * initialized. If this flag is untouched, it will have no effect.
+     * @type {?boolean}
+     */
+    this.isInitialized = null;
+
+    /**
+     * Comma-separated list of reserved words.
+     * @type {string}
+     * @protected
+     */
+    this.RESERVED_WORDS_ = '';
+
+    /**
+     * A dictionary of definitions to be printed before the code.
+     * @type {!Object|undefined}
+     * @protected
+     */
+    this.definitions_ = undefined;
+
+    /**
+     * A dictionary mapping desired function names in definitions_ to actual
+     * function names (to avoid collisions with user functions).
+     * @type {!Object|undefined}
+     * @protected
+     */
+    this.functionNames_ = undefined;
+
+    /**
+     * A database of variable and procedure names.
+     * @type {!Names|undefined}
+     * @protected
+     */
+    this.nameDB_ = undefined;
   }
-  let code = [];
-  this.init(workspace);
-  const blocks = workspace.getTopBlocks(true);
-  for (let i = 0, block; (block = blocks[i]); i++) {
-    let line = this.blockToCode(block);
-    if (Array.isArray(line)) {
-      // Value blocks return tuples of code and operator order.
-      // Top-level blocks don't care about operator order.
-      line = line[0];
+
+  /**
+   * Generate code for all blocks in the workspace to the specified language.
+   * @param {!Workspace=} workspace Workspace to generate code from.
+   * @return {string} Generated code.
+   */
+  workspaceToCode(workspace) {
+    if (!workspace) {
+      // Backwards compatibility from before there could be multiple workspaces.
+      console.warn(
+          'No workspace specified in workspaceToCode call.  Guessing.');
+      workspace = common.getMainWorkspace();
     }
-    if (line) {
-      if (block.outputConnection) {
-        // This block is a naked value.  Ask the language's code generator if
-        // it wants to append a semicolon, or something.
-        line = this.scrubNakedValue(line);
-        if (this.STATEMENT_PREFIX && !block.suppressPrefixSuffix) {
-          line = this.injectId(this.STATEMENT_PREFIX, block) + line;
-        }
-        if (this.STATEMENT_SUFFIX && !block.suppressPrefixSuffix) {
-          line = line + this.injectId(this.STATEMENT_SUFFIX, block);
+    let code = [];
+    this.init(workspace);
+    const blocks = workspace.getTopBlocks(true);
+    for (let i = 0, block; (block = blocks[i]); i++) {
+      let line = this.blockToCode(block);
+      if (Array.isArray(line)) {
+        // Value blocks return tuples of code and operator order.
+        // Top-level blocks don't care about operator order.
+        line = line[0];
+      }
+      if (line) {
+        if (block.outputConnection) {
+          // This block is a naked value.  Ask the language's code generator if
+          // it wants to append a semicolon, or something.
+          line = this.scrubNakedValue(line);
+          if (this.STATEMENT_PREFIX && !block.suppressPrefixSuffix) {
+            line = this.injectId(this.STATEMENT_PREFIX, block) + line;
+          }
+          if (this.STATEMENT_SUFFIX && !block.suppressPrefixSuffix) {
+            line = line + this.injectId(this.STATEMENT_SUFFIX, block);
+          }
         }
+        code.push(line);
       }
-      code.push(line);
     }
+    code = code.join('\n');  // Blank line between each section.
+    code = this.finish(code);
+    // Final scrubbing of whitespace.
+    code = code.replace(/^\s+\n/, '');
+    code = code.replace(/\n\s+$/, '\n');
+    code = code.replace(/[ \t]+\n/g, '\n');
+    return code;
   }
-  code = code.join('\n');  // Blank line between each section.
-  code = this.finish(code);
-  // Final scrubbing of whitespace.
-  code = code.replace(/^\s+\n/, '');
-  code = code.replace(/\n\s+$/, '\n');
-  code = code.replace(/[ \t]+\n/g, '\n');
-  return code;
-};
-
-// The following are some helpful functions which can be used by multiple
-// languages.
 
-/**
- * Prepend a common prefix onto each line of code.
- * Intended for indenting code or adding comment markers.
- * @param {string} text The lines of code.
- * @param {string} prefix The common prefix.
- * @return {string} The prefixed lines of code.
- */
-Generator.prototype.prefixLines = function(text, prefix) {
-  return prefix + text.replace(/(?!\n$)\n/g, '\n' + prefix);
-};
+  // The following are some helpful functions which can be used by multiple
 
-/**
- * Recursively spider a tree of blocks, returning all their comments.
- * @param {!Block} block The block from which to start spidering.
- * @return {string} Concatenated list of comments.
- */
-Generator.prototype.allNestedComments = function(block) {
-  const comments = [];
-  const blocks = block.getDescendants(true);
-  for (let i = 0; i < blocks.length; i++) {
-    const comment = blocks[i].getCommentText();
-    if (comment) {
-      comments.push(comment);
-    }
-  }
-  // Append an empty string to create a trailing line break when joined.
-  if (comments.length) {
-    comments.push('');
-  }
-  return comments.join('\n');
-};
+  // languages.
 
-/**
- * Generate code for the specified block (and attached blocks).
- * The generator must be initialized before calling this function.
- * @param {Block} block The block to generate code for.
- * @param {boolean=} opt_thisOnly True to generate code for only this statement.
- * @return {string|!Array} For statement blocks, the generated code.
- *     For value blocks, an array containing the generated code and an
- *     operator order value.  Returns '' if block is null.
- */
-Generator.prototype.blockToCode = function(block, opt_thisOnly) {
-  if (this.isInitialized === false) {
-    console.warn(
-        'Generator init was not called before blockToCode was called.');
-  }
-  if (!block) {
-    return '';
-  }
-  if (!block.isEnabled()) {
-    // Skip past this block if it is disabled.
-    return opt_thisOnly ? '' : this.blockToCode(block.getNextBlock());
-  }
-  if (block.isInsertionMarker()) {
-    // Skip past insertion markers.
-    return opt_thisOnly ? '' : this.blockToCode(block.getChildren(false)[0]);
+  /**
+   * Prepend a common prefix onto each line of code.
+   * Intended for indenting code or adding comment markers.
+   * @param {string} text The lines of code.
+   * @param {string} prefix The common prefix.
+   * @return {string} The prefixed lines of code.
+   */
+  prefixLines(text, prefix) {
+    return prefix + text.replace(/(?!\n$)\n/g, '\n' + prefix);
   }
 
-  const func = this[block.type];
-  if (typeof func !== 'function') {
-    throw Error(
-        'Language "' + this.name_ + '" does not know how to generate ' +
-        'code for block type "' + block.type + '".');
+  /**
+   * Recursively spider a tree of blocks, returning all their comments.
+   * @param {!Block} block The block from which to start spidering.
+   * @return {string} Concatenated list of comments.
+   */
+  allNestedComments(block) {
+    const comments = [];
+    const blocks = block.getDescendants(true);
+    for (let i = 0; i < blocks.length; i++) {
+      const comment = blocks[i].getCommentText();
+      if (comment) {
+        comments.push(comment);
+      }
+    }
+    // Append an empty string to create a trailing line break when joined.
+    if (comments.length) {
+      comments.push('');
+    }
+    return comments.join('\n');
   }
-  // First argument to func.call is the value of 'this' in the generator.
-  // Prior to 24 September 2013 'this' was the only way to access the block.
-  // The current preferred method of accessing the block is through the second
-  // argument to func.call, which becomes the first parameter to the generator.
-  let code = func.call(block, block);
-  if (Array.isArray(code)) {
-    // Value blocks return tuples of code and operator order.
-    if (!block.outputConnection) {
-      throw TypeError('Expecting string from statement block: ' + block.type);
+
+  /**
+   * Generate code for the specified block (and attached blocks).
+   * The generator must be initialized before calling this function.
+   * @param {?Block} block The block to generate code for.
+   * @param {boolean=} opt_thisOnly True to generate code for only this
+   *     statement.
+   * @return {string|!Array} For statement blocks, the generated code.
+   *     For value blocks, an array containing the generated code and an
+   *     operator order value.  Returns '' if block is null.
+   */
+  blockToCode(block, opt_thisOnly) {
+    if (this.isInitialized === false) {
+      console.warn(
+          'Generator init was not called before blockToCode was called.');
     }
-    return [this.scrub_(block, code[0], opt_thisOnly), code[1]];
-  } else if (typeof code === 'string') {
-    if (this.STATEMENT_PREFIX && !block.suppressPrefixSuffix) {
-      code = this.injectId(this.STATEMENT_PREFIX, block) + code;
+    if (!block) {
+      return '';
     }
-    if (this.STATEMENT_SUFFIX && !block.suppressPrefixSuffix) {
-      code = code + this.injectId(this.STATEMENT_SUFFIX, block);
+    if (!block.isEnabled()) {
+      // Skip past this block if it is disabled.
+      return opt_thisOnly ? '' : this.blockToCode(block.getNextBlock());
+    }
+    if (block.isInsertionMarker()) {
+      // Skip past insertion markers.
+      return opt_thisOnly ? '' : this.blockToCode(block.getChildren(false)[0]);
     }
-    return this.scrub_(block, code, opt_thisOnly);
-  } else if (code === null) {
-    // Block has handled code generation itself.
-    return '';
-  }
-  throw SyntaxError('Invalid code generated: ' + code);
-};
 
-/**
- * Generate code representing the specified value input.
- * @param {!Block} block The block containing the input.
- * @param {string} name The name of the input.
- * @param {number} outerOrder The maximum binding strength (minimum order value)
- *     of any operators adjacent to "block".
- * @return {string} Generated code or '' if no blocks are connected or the
- *     specified input does not exist.
- */
-Generator.prototype.valueToCode = function(block, name, outerOrder) {
-  if (isNaN(outerOrder)) {
-    throw TypeError('Expecting valid order from block: ' + block.type);
-  }
-  const targetBlock = block.getInputTargetBlock(name);
-  if (!targetBlock) {
-    return '';
-  }
-  const tuple = this.blockToCode(targetBlock);
-  if (tuple === '') {
-    // Disabled block.
-    return '';
-  }
-  // Value blocks must return code and order of operations info.
-  // Statement blocks must only return code.
-  if (!Array.isArray(tuple)) {
-    throw TypeError('Expecting tuple from value block: ' + targetBlock.type);
-  }
-  let code = tuple[0];
-  const innerOrder = tuple[1];
-  if (isNaN(innerOrder)) {
-    throw TypeError(
-        'Expecting valid order from value block: ' + targetBlock.type);
-  }
-  if (!code) {
-    return '';
+    const func = this[block.type];
+    if (typeof func !== 'function') {
+      throw Error(
+          'Language "' + this.name_ + '" does not know how to generate ' +
+          'code for block type "' + block.type + '".');
+    }
+    // First argument to func.call is the value of 'this' in the generator.
+    // Prior to 24 September 2013 'this' was the only way to access the block.
+    // The current preferred method of accessing the block is through the second
+    // argument to func.call, which becomes the first parameter to the
+    // generator.
+    let code = func.call(block, block);
+    if (Array.isArray(code)) {
+      // Value blocks return tuples of code and operator order.
+      if (!block.outputConnection) {
+        throw TypeError('Expecting string from statement block: ' + block.type);
+      }
+      return [this.scrub_(block, code[0], opt_thisOnly), code[1]];
+    } else if (typeof code === 'string') {
+      if (this.STATEMENT_PREFIX && !block.suppressPrefixSuffix) {
+        code = this.injectId(this.STATEMENT_PREFIX, block) + code;
+      }
+      if (this.STATEMENT_SUFFIX && !block.suppressPrefixSuffix) {
+        code = code + this.injectId(this.STATEMENT_SUFFIX, block);
+      }
+      return this.scrub_(block, code, opt_thisOnly);
+    } else if (code === null) {
+      // Block has handled code generation itself.
+      return '';
+    }
+    throw SyntaxError('Invalid code generated: ' + code);
   }
 
-  // Add parentheses if needed.
-  let parensNeeded = false;
-  const outerOrderClass = Math.floor(outerOrder);
-  const innerOrderClass = Math.floor(innerOrder);
-  if (outerOrderClass <= innerOrderClass) {
-    if (outerOrderClass === innerOrderClass &&
-        (outerOrderClass === 0 || outerOrderClass === 99)) {
-      // Don't generate parens around NONE-NONE and ATOMIC-ATOMIC pairs.
-      // 0 is the atomic order, 99 is the none order.  No parentheses needed.
-      // In all known languages multiple such code blocks are not order
-      // sensitive.  In fact in Python ('a' 'b') 'c' would fail.
-    } else {
-      // The operators outside this code are stronger than the operators
-      // inside this code.  To prevent the code from being pulled apart,
-      // wrap the code in parentheses.
-      parensNeeded = true;
-      // Check for special exceptions.
-      for (let i = 0; i < this.ORDER_OVERRIDES.length; i++) {
-        if (this.ORDER_OVERRIDES[i][0] === outerOrder &&
-            this.ORDER_OVERRIDES[i][1] === innerOrder) {
-          parensNeeded = false;
-          break;
+  /**
+   * Generate code representing the specified value input.
+   * @param {!Block} block The block containing the input.
+   * @param {string} name The name of the input.
+   * @param {number} outerOrder The maximum binding strength (minimum order
+   *     value) of any operators adjacent to "block".
+   * @return {string} Generated code or '' if no blocks are connected or the
+   *     specified input does not exist.
+   */
+  valueToCode(block, name, outerOrder) {
+    if (isNaN(outerOrder)) {
+      throw TypeError('Expecting valid order from block: ' + block.type);
+    }
+    const targetBlock = block.getInputTargetBlock(name);
+    if (!targetBlock) {
+      return '';
+    }
+    const tuple = this.blockToCode(targetBlock);
+    if (tuple === '') {
+      // Disabled block.
+      return '';
+    }
+    // Value blocks must return code and order of operations info.
+    // Statement blocks must only return code.
+    if (!Array.isArray(tuple)) {
+      throw TypeError('Expecting tuple from value block: ' + targetBlock.type);
+    }
+    let code = tuple[0];
+    const innerOrder = tuple[1];
+    if (isNaN(innerOrder)) {
+      throw TypeError(
+          'Expecting valid order from value block: ' + targetBlock.type);
+    }
+    if (!code) {
+      return '';
+    }
+
+    // Add parentheses if needed.
+    let parensNeeded = false;
+    const outerOrderClass = Math.floor(outerOrder);
+    const innerOrderClass = Math.floor(innerOrder);
+    if (outerOrderClass <= innerOrderClass) {
+      if (outerOrderClass === innerOrderClass &&
+          (outerOrderClass === 0 || outerOrderClass === 99)) {
+        // Don't generate parens around NONE-NONE and ATOMIC-ATOMIC pairs.
+        // 0 is the atomic order, 99 is the none order.  No parentheses needed.
+        // In all known languages multiple such code blocks are not order
+        // sensitive.  In fact in Python ('a' 'b') 'c' would fail.
+      } else {
+        // The operators outside this code are stronger than the operators
+        // inside this code.  To prevent the code from being pulled apart,
+        // wrap the code in parentheses.
+        parensNeeded = true;
+        // Check for special exceptions.
+        for (let i = 0; i < this.ORDER_OVERRIDES.length; i++) {
+          if (this.ORDER_OVERRIDES[i][0] === outerOrder &&
+              this.ORDER_OVERRIDES[i][1] === innerOrder) {
+            parensNeeded = false;
+            break;
+          }
         }
       }
     }
+    if (parensNeeded) {
+      // Technically, this should be handled on a language-by-language basis.
+      // However all known (sane) languages use parentheses for grouping.
+      code = '(' + code + ')';
+    }
+    return code;
   }
-  if (parensNeeded) {
-    // Technically, this should be handled on a language-by-language basis.
-    // However all known (sane) languages use parentheses for grouping.
-    code = '(' + code + ')';
-  }
-  return code;
-};
 
-/**
- * Generate a code string representing the blocks attached to the named
- * statement input. Indent the code.
- * This is mainly used in generators. When trying to generate code to evaluate
- * look at using workspaceToCode or blockToCode.
- * @param {!Block} block The block containing the input.
- * @param {string} name The name of the input.
- * @return {string} Generated code or '' if no blocks are connected.
- */
-Generator.prototype.statementToCode = function(block, name) {
-  const targetBlock = block.getInputTargetBlock(name);
-  let code = this.blockToCode(targetBlock);
-  // Value blocks must return code and order of operations info.
-  // Statement blocks must only return code.
-  if (typeof code !== 'string') {
-    throw TypeError(
-        'Expecting code from statement block: ' +
-        (targetBlock && targetBlock.type));
-  }
-  if (code) {
-    code = this.prefixLines(/** @type {string} */ (code), this.INDENT);
+  /**
+   * Generate a code string representing the blocks attached to the named
+   * statement input. Indent the code.
+   * This is mainly used in generators. When trying to generate code to evaluate
+   * look at using workspaceToCode or blockToCode.
+   * @param {!Block} block The block containing the input.
+   * @param {string} name The name of the input.
+   * @return {string} Generated code or '' if no blocks are connected.
+   */
+  statementToCode(block, name) {
+    const targetBlock = block.getInputTargetBlock(name);
+    let code = this.blockToCode(targetBlock);
+    // Value blocks must return code and order of operations info.
+    // Statement blocks must only return code.
+    if (typeof code !== 'string') {
+      throw TypeError(
+          'Expecting code from statement block: ' +
+          (targetBlock && targetBlock.type));
+    }
+    if (code) {
+      code = this.prefixLines(/** @type {string} */ (code), this.INDENT);
+    }
+    return code;
   }
-  return code;
-};
 
-/**
- * Add an infinite loop trap to the contents of a loop.
- * Add statement suffix at the start of the loop block (right after the loop
- * statement executes), and a statement prefix to the end of the loop block
- * (right before the loop statement executes).
- * @param {string} branch Code for loop contents.
- * @param {!Block} block Enclosing block.
- * @return {string} Loop contents, with infinite loop trap added.
- */
-Generator.prototype.addLoopTrap = function(branch, block) {
-  if (this.INFINITE_LOOP_TRAP) {
-    branch = this.prefixLines(
-                 this.injectId(this.INFINITE_LOOP_TRAP, block), this.INDENT) +
-        branch;
-  }
-  if (this.STATEMENT_SUFFIX && !block.suppressPrefixSuffix) {
-    branch = this.prefixLines(
-                 this.injectId(this.STATEMENT_SUFFIX, block), this.INDENT) +
-        branch;
-  }
-  if (this.STATEMENT_PREFIX && !block.suppressPrefixSuffix) {
-    branch = branch +
-        this.prefixLines(
-            this.injectId(this.STATEMENT_PREFIX, block), this.INDENT);
+  /**
+   * Add an infinite loop trap to the contents of a loop.
+   * Add statement suffix at the start of the loop block (right after the loop
+   * statement executes), and a statement prefix to the end of the loop block
+   * (right before the loop statement executes).
+   * @param {string} branch Code for loop contents.
+   * @param {!Block} block Enclosing block.
+   * @return {string} Loop contents, with infinite loop trap added.
+   */
+  addLoopTrap(branch, block) {
+    if (this.INFINITE_LOOP_TRAP) {
+      branch = this.prefixLines(
+                   this.injectId(this.INFINITE_LOOP_TRAP, block), this.INDENT) +
+          branch;
+    }
+    if (this.STATEMENT_SUFFIX && !block.suppressPrefixSuffix) {
+      branch = this.prefixLines(
+                   this.injectId(this.STATEMENT_SUFFIX, block), this.INDENT) +
+          branch;
+    }
+    if (this.STATEMENT_PREFIX && !block.suppressPrefixSuffix) {
+      branch = branch +
+          this.prefixLines(
+              this.injectId(this.STATEMENT_PREFIX, block), this.INDENT);
+    }
+    return branch;
   }
-  return branch;
-};
 
-/**
- * Inject a block ID into a message to replace '%1'.
- * Used for STATEMENT_PREFIX, STATEMENT_SUFFIX, and INFINITE_LOOP_TRAP.
- * @param {string} msg Code snippet with '%1'.
- * @param {!Block} block Block which has an ID.
- * @return {string} Code snippet with ID.
- */
-Generator.prototype.injectId = function(msg, block) {
-  const id = block.id.replace(/\$/g, '$$$$');  // Issue 251.
-  return msg.replace(/%1/g, '\'' + id + '\'');
-};
+  /**
+   * Inject a block ID into a message to replace '%1'.
+   * Used for STATEMENT_PREFIX, STATEMENT_SUFFIX, and INFINITE_LOOP_TRAP.
+   * @param {string} msg Code snippet with '%1'.
+   * @param {!Block} block Block which has an ID.
+   * @return {string} Code snippet with ID.
+   */
+  injectId(msg, block) {
+    const id = block.id.replace(/\$/g, '$$$$');  // Issue 251.
+    return msg.replace(/%1/g, '\'' + id + '\'');
+  }
 
-/**
- * Comma-separated list of reserved words.
- * @type {string}
- * @protected
- */
-Generator.prototype.RESERVED_WORDS_ = '';
+  /**
+   * Add one or more words to the list of reserved words for this language.
+   * @param {string} words Comma-separated list of words to add to the list.
+   *     No spaces.  Duplicates are ok.
+   */
+  addReservedWords(words) {
+    this.RESERVED_WORDS_ += words + ',';
+  }
 
-/**
- * Add one or more words to the list of reserved words for this language.
- * @param {string} words Comma-separated list of words to add to the list.
- *     No spaces.  Duplicates are ok.
- */
-Generator.prototype.addReservedWords = function(words) {
-  this.RESERVED_WORDS_ += words + ',';
-};
+  /**
+   * Define a developer-defined function (not a user-defined procedure) to be
+   * included in the generated code.  Used for creating private helper
+   * functions. The first time this is called with a given desiredName, the code
+   * is saved and an actual name is generated.  Subsequent calls with the same
+   * desiredName have no effect but have the same return value.
+   *
+   * It is up to the caller to make sure the same desiredName is not
+   * used for different helper functions (e.g. use "colourRandom" and
+   * "listRandom", not "random").  There is no danger of colliding with reserved
+   * words, or user-defined variable or procedure names.
+   *
+   * The code gets output when Generator.finish() is called.
+   *
+   * @param {string} desiredName The desired name of the function
+   *     (e.g. mathIsPrime).
+   * @param {!Array<string>|string} code A list of statements or one multi-line
+   *     code string.  Use '  ' for indents (they will be replaced).
+   * @return {string} The actual name of the new function.  This may differ
+   *     from desiredName if the former has already been taken by the user.
+   * @protected
+   */
+  provideFunction_(desiredName, code) {
+    if (!this.definitions_[desiredName]) {
+      const functionName =
+          this.nameDB_.getDistinctName(desiredName, NameType.PROCEDURE);
+      this.functionNames_[desiredName] = functionName;
+      if (Array.isArray(code)) {
+        code = code.join('\n');
+      }
+      let codeText = code.trim().replace(
+          this.FUNCTION_NAME_PLACEHOLDER_REGEXP_, functionName);
+      // Change all '  ' indents into the desired indent.
+      // To avoid an infinite loop of replacements, change all indents to '\0'
+      // character first, then replace them all with the indent.
+      // We are assuming that no provided functions contain a literal null char.
+      let oldCodeText;
+      while (oldCodeText !== codeText) {
+        oldCodeText = codeText;
+        codeText = codeText.replace(/^(( {2})*) {2}/gm, '$1\0');
+      }
+      codeText = codeText.replace(/\0/g, this.INDENT);
+      this.definitions_[desiredName] = codeText;
+    }
+    return this.functionNames_[desiredName];
+  }
 
-/**
- * This is used as a placeholder in functions defined using
- * Generator.provideFunction_.  It must not be legal code that could
- * legitimately appear in a function definition (or comment), and it must
- * not confuse the regular expression parser.
- * @type {string}
- * @protected
- */
-Generator.prototype.FUNCTION_NAME_PLACEHOLDER_ = '{leCUI8hutHZI4480Dc}';
+  /**
+   * Hook for code to run before code generation starts.
+   * Subclasses may override this, e.g. to initialise the database of variable
+   * names.
+   * @param {!Workspace} _workspace Workspace to generate code from.
+   */
+  init(_workspace) {
+    // Optionally override
+    // Create a dictionary of definitions to be printed before the code.
+    this.definitions_ = Object.create(null);
+    // Create a dictionary mapping desired developer-defined function names in
+    // definitions_ to actual function names (to avoid collisions with
+    // user-defined procedures).
+    this.functionNames_ = Object.create(null);
+  }
 
-/**
- * A dictionary of definitions to be printed before the code.
- * @type {!Object|undefined}
- * @protected
- */
-Generator.prototype.definitions_;
+  /**
+   * Common tasks for generating code from blocks.  This is called from
+   * blockToCode and is called on every block, not just top level blocks.
+   * Subclasses may override this, e.g. to generate code for statements
+   * following the block, or to handle comments for the specified block and any
+   * connected value blocks.
+   * @param {!Block} _block The current block.
+   * @param {string} code The code created for this block.
+   * @param {boolean=} _opt_thisOnly True to generate code for only this
+   *     statement.
+   * @return {string} Code with comments and subsequent blocks added.
+   * @protected
+   */
+  scrub_(_block, code, _opt_thisOnly) {
+    // Optionally override
+    return code;
+  }
 
-/**
- * A dictionary mapping desired function names in definitions_ to actual
- * function names (to avoid collisions with user functions).
- * @type {!Object|undefined}
- * @protected
- */
-Generator.prototype.functionNames_;
+  /**
+   * Hook for code to run at end of code generation.
+   * Subclasses may override this, e.g. to prepend the generated code with
+   * import statements or variable definitions.
+   * @param {string} code Generated code.
+   * @return {string} Completed code.
+   */
+  finish(code) {
+    // Optionally override
+    // Clean up temporary data.
+    delete this.definitions_;
+    delete this.functionNames_;
+    return code;
+  }
 
-/**
- * A database of variable and procedure names.
- * @type {!Names|undefined}
- * @protected
- */
-Generator.prototype.nameDB_;
+  /**
+   * Naked values are top-level blocks with outputs that aren't plugged into
+   * anything.
+   * Subclasses may override this, e.g. if their language does not allow
+   * naked values.
+   * @param {string} line Line of generated code.
+   * @return {string} Legal line of code.
+   */
+  scrubNakedValue(line) {
+    // Optionally override
+    return line;
+  }
+}
 
 Object.defineProperties(Generator.prototype, {
   /**
@@ -443,109 +561,4 @@ Object.defineProperties(Generator.prototype, {
   },
 });
 
-/**
- * Define a developer-defined function (not a user-defined procedure) to be
- * included in the generated code.  Used for creating private helper functions.
- * The first time this is called with a given desiredName, the code is
- * saved and an actual name is generated.  Subsequent calls with the
- * same desiredName have no effect but have the same return value.
- *
- * It is up to the caller to make sure the same desiredName is not
- * used for different helper functions (e.g. use "colourRandom" and
- * "listRandom", not "random").  There is no danger of colliding with reserved
- * words, or user-defined variable or procedure names.
- *
- * The code gets output when Generator.finish() is called.
- *
- * @param {string} desiredName The desired name of the function
- *     (e.g. mathIsPrime).
- * @param {!Array<string>} code A list of statements.  Use '  ' for indents.
- * @return {string} The actual name of the new function.  This may differ
- *     from desiredName if the former has already been taken by the user.
- * @protected
- */
-Generator.prototype.provideFunction_ = function(desiredName, code) {
-  if (!this.definitions_[desiredName]) {
-    const functionName =
-        this.nameDB_.getDistinctName(desiredName, NameType.PROCEDURE);
-    this.functionNames_[desiredName] = functionName;
-    let codeText = code.join('\n').replace(
-        this.FUNCTION_NAME_PLACEHOLDER_REGEXP_, functionName);
-    // Change all '  ' indents into the desired indent.
-    // To avoid an infinite loop of replacements, change all indents to '\0'
-    // character first, then replace them all with the indent.
-    // We are assuming that no provided functions contain a literal null char.
-    let oldCodeText;
-    while (oldCodeText !== codeText) {
-      oldCodeText = codeText;
-      codeText = codeText.replace(/^(( {2})*) {2}/gm, '$1\0');
-    }
-    codeText = codeText.replace(/\0/g, this.INDENT);
-    this.definitions_[desiredName] = codeText;
-  }
-  return this.functionNames_[desiredName];
-};
-
-/**
- * Hook for code to run before code generation starts.
- * Subclasses may override this, e.g. to initialise the database of variable
- * names.
- * @param {!Workspace} _workspace Workspace to generate code from.
- */
-Generator.prototype.init = function(_workspace) {
-  // Optionally override
-  // Create a dictionary of definitions to be printed before the code.
-  this.definitions_ = Object.create(null);
-  // Create a dictionary mapping desired developer-defined function names in
-  // definitions_ to actual function names (to avoid collisions with
-  // user-defined procedures).
-  this.functionNames_ = Object.create(null);
-};
-
-/**
- * Common tasks for generating code from blocks.  This is called from
- * blockToCode and is called on every block, not just top level blocks.
- * Subclasses may override this, e.g. to generate code for statements following
- * the block, or to handle comments for the specified block and any connected
- * value blocks.
- * @param {!Block} _block The current block.
- * @param {string} code The code created for this block.
- * @param {boolean=} _opt_thisOnly True to generate code for only this
- *     statement.
- * @return {string} Code with comments and subsequent blocks added.
- * @protected
- */
-Generator.prototype.scrub_ = function(_block, code, _opt_thisOnly) {
-  // Optionally override
-  return code;
-};
-
-/**
- * Hook for code to run at end of code generation.
- * Subclasses may override this, e.g. to prepend the generated code with import
- * statements or variable definitions.
- * @param {string} code Generated code.
- * @return {string} Completed code.
- */
-Generator.prototype.finish = function(code) {
-  // Optionally override
-  // Clean up temporary data.
-  delete this.definitions_;
-  delete this.functionNames_;
-  return code;
-};
-
-/**
- * Naked values are top-level blocks with outputs that aren't plugged into
- * anything.
- * Subclasses may override this, e.g. if their language does not allow
- * naked values.
- * @param {string} line Line of generated code.
- * @return {string} Legal line of code.
- */
-Generator.prototype.scrubNakedValue = function(line) {
-  // Optionally override
-  return line;
-};
-
 exports.Generator = Generator;