blockly 7.20211209.4 → 8.0.0

package/core/block.js

@@ -15,8 +15,6 @@
  */
 goog.module('Blockly.Block');
 
-/* eslint-disable-next-line no-unused-vars */
-const Abstract = goog.requireType('Blockly.Events.Abstract');
 const Extensions = goog.require('Blockly.Extensions');
 const Tooltip = goog.require('Blockly.Tooltip');
 const arrayUtils = goog.require('Blockly.utils.array');
@@ -27,8 +25,12 @@ const fieldRegistry = goog.require('Blockly.fieldRegistry');
 const idGenerator = goog.require('Blockly.utils.idGenerator');
 const object = goog.require('Blockly.utils.object');
 const parsing = goog.require('Blockly.utils.parsing');
+/* eslint-disable-next-line no-unused-vars */
+const {Abstract} = goog.requireType('Blockly.Events.Abstract');
 const {Align, Input} = goog.require('Blockly.Input');
 const {ASTNode} = goog.require('Blockly.ASTNode');
+/* eslint-disable-next-line no-unused-vars */
+const {BlockMove} = goog.requireType('Blockly.Events.BlockMove');
 const {Blocks} = goog.require('Blockly.blocks');
 /* eslint-disable-next-line no-unused-vars */
 const {Comment} = goog.requireType('Blockly.Comment');
@@ -62,2095 +64,2148 @@ goog.require('Blockly.Events.BlockMove');
 /**
  * Class for one block.
  * Not normally called directly, workspace.newBlock() is preferred.
- * @param {!Workspace} workspace The block's workspace.
- * @param {!string} prototypeName Name of the language object containing
- *     type-specific functions for this block.
- * @param {string=} opt_id Optional ID.  Use this ID if provided, otherwise
- *     create a new ID.
- * @constructor
  * @implements {IASTNodeLocation}
  * @implements {IDeletable}
- * @throws When the prototypeName is not valid or not allowed.
+ * @unrestricted
  * @alias Blockly.Block
  */
-const Block = function(workspace, prototypeName, opt_id) {
-  const {Generator} = goog.module.get('Blockly.Generator');
-  if (Generator && typeof Generator.prototype[prototypeName] !== 'undefined') {
-    // Occluding Generator class members is not allowed.
-    throw Error(
-        'Block prototypeName "' + prototypeName +
-        '" conflicts with Blockly.Generator members.');
-  }
-
-  /** @type {string} */
-  this.id = (opt_id && !workspace.getBlockById(opt_id)) ? opt_id :
-                                                          idGenerator.genUid();
-  workspace.setBlockById(this.id, this);
-  /** @type {Connection} */
-  this.outputConnection = null;
-  /** @type {Connection} */
-  this.nextConnection = null;
-  /** @type {Connection} */
-  this.previousConnection = null;
-  /** @type {!Array<!Input>} */
-  this.inputList = [];
-  /** @type {boolean|undefined} */
-  this.inputsInline = undefined;
-  /**
-   * @type {boolean}
-   * @private
+class Block {
+  /**
+   * @param {!Workspace} workspace The block's workspace.
+   * @param {!string} prototypeName Name of the language object containing
+   *     type-specific functions for this block.
+   * @param {string=} opt_id Optional ID.  Use this ID if provided, otherwise
+   *     create a new ID.
+   * @throws When the prototypeName is not valid or not allowed.
    */
-  this.disabled = false;
-  /** @type {!Tooltip.TipInfo} */
-  this.tooltip = '';
-  /** @type {boolean} */
-  this.contextMenu = true;
+  constructor(workspace, prototypeName, opt_id) {
+    const {Generator} = goog.module.get('Blockly.Generator');
+    if (Generator &&
+        typeof Generator.prototype[prototypeName] !== 'undefined') {
+      // Occluding Generator class members is not allowed.
+      throw Error(
+          'Block prototypeName "' + prototypeName +
+          '" conflicts with Blockly.Generator members.');
+    }
+
+    /**
+     * Optional text data that round-trips between blocks and XML.
+     * Has no effect. May be used by 3rd parties for meta information.
+     * @type {?string}
+     */
+    this.data = null;
+
+    /**
+     * Has this block been disposed of?
+     * @type {boolean}
+     * @package
+     */
+    this.disposed = false;
+
+    /**
+     * Colour of the block as HSV hue value (0-360)
+     * This may be null if the block colour was not set via a hue number.
+     * @type {?number}
+     * @private
+     */
+    this.hue_ = null;
+
+    /**
+     * Colour of the block in '#RRGGBB' format.
+     * @type {string}
+     * @protected
+     */
+    this.colour_ = '#000000';
+
+    /**
+     * Name of the block style.
+     * @type {string}
+     * @protected
+     */
+    this.styleName_ = '';
+
+    /**
+     * An optional method called during initialization.
+     * @type {undefined|?function()}
+     */
+    this.init = undefined;
+
+    /**
+     * An optional serialization method for defining how to serialize the
+     * mutation state to XML. This must be coupled with defining
+     * `domToMutation`.
+     * @type {undefined|?function(...):!Element}
+     */
+    this.mutationToDom = undefined;
+
+    /**
+     * An optional deserialization method for defining how to deserialize the
+     * mutation state from XML. This must be coupled with defining
+     * `mutationToDom`.
+     * @type {undefined|?function(!Element)}
+     */
+    this.domToMutation = undefined;
+
+    /**
+     * An optional serialization method for defining how to serialize the
+     * block's extra state (eg mutation state) to something JSON compatible.
+     * This must be coupled with defining `loadExtraState`.
+     * @type {undefined|?function(): *}
+     */
+    this.saveExtraState = undefined;
+
+    /**
+     * An optional serialization method for defining how to deserialize the
+     * block's extra state (eg mutation state) from something JSON compatible.
+     * This must be coupled with defining `saveExtraState`.
+     * @type {undefined|?function(*)}
+     */
+    this.loadExtraState = undefined;
+
+
+    /**
+     * An optional property for suppressing adding STATEMENT_PREFIX and
+     * STATEMENT_SUFFIX to generated code.
+     * @type {?boolean}
+     */
+    this.suppressPrefixSuffix = false;
+
+    /**
+     * An optional property for declaring developer variables.  Return a list of
+     * variable names for use by generators.  Developer variables are never
+     * shown to the user, but are declared as global variables in the generated
+     * code.
+     * @type {undefined|?function():!Array<string>}
+     */
+    this.getDeveloperVariables = undefined;
+
+    /** @type {string} */
+    this.id = (opt_id && !workspace.getBlockById(opt_id)) ?
+        opt_id :
+        idGenerator.genUid();
+    workspace.setBlockById(this.id, this);
+    /** @type {Connection} */
+    this.outputConnection = null;
+    /** @type {Connection} */
+    this.nextConnection = null;
+    /** @type {Connection} */
+    this.previousConnection = null;
+    /** @type {!Array<!Input>} */
+    this.inputList = [];
+    /** @type {boolean|undefined} */
+    this.inputsInline = undefined;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    this.disabled = false;
+    /** @type {!Tooltip.TipInfo} */
+    this.tooltip = '';
+    /** @type {boolean} */
+    this.contextMenu = true;
+
+    /**
+     * @type {Block}
+     * @protected
+     */
+    this.parentBlock_ = null;
+
+    /**
+     * @type {!Array<!Block>}
+     * @protected
+     */
+    this.childBlocks_ = [];
+
+    /**
+     * @type {boolean}
+     * @private
+     */
+    this.deletable_ = true;
+
+    /**
+     * @type {boolean}
+     * @private
+     */
+    this.movable_ = true;
+
+    /**
+     * @type {boolean}
+     * @private
+     */
+    this.editable_ = true;
+
+    /**
+     * @type {boolean}
+     * @private
+     */
+    this.isShadow_ = false;
+
+    /**
+     * @type {boolean}
+     * @protected
+     */
+    this.collapsed_ = false;
+
+    /**
+     * @type {?number}
+     * @protected
+     */
+    this.outputShape_ = null;
+
+    /**
+     * A string representing the comment attached to this block.
+     * @type {string|Comment}
+     * @deprecated August 2019. Use getCommentText instead.
+     */
+    this.comment = null;
+
+    /**
+     * A model of the comment attached to this block.
+     * @type {!Block.CommentModel}
+     * @package
+     */
+    this.commentModel = {text: null, pinned: false, size: new Size(160, 80)};
+
+    /**
+     * The block's position in workspace units.  (0, 0) is at the workspace's
+     * origin; scale does not change this value.
+     * @type {!Coordinate}
+     * @private
+     */
+    this.xy_ = new Coordinate(0, 0);
+
+    /** @type {!Workspace} */
+    this.workspace = workspace;
+    /** @type {boolean} */
+    this.isInFlyout = workspace.isFlyout;
+    /** @type {boolean} */
+    this.isInMutator = workspace.isMutator;
+
+    /** @type {boolean} */
+    this.RTL = workspace.RTL;
+
+    /**
+     * True if this block is an insertion marker.
+     * @type {boolean}
+     * @protected
+     */
+    this.isInsertionMarker_ = false;
+
+    /**
+     * Name of the type of hat.
+     * @type {string|undefined}
+     */
+    this.hat = undefined;
+
+    /** @type {?boolean} */
+    this.rendered = null;
+
+    /**
+     * String for block help, or function that returns a URL. Null for no help.
+     * @type {string|Function}
+     */
+    this.helpUrl = null;
+
+    /**
+     * A bound callback function to use when the parent workspace changes.
+     * @type {?function(Abstract)}
+     * @private
+     */
+    this.onchangeWrapper_ = null;
+
+    /**
+     * A count of statement inputs on the block.
+     * @type {number}
+     * @package
+     */
+    this.statementInputCount = 0;
+
+    // Copy the type-specific functions and data from the prototype.
+    if (prototypeName) {
+      /** @type {string} */
+      this.type = prototypeName;
+      const prototype = Blocks[prototypeName];
+      if (!prototype || typeof prototype !== 'object') {
+        throw TypeError('Invalid block definition for type: ' + prototypeName);
+      }
+      object.mixin(this, prototype);
+    }
+
+    workspace.addTopBlock(this);
+    workspace.addTypedBlock(this);
+
+    if (new.target === Block) this.doInit_();
+  }
 
   /**
-   * @type {Block}
+   * Calls the init() function and handles associated event firing, etc.
    * @protected
    */
-  this.parentBlock_ = null;
+  doInit_() {
+    // All events fired should be part of the same group.
+    // Any events fired during init should not be undoable,
+    // so that block creation is atomic.
+    const existingGroup = eventUtils.getGroup();
+    if (!existingGroup) {
+      eventUtils.setGroup(true);
+    }
+    const initialUndoFlag = eventUtils.getRecordUndo();
+
+    try {
+      // Call an initialization function, if it exists.
+      if (typeof this.init === 'function') {
+        eventUtils.setRecordUndo(false);
+        this.init();
+        eventUtils.setRecordUndo(initialUndoFlag);
+      }
+
+      // Fire a create event.
+      if (eventUtils.isEnabled()) {
+        eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CREATE))(this));
+      }
+    } finally {
+      if (!existingGroup) {
+        eventUtils.setGroup(false);
+      }
+      // In case init threw, recordUndo flag should still be reset.
+      eventUtils.setRecordUndo(initialUndoFlag);
+    }
+
+    // Record initial inline state.
+    /** @type {boolean|undefined} */
+    this.inputsInlineDefault = this.inputsInline;
+
+    // Bind an onchange function, if it exists.
+    if (typeof this.onchange === 'function') {
+      this.setOnChange(this.onchange);
+    }
+  }
 
   /**
-   * @type {!Array<!Block>}
-   * @protected
+   * Dispose of this block.
+   * @param {boolean} healStack If true, then try to heal any gap by connecting
+   *     the next statement with the previous statement.  Otherwise, dispose of
+   *     all children of this block.
+   * @suppress {checkTypes}
    */
-  this.childBlocks_ = [];
+  dispose(healStack) {
+    if (!this.workspace) {
+      // Already deleted.
+      return;
+    }
+    // Terminate onchange event calls.
+    if (this.onchangeWrapper_) {
+      this.workspace.removeChangeListener(this.onchangeWrapper_);
+    }
+
+    this.unplug(healStack);
+    if (eventUtils.isEnabled()) {
+      eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_DELETE))(this));
+    }
+    eventUtils.disable();
+
+    try {
+      // This block is now at the top of the workspace.
+      // Remove this block from the workspace's list of top-most blocks.
+      if (this.workspace) {
+        this.workspace.removeTopBlock(this);
+        this.workspace.removeTypedBlock(this);
+        // Remove from block database.
+        this.workspace.removeBlockById(this.id);
+        this.workspace = null;
+      }
+
+      // Just deleting this block from the DOM would result in a memory leak as
+      // well as corruption of the connection database.  Therefore we must
+      // methodically step through the blocks and carefully disassemble them.
+
+      if (common.getSelected() === this) {
+        common.setSelected(null);
+      }
+
+      // First, dispose of all my children.
+      for (let i = this.childBlocks_.length - 1; i >= 0; i--) {
+        this.childBlocks_[i].dispose(false);
+      }
+      // Then dispose of myself.
+      // Dispose of all inputs and their fields.
+      for (let i = 0, input; (input = this.inputList[i]); i++) {
+        input.dispose();
+      }
+      this.inputList.length = 0;
+      // Dispose of any remaining connections (next/previous/output).
+      const connections = this.getConnections_(true);
+      for (let i = 0, connection; (connection = connections[i]); i++) {
+        connection.dispose();
+      }
+    } finally {
+      eventUtils.enable();
+      this.disposed = true;
+    }
+  }
 
   /**
-   * @type {boolean}
-   * @private
+   * Call initModel on all fields on the block.
+   * May be called more than once.
+   * Either initModel or initSvg must be called after creating a block and
+   * before the first interaction with it.  Interactions include UI actions
+   * (e.g. clicking and dragging) and firing events (e.g. create, delete, and
+   * change).
+   * @public
    */
-  this.deletable_ = true;
+  initModel() {
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      for (let j = 0, field; (field = input.fieldRow[j]); j++) {
+        if (field.initModel) {
+          field.initModel();
+        }
+      }
+    }
+  }
 
   /**
-   * @type {boolean}
-   * @private
+   * Unplug this block from its superior block.  If this block is a statement,
+   * optionally reconnect the block underneath with the block on top.
+   * @param {boolean=} opt_healStack Disconnect child statement and reconnect
+   *   stack.  Defaults to false.
    */
-  this.movable_ = true;
+  unplug(opt_healStack) {
+    if (this.outputConnection) {
+      this.unplugFromRow_(opt_healStack);
+    }
+    if (this.previousConnection) {
+      this.unplugFromStack_(opt_healStack);
+    }
+  }
 
   /**
-   * @type {boolean}
+   * Unplug this block's output from an input on another block.  Optionally
+   * reconnect the block's parent to the only child block, if possible.
+   * @param {boolean=} opt_healStack Disconnect right-side block and connect to
+   *     left-side block.  Defaults to false.
    * @private
    */
-  this.editable_ = true;
+  unplugFromRow_(opt_healStack) {
+    let parentConnection = null;
+    if (this.outputConnection.isConnected()) {
+      parentConnection = this.outputConnection.targetConnection;
+      // Disconnect from any superior block.
+      this.outputConnection.disconnect();
+    }
+
+    // Return early in obvious cases.
+    if (!parentConnection || !opt_healStack) {
+      return;
+    }
+
+    const thisConnection = this.getOnlyValueConnection_();
+    if (!thisConnection || !thisConnection.isConnected() ||
+        thisConnection.targetBlock().isShadow()) {
+      // Too many or too few possible connections on this block, or there's
+      // nothing on the other side of this connection.
+      return;
+    }
+
+    const childConnection = thisConnection.targetConnection;
+    // Disconnect the child block.
+    childConnection.disconnect();
+    // Connect child to the parent if possible, otherwise bump away.
+    if (this.workspace.connectionChecker.canConnect(
+            childConnection, parentConnection, false)) {
+      parentConnection.connect(childConnection);
+    } else {
+      childConnection.onFailedConnect(parentConnection);
+    }
+  }
 
   /**
-   * @type {boolean}
+   * Returns the connection on the value input that is connected to another
+   * block. When an insertion marker is connected to a connection with a block
+   * already attached, the connected block is attached to the insertion marker.
+   * Since only one block can be displaced and attached to the insertion marker
+   * this should only ever return one connection.
+   *
+   * @return {?Connection} The connection on the value input, or null.
    * @private
    */
-  this.isShadow_ = false;
+  getOnlyValueConnection_() {
+    let connection = null;
+    for (let i = 0; i < this.inputList.length; i++) {
+      const thisConnection = this.inputList[i].connection;
+      if (thisConnection &&
+          thisConnection.type === ConnectionType.INPUT_VALUE &&
+          thisConnection.targetConnection) {
+        if (connection) {
+          return null;  // More than one value input found.
+        }
+        connection = thisConnection;
+      }
+    }
+    return connection;
+  }
 
   /**
-   * @type {boolean}
-   * @protected
+   * Unplug this statement block from its superior block.  Optionally reconnect
+   * the block underneath with the block on top.
+   * @param {boolean=} opt_healStack Disconnect child statement and reconnect
+   *   stack.  Defaults to false.
+   * @private
    */
-  this.collapsed_ = false;
+  unplugFromStack_(opt_healStack) {
+    let previousTarget = null;
+    if (this.previousConnection.isConnected()) {
+      // Remember the connection that any next statements need to connect to.
+      previousTarget = this.previousConnection.targetConnection;
+      // Detach this block from the parent's tree.
+      this.previousConnection.disconnect();
+    }
+    const nextBlock = this.getNextBlock();
+    if (opt_healStack && nextBlock && !nextBlock.isShadow()) {
+      // Disconnect the next statement.
+      const nextTarget = this.nextConnection.targetConnection;
+      nextTarget.disconnect();
+      if (previousTarget &&
+          this.workspace.connectionChecker.canConnect(
+              previousTarget, nextTarget, false)) {
+        // Attach the next statement to the previous statement.
+        previousTarget.connect(nextTarget);
+      }
+    }
+  }
 
   /**
-   * @type {?number}
-   * @protected
+   * Returns all connections originating from this block.
+   * @param {boolean} _all If true, return all connections even hidden ones.
+   * @return {!Array<!Connection>} Array of connections.
+   * @package
    */
-  this.outputShape_ = null;
+  getConnections_(_all) {
+    const myConnections = [];
+    if (this.outputConnection) {
+      myConnections.push(this.outputConnection);
+    }
+    if (this.previousConnection) {
+      myConnections.push(this.previousConnection);
+    }
+    if (this.nextConnection) {
+      myConnections.push(this.nextConnection);
+    }
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      if (input.connection) {
+        myConnections.push(input.connection);
+      }
+    }
+    return myConnections;
+  }
 
   /**
-   * A string representing the comment attached to this block.
-   * @type {string|Comment}
-   * @deprecated August 2019. Use getCommentText instead.
+   * Walks down a stack of blocks and finds the last next connection on the
+   * stack.
+   * @param {boolean} ignoreShadows If true,the last connection on a non-shadow
+   *     block will be returned. If false, this will follow shadows to find the
+   *     last connection.
+   * @return {?Connection} The last next connection on the stack, or null.
+   * @package
    */
-  this.comment = null;
+  lastConnectionInStack(ignoreShadows) {
+    let nextConnection = this.nextConnection;
+    while (nextConnection) {
+      const nextBlock = nextConnection.targetBlock();
+      if (!nextBlock || (ignoreShadows && nextBlock.isShadow())) {
+        return nextConnection;
+      }
+      nextConnection = nextBlock.nextConnection;
+    }
+    return null;
+  }
 
   /**
-   * A model of the comment attached to this block.
-   * @type {!Block.CommentModel}
-   * @package
+   * Bump unconnected blocks out of alignment.  Two blocks which aren't actually
+   * connected should not coincidentally line up on screen.
    */
-  this.commentModel = {text: null, pinned: false, size: new Size(160, 80)};
+  bumpNeighbours() {
+    // noop.
+  }
 
   /**
-   * The block's position in workspace units.  (0, 0) is at the workspace's
-   * origin; scale does not change this value.
-   * @type {!Coordinate}
-   * @private
+   * Return the parent block or null if this block is at the top level. The
+   * parent block is either the block connected to the previous connection (for
+   * a statement block) or the block connected to the output connection (for a
+   * value block).
+   * @return {?Block} The block (if any) that holds the current block.
    */
-  this.xy_ = new Coordinate(0, 0);
-
-  /** @type {!Workspace} */
-  this.workspace = workspace;
-  /** @type {boolean} */
-  this.isInFlyout = workspace.isFlyout;
-  /** @type {boolean} */
-  this.isInMutator = workspace.isMutator;
+  getParent() {
+    return this.parentBlock_;
+  }
 
-  /** @type {boolean} */
-  this.RTL = workspace.RTL;
+  /**
+   * Return the input that connects to the specified block.
+   * @param {!Block} block A block connected to an input on this block.
+   * @return {?Input} The input (if any) that connects to the specified
+   *     block.
+   */
+  getInputWithBlock(block) {
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      if (input.connection && input.connection.targetBlock() === block) {
+        return input;
+      }
+    }
+    return null;
+  }
 
   /**
-   * True if this block is an insertion marker.
-   * @type {boolean}
-   * @protected
+   * Return the parent block that surrounds the current block, or null if this
+   * block has no surrounding block.  A parent block might just be the previous
+   * statement, whereas the surrounding block is an if statement, while loop,
+   * etc.
+   * @return {?Block} The block (if any) that surrounds the current block.
    */
-  this.isInsertionMarker_ = false;
+  getSurroundParent() {
+    let block = this;
+    let prevBlock;
+    do {
+      prevBlock = block;
+      block = block.getParent();
+      if (!block) {
+        // Ran off the top.
+        return null;
+      }
+    } while (block.getNextBlock() === prevBlock);
+    // This block is an enclosing parent, not just a statement in a stack.
+    return block;
+  }
 
   /**
-   * Name of the type of hat.
-   * @type {string|undefined}
+   * Return the next statement block directly connected to this block.
+   * @return {?Block} The next statement block or null.
    */
-  this.hat = undefined;
+  getNextBlock() {
+    return this.nextConnection && this.nextConnection.targetBlock();
+  }
 
-  /** @type {?boolean} */
-  this.rendered = null;
+  /**
+   * Returns the block connected to the previous connection.
+   * @return {?Block} The previous statement block or null.
+   */
+  getPreviousBlock() {
+    return this.previousConnection && this.previousConnection.targetBlock();
+  }
 
   /**
-   * A count of statement inputs on the block.
-   * @type {number}
+   * Return the connection on the first statement input on this block, or null
+   * if there are none.
+   * @return {?Connection} The first statement connection or null.
    * @package
    */
-  this.statementInputCount = 0;
-
-  // Copy the type-specific functions and data from the prototype.
-  if (prototypeName) {
-    /** @type {string} */
-    this.type = prototypeName;
-    const prototype = Blocks[prototypeName];
-    if (!prototype || typeof prototype !== 'object') {
-      throw TypeError('Unknown block type: ' + prototypeName);
+  getFirstStatementConnection() {
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      if (input.connection &&
+          input.connection.type === ConnectionType.NEXT_STATEMENT) {
+        return input.connection;
+      }
     }
-    object.mixin(this, prototype);
+    return null;
   }
 
-  workspace.addTopBlock(this);
-  workspace.addTypedBlock(this);
+  /**
+   * Return the top-most block in this block's tree.
+   * This will return itself if this block is at the top level.
+   * @return {!Block} The root block.
+   */
+  getRootBlock() {
+    let rootBlock;
+    let block = this;
+    do {
+      rootBlock = block;
+      block = rootBlock.parentBlock_;
+    } while (block);
+    return rootBlock;
+  }
 
-  // All events fired should be part of the same group.
-  // Any events fired during init should not be undoable,
-  // so that block creation is atomic.
-  const existingGroup = eventUtils.getGroup();
-  if (!existingGroup) {
-    eventUtils.setGroup(true);
+  /**
+   * Walk up from the given block up through the stack of blocks to find
+   * the top block of the sub stack. If we are nested in a statement input only
+   * find the top-most nested block. Do not go all the way to the root block.
+   * @return {!Block} The top block in a stack.
+   * @package
+   */
+  getTopStackBlock() {
+    let block = this;
+    let previous;
+    do {
+      previous = block.getPreviousBlock();
+    } while (previous && previous.getNextBlock() === block &&
+             (block = previous));
+    return block;
   }
-  const initialUndoFlag = eventUtils.getRecordUndo();
 
-  try {
-    // Call an initialization function, if it exists.
-    if (typeof this.init === 'function') {
-      eventUtils.setRecordUndo(false);
-      this.init();
-      eventUtils.setRecordUndo(initialUndoFlag);
+  /**
+   * Find all the blocks that are directly nested inside this one.
+   * Includes value and statement inputs, as well as any following statement.
+   * Excludes any connection on an output tab or any preceding statement.
+   * Blocks are optionally sorted by position; top to bottom.
+   * @param {boolean} ordered Sort the list if true.
+   * @return {!Array<!Block>} Array of blocks.
+   */
+  getChildren(ordered) {
+    if (!ordered) {
+      return this.childBlocks_;
     }
-
-    // Fire a create event.
-    if (eventUtils.isEnabled()) {
-      eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CREATE))(this));
+    const blocks = [];
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      if (input.connection) {
+        const child = input.connection.targetBlock();
+        if (child) {
+          blocks.push(child);
+        }
+      }
     }
-  } finally {
-    if (!existingGroup) {
-      eventUtils.setGroup(false);
+    const next = this.getNextBlock();
+    if (next) {
+      blocks.push(next);
     }
-    // In case init threw, recordUndo flag should still be reset.
-    eventUtils.setRecordUndo(initialUndoFlag);
-  }
-
-  // Record initial inline state.
-  /** @type {boolean|undefined} */
-  this.inputsInlineDefault = this.inputsInline;
-
-  // Bind an onchange function, if it exists.
-  if (typeof this.onchange === 'function') {
-    this.setOnChange(this.onchange);
+    return blocks;
   }
-};
-
-/**
- * @typedef {{
- *            text:?string,
- *            pinned:boolean,
- *            size:Size
- *          }}
- */
-Block.CommentModel;
-
-/**
- * The language-neutral ID given to the collapsed input.
- * @const {string}
- */
-Block.COLLAPSED_INPUT_NAME = constants.COLLAPSED_INPUT_NAME;
-
-/**
- * The language-neutral ID given to the collapsed field.
- * @const {string}
- */
-Block.COLLAPSED_FIELD_NAME = constants.COLLAPSED_FIELD_NAME;
-
-/**
- * Optional text data that round-trips between blocks and XML.
- * Has no effect. May be used by 3rd parties for meta information.
- * @type {?string}
- */
-Block.prototype.data = null;
-
-/**
- * Has this block been disposed of?
- * @type {boolean}
- * @package
- */
-Block.prototype.disposed = false;
-
-/**
- * Colour of the block as HSV hue value (0-360)
- * This may be null if the block colour was not set via a hue number.
- * @type {?number}
- * @private
- */
-Block.prototype.hue_ = null;
-
-/**
- * Colour of the block in '#RRGGBB' format.
- * @type {string}
- * @protected
- */
-Block.prototype.colour_ = '#000000';
-
-/**
- * Name of the block style.
- * @type {string}
- * @protected
- */
-Block.prototype.styleName_ = '';
-
-/**
- * An optional method called during initialization.
- * @type {?function()}
- */
-Block.prototype.init;
-
-/**
- * An optional callback method to use whenever the block's parent workspace
- * changes. This is usually only called from the constructor, the block type
- * initializer function, or an extension initializer function.
- * @type {?function(Abstract)}
- */
-Block.prototype.onchange;
-
-/**
- * An optional serialization method for defining how to serialize the
- * mutation state to XML. This must be coupled with defining `domToMutation`.
- * @type {?function(...):!Element}
- */
-Block.prototype.mutationToDom;
-
-/**
- * An optional deserialization method for defining how to deserialize the
- * mutation state from XML. This must be coupled with defining `mutationToDom`.
- * @type {?function(!Element)}
- */
-Block.prototype.domToMutation;
-
-/**
- * An optional serialization method for defining how to serialize the block's
- * extra state (eg mutation state) to something JSON compatible. This must be
- * coupled with defining `loadExtraState`.
- * @type {?function(): *}
- */
-Block.prototype.saveExtraState;
-
-/**
- * An optional serialization method for defining how to deserialize the block's
- * extra state (eg mutation state) from something JSON compatible. This must be
- * coupled with defining `saveExtraState`.
- * @type {?function(*)}
- */
-Block.prototype.loadExtraState;
-
-/**
- * An optional property for suppressing adding STATEMENT_PREFIX and
- * STATEMENT_SUFFIX to generated code.
- * @type {?boolean}
- */
-Block.prototype.suppressPrefixSuffix;
 
-/**
- * An optional property for declaring developer variables.  Return a list of
- * variable names for use by generators.  Developer variables are never shown to
- * the user, but are declared as global variables in the generated code.
- * @type {?function():!Array<string>}
- */
-Block.prototype.getDeveloperVariables;
+  /**
+   * Set parent of this block to be a new block or null.
+   * @param {Block} newParent New parent block.
+   * @package
+   */
+  setParent(newParent) {
+    if (newParent === this.parentBlock_) {
+      return;
+    }
 
-/**
- * Dispose of this block.
- * @param {boolean} healStack If true, then try to heal any gap by connecting
- *     the next statement with the previous statement.  Otherwise, dispose of
- *     all children of this block.
- * @suppress {checkTypes}
- */
-Block.prototype.dispose = function(healStack) {
-  if (!this.workspace) {
-    // Already deleted.
-    return;
-  }
-  // Terminate onchange event calls.
-  if (this.onchangeWrapper_) {
-    this.workspace.removeChangeListener(this.onchangeWrapper_);
-  }
+    // Check that block is connected to new parent if new parent is not null and
+    //    that block is not connected to superior one if new parent is null.
+    const targetBlock =
+        (this.previousConnection && this.previousConnection.targetBlock()) ||
+        (this.outputConnection && this.outputConnection.targetBlock());
+    const isConnected = !!targetBlock;
+
+    if (isConnected && newParent && targetBlock !== newParent) {
+      throw Error('Block connected to superior one that is not new parent.');
+    } else if (!isConnected && newParent) {
+      throw Error('Block not connected to new parent.');
+    } else if (isConnected && !newParent) {
+      throw Error(
+          'Cannot set parent to null while block is still connected to' +
+          ' superior block.');
+    }
 
-  this.unplug(healStack);
-  if (eventUtils.isEnabled()) {
-    eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_DELETE))(this));
-  }
-  eventUtils.disable();
+    if (this.parentBlock_) {
+      // Remove this block from the old parent's child list.
+      arrayUtils.removeElem(this.parentBlock_.childBlocks_, this);
 
-  try {
-    // This block is now at the top of the workspace.
-    // Remove this block from the workspace's list of top-most blocks.
-    if (this.workspace) {
+      // This block hasn't actually moved on-screen, so there's no need to
+      // update
+      //     its connection locations.
+    } else {
+      // New parent must be non-null so remove this block from the workspace's
+      //     list of top-most blocks.
       this.workspace.removeTopBlock(this);
-      this.workspace.removeTypedBlock(this);
-      // Remove from block database.
-      this.workspace.removeBlockById(this.id);
-      this.workspace = null;
     }
 
-    // Just deleting this block from the DOM would result in a memory leak as
-    // well as corruption of the connection database.  Therefore we must
-    // methodically step through the blocks and carefully disassemble them.
-
-    if (common.getSelected() === this) {
-      common.setSelected(null);
+    this.parentBlock_ = newParent;
+    if (newParent) {
+      // Add this block to the new parent's child list.
+      newParent.childBlocks_.push(this);
+    } else {
+      this.workspace.addTopBlock(this);
     }
+  }
 
-    // First, dispose of all my children.
-    for (let i = this.childBlocks_.length - 1; i >= 0; i--) {
-      this.childBlocks_[i].dispose(false);
-    }
-    // Then dispose of myself.
-    // Dispose of all inputs and their fields.
-    for (let i = 0, input; (input = this.inputList[i]); i++) {
-      input.dispose();
-    }
-    this.inputList.length = 0;
-    // Dispose of any remaining connections (next/previous/output).
-    const connections = this.getConnections_(true);
-    for (let i = 0, connection; (connection = connections[i]); i++) {
-      connection.dispose();
+  /**
+   * Find all the blocks that are directly or indirectly nested inside this one.
+   * Includes this block in the list.
+   * Includes value and statement inputs, as well as any following statements.
+   * Excludes any connection on an output tab or any preceding statements.
+   * Blocks are optionally sorted by position; top to bottom.
+   * @param {boolean} ordered Sort the list if true.
+   * @return {!Array<!Block>} Flattened array of blocks.
+   */
+  getDescendants(ordered) {
+    const blocks = [this];
+    const childBlocks = this.getChildren(ordered);
+    for (let child, i = 0; (child = childBlocks[i]); i++) {
+      blocks.push.apply(blocks, child.getDescendants(ordered));
     }
-  } finally {
-    eventUtils.enable();
-    this.disposed = true;
+    return blocks;
   }
-};
 
-/**
- * Call initModel on all fields on the block.
- * May be called more than once.
- * Either initModel or initSvg must be called after creating a block and before
- * the first interaction with it.  Interactions include UI actions
- * (e.g. clicking and dragging) and firing events (e.g. create, delete, and
- * change).
- * @public
- */
-Block.prototype.initModel = function() {
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    for (let j = 0, field; (field = input.fieldRow[j]); j++) {
-      if (field.initModel) {
-        field.initModel();
-      }
-    }
+  /**
+   * Get whether this block is deletable or not.
+   * @return {boolean} True if deletable.
+   */
+  isDeletable() {
+    return this.deletable_ && !this.isShadow_ &&
+        !(this.workspace && this.workspace.options.readOnly);
   }
-};
 
-/**
- * Unplug this block from its superior block.  If this block is a statement,
- * optionally reconnect the block underneath with the block on top.
- * @param {boolean=} opt_healStack Disconnect child statement and reconnect
- *   stack.  Defaults to false.
- */
-Block.prototype.unplug = function(opt_healStack) {
-  if (this.outputConnection) {
-    this.unplugFromRow_(opt_healStack);
+  /**
+   * Set whether this block is deletable or not.
+   * @param {boolean} deletable True if deletable.
+   */
+  setDeletable(deletable) {
+    this.deletable_ = deletable;
   }
-  if (this.previousConnection) {
-    this.unplugFromStack_(opt_healStack);
+
+  /**
+   * Get whether this block is movable or not.
+   * @return {boolean} True if movable.
+   */
+  isMovable() {
+    return this.movable_ && !this.isShadow_ &&
+        !(this.workspace && this.workspace.options.readOnly);
   }
-};
 
-/**
- * Unplug this block's output from an input on another block.  Optionally
- * reconnect the block's parent to the only child block, if possible.
- * @param {boolean=} opt_healStack Disconnect right-side block and connect to
- *     left-side block.  Defaults to false.
- * @private
- */
-Block.prototype.unplugFromRow_ = function(opt_healStack) {
-  let parentConnection = null;
-  if (this.outputConnection.isConnected()) {
-    parentConnection = this.outputConnection.targetConnection;
-    // Disconnect from any superior block.
-    this.outputConnection.disconnect();
+  /**
+   * Set whether this block is movable or not.
+   * @param {boolean} movable True if movable.
+   */
+  setMovable(movable) {
+    this.movable_ = movable;
   }
 
-  // Return early in obvious cases.
-  if (!parentConnection || !opt_healStack) {
-    return;
+  /**
+   * Get whether is block is duplicatable or not. If duplicating this block and
+   * descendants will put this block over the workspace's capacity this block is
+   * not duplicatable. If duplicating this block and descendants will put any
+   * type over their maxInstances this block is not duplicatable.
+   * @return {boolean} True if duplicatable.
+   */
+  isDuplicatable() {
+    if (!this.workspace.hasBlockLimits()) {
+      return true;
+    }
+    return this.workspace.isCapacityAvailable(
+        common.getBlockTypeCounts(this, true));
   }
 
-  const thisConnection = this.getOnlyValueConnection_();
-  if (!thisConnection || !thisConnection.isConnected() ||
-      thisConnection.targetBlock().isShadow()) {
-    // Too many or too few possible connections on this block, or there's
-    // nothing on the other side of this connection.
-    return;
+  /**
+   * Get whether this block is a shadow block or not.
+   * @return {boolean} True if a shadow.
+   */
+  isShadow() {
+    return this.isShadow_;
   }
 
-  const childConnection = thisConnection.targetConnection;
-  // Disconnect the child block.
-  childConnection.disconnect();
-  // Connect child to the parent if possible, otherwise bump away.
-  if (this.workspace.connectionChecker.canConnect(
-          childConnection, parentConnection, false)) {
-    parentConnection.connect(childConnection);
-  } else {
-    childConnection.onFailedConnect(parentConnection);
+  /**
+   * Set whether this block is a shadow block or not.
+   * @param {boolean} shadow True if a shadow.
+   * @package
+   */
+  setShadow(shadow) {
+    this.isShadow_ = shadow;
   }
-};
 
-/**
- * Returns the connection on the value input that is connected to another block.
- * When an insertion marker is connected to a connection with a block already
- * attached, the connected block is attached to the insertion marker.
- * Since only one block can be displaced and attached to the insertion marker
- * this should only ever return one connection.
- *
- * @return {?Connection} The connection on the value input, or null.
- * @private
- */
-Block.prototype.getOnlyValueConnection_ = function() {
-  let connection = null;
-  for (let i = 0; i < this.inputList.length; i++) {
-    const thisConnection = this.inputList[i].connection;
-    if (thisConnection && thisConnection.type === ConnectionType.INPUT_VALUE &&
-        thisConnection.targetConnection) {
-      if (connection) {
-        return null;  // More than one value input found.
-      }
-      connection = thisConnection;
-    }
+  /**
+   * Get whether this block is an insertion marker block or not.
+   * @return {boolean} True if an insertion marker.
+   */
+  isInsertionMarker() {
+    return this.isInsertionMarker_;
   }
-  return connection;
-};
 
-/**
- * Unplug this statement block from its superior block.  Optionally reconnect
- * the block underneath with the block on top.
- * @param {boolean=} opt_healStack Disconnect child statement and reconnect
- *   stack.  Defaults to false.
- * @private
- */
-Block.prototype.unplugFromStack_ = function(opt_healStack) {
-  let previousTarget = null;
-  if (this.previousConnection.isConnected()) {
-    // Remember the connection that any next statements need to connect to.
-    previousTarget = this.previousConnection.targetConnection;
-    // Detach this block from the parent's tree.
-    this.previousConnection.disconnect();
-  }
-  const nextBlock = this.getNextBlock();
-  if (opt_healStack && nextBlock && !nextBlock.isShadow()) {
-    // Disconnect the next statement.
-    const nextTarget = this.nextConnection.targetConnection;
-    nextTarget.disconnect();
-    if (previousTarget &&
-        this.workspace.connectionChecker.canConnect(
-            previousTarget, nextTarget, false)) {
-      // Attach the next statement to the previous statement.
-      previousTarget.connect(nextTarget);
-    }
-  }
-};
+  /**
+   * Set whether this block is an insertion marker block or not.
+   * Once set this cannot be unset.
+   * @param {boolean} insertionMarker True if an insertion marker.
+   * @package
+   */
+  setInsertionMarker(insertionMarker) {
+    this.isInsertionMarker_ = insertionMarker;
+  }
 
-/**
- * Returns all connections originating from this block.
- * @param {boolean} _all If true, return all connections even hidden ones.
- * @return {!Array<!Connection>} Array of connections.
- * @package
- */
-Block.prototype.getConnections_ = function(_all) {
-  const myConnections = [];
-  if (this.outputConnection) {
-    myConnections.push(this.outputConnection);
-  }
-  if (this.previousConnection) {
-    myConnections.push(this.previousConnection);
-  }
-  if (this.nextConnection) {
-    myConnections.push(this.nextConnection);
-  }
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    if (input.connection) {
-      myConnections.push(input.connection);
-    }
+  /**
+   * Get whether this block is editable or not.
+   * @return {boolean} True if editable.
+   */
+  isEditable() {
+    return this.editable_ &&
+        !(this.workspace && this.workspace.options.readOnly);
   }
-  return myConnections;
-};
 
-/**
- * Walks down a stack of blocks and finds the last next connection on the stack.
- * @param {boolean} ignoreShadows If true,the last connection on a non-shadow
- *     block will be returned. If false, this will follow shadows to find the
- *     last connection.
- * @return {?Connection} The last next connection on the stack, or null.
- * @package
- */
-Block.prototype.lastConnectionInStack = function(ignoreShadows) {
-  let nextConnection = this.nextConnection;
-  while (nextConnection) {
-    const nextBlock = nextConnection.targetBlock();
-    if (!nextBlock || (ignoreShadows && nextBlock.isShadow())) {
-      return nextConnection;
+  /**
+   * Set whether this block is editable or not.
+   * @param {boolean} editable True if editable.
+   */
+  setEditable(editable) {
+    this.editable_ = editable;
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      for (let j = 0, field; (field = input.fieldRow[j]); j++) {
+        field.updateEditable();
+      }
     }
-    nextConnection = nextBlock.nextConnection;
   }
-  return null;
-};
-
-/**
- * Bump unconnected blocks out of alignment.  Two blocks which aren't actually
- * connected should not coincidentally line up on screen.
- */
-Block.prototype.bumpNeighbours = function() {
-  // noop.
-};
 
-/**
- * Return the parent block or null if this block is at the top level. The parent
- * block is either the block connected to the previous connection (for a
- * statement block) or the block connected to the output connection (for a value
- * block).
- * @return {?Block} The block (if any) that holds the current block.
- */
-Block.prototype.getParent = function() {
-  return this.parentBlock_;
-};
-
-/**
- * Return the input that connects to the specified block.
- * @param {!Block} block A block connected to an input on this block.
- * @return {?Input} The input (if any) that connects to the specified
- *     block.
- */
-Block.prototype.getInputWithBlock = function(block) {
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    if (input.connection && input.connection.targetBlock() === block) {
-      return input;
-    }
+  /**
+   * Returns if this block has been disposed of / deleted.
+   * @return {boolean} True if this block has been disposed of / deleted.
+   */
+  isDisposed() {
+    return this.disposed;
   }
-  return null;
-};
 
-/**
- * Return the parent block that surrounds the current block, or null if this
- * block has no surrounding block.  A parent block might just be the previous
- * statement, whereas the surrounding block is an if statement, while loop, etc.
- * @return {?Block} The block (if any) that surrounds the current block.
- */
-Block.prototype.getSurroundParent = function() {
-  let block = this;
-  let prevBlock;
-  do {
-    prevBlock = block;
-    block = block.getParent();
-    if (!block) {
-      // Ran off the top.
-      return null;
-    }
-  } while (block.getNextBlock() === prevBlock);
-  // This block is an enclosing parent, not just a statement in a stack.
-  return block;
-};
-
-/**
- * Return the next statement block directly connected to this block.
- * @return {?Block} The next statement block or null.
- */
-Block.prototype.getNextBlock = function() {
-  return this.nextConnection && this.nextConnection.targetBlock();
-};
-
-/**
- * Returns the block connected to the previous connection.
- * @return {?Block} The previous statement block or null.
- */
-Block.prototype.getPreviousBlock = function() {
-  return this.previousConnection && this.previousConnection.targetBlock();
-};
-
-/**
- * Return the connection on the first statement input on this block, or null if
- * there are none.
- * @return {?Connection} The first statement connection or null.
- * @package
- */
-Block.prototype.getFirstStatementConnection = function() {
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    if (input.connection &&
-        input.connection.type === ConnectionType.NEXT_STATEMENT) {
-      return input.connection;
+  /**
+   * Find the connection on this block that corresponds to the given connection
+   * on the other block.
+   * Used to match connections between a block and its insertion marker.
+   * @param {!Block} otherBlock The other block to match against.
+   * @param {!Connection} conn The other connection to match.
+   * @return {?Connection} The matching connection on this block, or null.
+   * @package
+   */
+  getMatchingConnection(otherBlock, conn) {
+    const connections = this.getConnections_(true);
+    const otherConnections = otherBlock.getConnections_(true);
+    if (connections.length !== otherConnections.length) {
+      throw Error('Connection lists did not match in length.');
     }
-  }
-  return null;
-};
-
-/**
- * Return the top-most block in this block's tree.
- * This will return itself if this block is at the top level.
- * @return {!Block} The root block.
- */
-Block.prototype.getRootBlock = function() {
-  let rootBlock;
-  let block = this;
-  do {
-    rootBlock = block;
-    block = rootBlock.parentBlock_;
-  } while (block);
-  return rootBlock;
-};
-
-/**
- * Walk up from the given block up through the stack of blocks to find
- * the top block of the sub stack. If we are nested in a statement input only
- * find the top-most nested block. Do not go all the way to the root block.
- * @return {!Block} The top block in a stack.
- * @package
- */
-Block.prototype.getTopStackBlock = function() {
-  let block = this;
-  let previous;
-  do {
-    previous = block.getPreviousBlock();
-  } while (previous && previous.getNextBlock() === block && (block = previous));
-  return block;
-};
-
-/**
- * Find all the blocks that are directly nested inside this one.
- * Includes value and statement inputs, as well as any following statement.
- * Excludes any connection on an output tab or any preceding statement.
- * Blocks are optionally sorted by position; top to bottom.
- * @param {boolean} ordered Sort the list if true.
- * @return {!Array<!Block>} Array of blocks.
- */
-Block.prototype.getChildren = function(ordered) {
-  if (!ordered) {
-    return this.childBlocks_;
-  }
-  const blocks = [];
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    if (input.connection) {
-      const child = input.connection.targetBlock();
-      if (child) {
-        blocks.push(child);
+    for (let i = 0; i < otherConnections.length; i++) {
+      if (otherConnections[i] === conn) {
+        return connections[i];
       }
     }
+    return null;
   }
-  const next = this.getNextBlock();
-  if (next) {
-    blocks.push(next);
-  }
-  return blocks;
-};
 
-/**
- * Set parent of this block to be a new block or null.
- * @param {Block} newParent New parent block.
- * @package
- */
-Block.prototype.setParent = function(newParent) {
-  if (newParent === this.parentBlock_) {
-    return;
+  /**
+   * Set the URL of this block's help page.
+   * @param {string|Function} url URL string for block help, or function that
+   *     returns a URL.  Null for no help.
+   */
+  setHelpUrl(url) {
+    this.helpUrl = url;
   }
 
-  // Check that block is connected to new parent if new parent is not null and
-  //    that block is not connected to superior one if new parent is null.
-  const targetBlock =
-      (this.previousConnection && this.previousConnection.targetBlock()) ||
-      (this.outputConnection && this.outputConnection.targetBlock());
-  const isConnected = !!targetBlock;
-
-  if (isConnected && newParent && targetBlock !== newParent) {
-    throw Error('Block connected to superior one that is not new parent.');
-  } else if (!isConnected && newParent) {
-    throw Error('Block not connected to new parent.');
-  } else if (isConnected && !newParent) {
-    throw Error(
-        'Cannot set parent to null while block is still connected to' +
-        ' superior block.');
+  /**
+   * Sets the tooltip for this block.
+   * @param {!Tooltip.TipInfo} newTip The text for the tooltip, a function
+   *     that returns the text for the tooltip, or a parent object whose tooltip
+   *     will be used. To not display a tooltip pass the empty string.
+   */
+  setTooltip(newTip) {
+    this.tooltip = newTip;
   }
 
-  if (this.parentBlock_) {
-    // Remove this block from the old parent's child list.
-    arrayUtils.removeElem(this.parentBlock_.childBlocks_, this);
-
-    // This block hasn't actually moved on-screen, so there's no need to update
-    //     its connection locations.
-  } else {
-    // New parent must be non-null so remove this block from the workspace's
-    //     list of top-most blocks.
-    this.workspace.removeTopBlock(this);
+  /**
+   * Returns the tooltip text for this block.
+   * @return {!string} The tooltip text for this block.
+   */
+  getTooltip() {
+    return Tooltip.getTooltipOfObject(this);
   }
 
-  this.parentBlock_ = newParent;
-  if (newParent) {
-    // Add this block to the new parent's child list.
-    newParent.childBlocks_.push(this);
-  } else {
-    this.workspace.addTopBlock(this);
+  /**
+   * Get the colour of a block.
+   * @return {string} #RRGGBB string.
+   */
+  getColour() {
+    return this.colour_;
   }
-};
 
-/**
- * Find all the blocks that are directly or indirectly nested inside this one.
- * Includes this block in the list.
- * Includes value and statement inputs, as well as any following statements.
- * Excludes any connection on an output tab or any preceding statements.
- * Blocks are optionally sorted by position; top to bottom.
- * @param {boolean} ordered Sort the list if true.
- * @return {!Array<!Block>} Flattened array of blocks.
- */
-Block.prototype.getDescendants = function(ordered) {
-  const blocks = [this];
-  const childBlocks = this.getChildren(ordered);
-  for (let child, i = 0; (child = childBlocks[i]); i++) {
-    blocks.push.apply(blocks, child.getDescendants(ordered));
+  /**
+   * Get the name of the block style.
+   * @return {string} Name of the block style.
+   */
+  getStyleName() {
+    return this.styleName_;
   }
-  return blocks;
-};
 
-/**
- * Get whether this block is deletable or not.
- * @return {boolean} True if deletable.
- */
-Block.prototype.isDeletable = function() {
-  return this.deletable_ && !this.isShadow_ &&
-      !(this.workspace && this.workspace.options.readOnly);
-};
-
-/**
- * Set whether this block is deletable or not.
- * @param {boolean} deletable True if deletable.
- */
-Block.prototype.setDeletable = function(deletable) {
-  this.deletable_ = deletable;
-};
-
-/**
- * Get whether this block is movable or not.
- * @return {boolean} True if movable.
- */
-Block.prototype.isMovable = function() {
-  return this.movable_ && !this.isShadow_ &&
-      !(this.workspace && this.workspace.options.readOnly);
-};
-
-/**
- * Set whether this block is movable or not.
- * @param {boolean} movable True if movable.
- */
-Block.prototype.setMovable = function(movable) {
-  this.movable_ = movable;
-};
-
-/**
- * Get whether is block is duplicatable or not. If duplicating this block and
- * descendants will put this block over the workspace's capacity this block is
- * not duplicatable. If duplicating this block and descendants will put any
- * type over their maxInstances this block is not duplicatable.
- * @return {boolean} True if duplicatable.
- */
-Block.prototype.isDuplicatable = function() {
-  if (!this.workspace.hasBlockLimits()) {
-    return true;
+  /**
+   * Get the HSV hue value of a block.  Null if hue not set.
+   * @return {?number} Hue value (0-360).
+   */
+  getHue() {
+    return this.hue_;
   }
-  return this.workspace.isCapacityAvailable(
-      common.getBlockTypeCounts(this, true));
-};
 
-/**
- * Get whether this block is a shadow block or not.
- * @return {boolean} True if a shadow.
- */
-Block.prototype.isShadow = function() {
-  return this.isShadow_;
-};
-
-/**
- * Set whether this block is a shadow block or not.
- * @param {boolean} shadow True if a shadow.
- * @package
- */
-Block.prototype.setShadow = function(shadow) {
-  this.isShadow_ = shadow;
-};
-
-/**
- * Get whether this block is an insertion marker block or not.
- * @return {boolean} True if an insertion marker.
- */
-Block.prototype.isInsertionMarker = function() {
-  return this.isInsertionMarker_;
-};
-
-/**
- * Set whether this block is an insertion marker block or not.
- * Once set this cannot be unset.
- * @param {boolean} insertionMarker True if an insertion marker.
- * @package
- */
-Block.prototype.setInsertionMarker = function(insertionMarker) {
-  this.isInsertionMarker_ = insertionMarker;
-};
+  /**
+   * Change the colour of a block.
+   * @param {number|string} colour HSV hue value (0 to 360), #RRGGBB string,
+   *     or a message reference string pointing to one of those two values.
+   */
+  setColour(colour) {
+    const parsed = parsing.parseBlockColour(colour);
+    this.hue_ = parsed.hue;
+    this.colour_ = parsed.hex;
+  }
 
-/**
- * Get whether this block is editable or not.
- * @return {boolean} True if editable.
- */
-Block.prototype.isEditable = function() {
-  return this.editable_ && !(this.workspace && this.workspace.options.readOnly);
-};
+  /**
+   * Set the style and colour values of a block.
+   * @param {string} blockStyleName Name of the block style.
+   */
+  setStyle(blockStyleName) {
+    this.styleName_ = blockStyleName;
+  }
 
-/**
- * Set whether this block is editable or not.
- * @param {boolean} editable True if editable.
- */
-Block.prototype.setEditable = function(editable) {
-  this.editable_ = editable;
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    for (let j = 0, field; (field = input.fieldRow[j]); j++) {
-      field.updateEditable();
+  /**
+   * Sets a callback function to use whenever the block's parent workspace
+   * changes, replacing any prior onchange handler. This is usually only called
+   * from the constructor, the block type initializer function, or an extension
+   * initializer function.
+   * @param {function(Abstract)} onchangeFn The callback to call
+   *     when the block's workspace changes.
+   * @throws {Error} if onchangeFn is not falsey and not a function.
+   */
+  setOnChange(onchangeFn) {
+    if (onchangeFn && typeof onchangeFn !== 'function') {
+      throw Error('onchange must be a function.');
+    }
+    if (this.onchangeWrapper_) {
+      this.workspace.removeChangeListener(this.onchangeWrapper_);
+    }
+    this.onchange = onchangeFn;
+    if (this.onchange) {
+      this.onchangeWrapper_ = onchangeFn.bind(this);
+      this.workspace.addChangeListener(this.onchangeWrapper_);
     }
   }
-};
-
-/**
- * Returns if this block has been disposed of / deleted.
- * @return {boolean} True if this block has been disposed of / deleted.
- */
-Block.prototype.isDisposed = function() {
-  return this.disposed;
-};
 
-/**
- * Find the connection on this block that corresponds to the given connection
- * on the other block.
- * Used to match connections between a block and its insertion marker.
- * @param {!Block} otherBlock The other block to match against.
- * @param {!Connection} conn The other connection to match.
- * @return {?Connection} The matching connection on this block, or null.
- * @package
- */
-Block.prototype.getMatchingConnection = function(otherBlock, conn) {
-  const connections = this.getConnections_(true);
-  const otherConnections = otherBlock.getConnections_(true);
-  if (connections.length !== otherConnections.length) {
-    throw Error('Connection lists did not match in length.');
-  }
-  for (let i = 0; i < otherConnections.length; i++) {
-    if (otherConnections[i] === conn) {
-      return connections[i];
+  /**
+   * Returns the named field from a block.
+   * @param {string} name The name of the field.
+   * @return {?Field} Named field, or null if field does not exist.
+   */
+  getField(name) {
+    if (typeof name !== 'string') {
+      throw TypeError(
+          'Block.prototype.getField expects a string ' +
+          'with the field name but received ' +
+          (name === undefined ? 'nothing' : name + ' of type ' + typeof name) +
+          ' instead');
     }
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      for (let j = 0, field; (field = input.fieldRow[j]); j++) {
+        if (field.name === name) {
+          return field;
+        }
+      }
+    }
+    return null;
   }
-  return null;
-};
 
-/**
- * Set the URL of this block's help page.
- * @param {string|Function} url URL string for block help, or function that
- *     returns a URL.  Null for no help.
- */
-Block.prototype.setHelpUrl = function(url) {
-  this.helpUrl = url;
-};
-
-/**
- * Sets the tooltip for this block.
- * @param {!Tooltip.TipInfo} newTip The text for the tooltip, a function
- *     that returns the text for the tooltip, or a parent object whose tooltip
- *     will be used. To not display a tooltip pass the empty string.
- */
-Block.prototype.setTooltip = function(newTip) {
-  this.tooltip = newTip;
-};
-
-/**
- * Returns the tooltip text for this block.
- * @return {!string} The tooltip text for this block.
- */
-Block.prototype.getTooltip = function() {
-  return Tooltip.getTooltipOfObject(this);
-};
-
-/**
- * Get the colour of a block.
- * @return {string} #RRGGBB string.
- */
-Block.prototype.getColour = function() {
-  return this.colour_;
-};
-
-/**
- * Get the name of the block style.
- * @return {string} Name of the block style.
- */
-Block.prototype.getStyleName = function() {
-  return this.styleName_;
-};
-
-/**
- * Get the HSV hue value of a block.  Null if hue not set.
- * @return {?number} Hue value (0-360).
- */
-Block.prototype.getHue = function() {
-  return this.hue_;
-};
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array<string>} List of variable ids.
+   */
+  getVars() {
+    const vars = [];
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      for (let j = 0, field; (field = input.fieldRow[j]); j++) {
+        if (field.referencesVariables()) {
+          vars.push(field.getValue());
+        }
+      }
+    }
+    return vars;
+  }
 
-/**
- * Change the colour of a block.
- * @param {number|string} colour HSV hue value (0 to 360), #RRGGBB string,
- *     or a message reference string pointing to one of those two values.
- */
-Block.prototype.setColour = function(colour) {
-  const parsed = parsing.parseBlockColour(colour);
-  this.hue_ = parsed.hue;
-  this.colour_ = parsed.hex;
-};
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array<!VariableModel>} List of variable models.
+   * @package
+   */
+  getVarModels() {
+    const vars = [];
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      for (let j = 0, field; (field = input.fieldRow[j]); j++) {
+        if (field.referencesVariables()) {
+          const model = this.workspace.getVariableById(
+              /** @type {string} */ (field.getValue()));
+          // Check if the variable actually exists (and isn't just a potential
+          // variable).
+          if (model) {
+            vars.push(model);
+          }
+        }
+      }
+    }
+    return vars;
+  }
 
-/**
- * Set the style and colour values of a block.
- * @param {string} blockStyleName Name of the block style.
- */
-Block.prototype.setStyle = function(blockStyleName) {
-  this.styleName_ = blockStyleName;
-};
+  /**
+   * Notification that a variable is renaming but keeping the same ID.  If the
+   * variable is in use on this block, rerender to show the new name.
+   * @param {!VariableModel} variable The variable being renamed.
+   * @package
+   */
+  updateVarName(variable) {
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      for (let j = 0, field; (field = input.fieldRow[j]); j++) {
+        if (field.referencesVariables() &&
+            variable.getId() === field.getValue()) {
+          field.refreshVariableName();
+        }
+      }
+    }
+  }
 
-/**
- * Sets a callback function to use whenever the block's parent workspace
- * changes, replacing any prior onchange handler. This is usually only called
- * from the constructor, the block type initializer function, or an extension
- * initializer function.
- * @param {function(Abstract)} onchangeFn The callback to call
- *     when the block's workspace changes.
- * @throws {Error} if onchangeFn is not falsey and not a function.
- */
-Block.prototype.setOnChange = function(onchangeFn) {
-  if (onchangeFn && typeof onchangeFn !== 'function') {
-    throw Error('onchange must be a function.');
+  /**
+   * Notification that a variable is renaming.
+   * If the ID matches one of this block's variables, rename it.
+   * @param {string} oldId ID of variable to rename.
+   * @param {string} newId ID of new variable.  May be the same as oldId, but
+   *     with an updated name.
+   */
+  renameVarById(oldId, newId) {
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      for (let j = 0, field; (field = input.fieldRow[j]); j++) {
+        if (field.referencesVariables() && oldId === field.getValue()) {
+          field.setValue(newId);
+        }
+      }
+    }
   }
-  if (this.onchangeWrapper_) {
-    this.workspace.removeChangeListener(this.onchangeWrapper_);
+
+  /**
+   * Returns the language-neutral value of the given field.
+   * @param {string} name The name of the field.
+   * @return {*} Value of the field or null if field does not exist.
+   */
+  getFieldValue(name) {
+    const field = this.getField(name);
+    if (field) {
+      return field.getValue();
+    }
+    return null;
   }
-  this.onchange = onchangeFn;
-  if (this.onchange) {
-    this.onchangeWrapper_ = onchangeFn.bind(this);
-    this.workspace.addChangeListener(this.onchangeWrapper_);
+
+  /**
+   * Sets the value of the given field for this block.
+   * @param {*} newValue The value to set.
+   * @param {string} name The name of the field to set the value of.
+   */
+  setFieldValue(newValue, name) {
+    const field = this.getField(name);
+    if (!field) {
+      throw Error('Field "' + name + '" not found.');
+    }
+    field.setValue(newValue);
   }
-};
 
-/**
- * Returns the named field from a block.
- * @param {string} name The name of the field.
- * @return {?Field} Named field, or null if field does not exist.
- */
-Block.prototype.getField = function(name) {
-  if (typeof name !== 'string') {
-    throw TypeError(
-        'Block.prototype.getField expects a string ' +
-        'with the field name but received ' +
-        (name === undefined ? 'nothing' : name + ' of type ' + typeof name) +
-        ' instead');
-  }
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    for (let j = 0, field; (field = input.fieldRow[j]); j++) {
-      if (field.name === name) {
-        return field;
+  /**
+   * Set whether this block can chain onto the bottom of another block.
+   * @param {boolean} newBoolean True if there can be a previous statement.
+   * @param {(string|Array<string>|null)=} opt_check Statement type or
+   *     list of statement types.  Null/undefined if any type could be
+   * connected.
+   */
+  setPreviousStatement(newBoolean, opt_check) {
+    if (newBoolean) {
+      if (opt_check === undefined) {
+        opt_check = null;
+      }
+      if (!this.previousConnection) {
+        this.previousConnection =
+            this.makeConnection_(ConnectionType.PREVIOUS_STATEMENT);
+      }
+      this.previousConnection.setCheck(opt_check);
+    } else {
+      if (this.previousConnection) {
+        if (this.previousConnection.isConnected()) {
+          throw Error(
+              'Must disconnect previous statement before removing ' +
+              'connection.');
+        }
+        this.previousConnection.dispose();
+        this.previousConnection = null;
       }
     }
   }
-  return null;
-};
 
-/**
- * Return all variables referenced by this block.
- * @return {!Array<string>} List of variable ids.
- */
-Block.prototype.getVars = function() {
-  const vars = [];
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    for (let j = 0, field; (field = input.fieldRow[j]); j++) {
-      if (field.referencesVariables()) {
-        vars.push(field.getValue());
+  /**
+   * Set whether another block can chain onto the bottom of this block.
+   * @param {boolean} newBoolean True if there can be a next statement.
+   * @param {(string|Array<string>|null)=} opt_check Statement type or
+   *     list of statement types.  Null/undefined if any type could be
+   * connected.
+   */
+  setNextStatement(newBoolean, opt_check) {
+    if (newBoolean) {
+      if (opt_check === undefined) {
+        opt_check = null;
+      }
+      if (!this.nextConnection) {
+        this.nextConnection =
+            this.makeConnection_(ConnectionType.NEXT_STATEMENT);
+      }
+      this.nextConnection.setCheck(opt_check);
+    } else {
+      if (this.nextConnection) {
+        if (this.nextConnection.isConnected()) {
+          throw Error(
+              'Must disconnect next statement before removing ' +
+              'connection.');
+        }
+        this.nextConnection.dispose();
+        this.nextConnection = null;
       }
     }
   }
-  return vars;
-};
 
-/**
- * Return all variables referenced by this block.
- * @return {!Array<!VariableModel>} List of variable models.
- * @package
- */
-Block.prototype.getVarModels = function() {
-  const vars = [];
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    for (let j = 0, field; (field = input.fieldRow[j]); j++) {
-      if (field.referencesVariables()) {
-        const model = this.workspace.getVariableById(
-            /** @type {string} */ (field.getValue()));
-        // Check if the variable actually exists (and isn't just a potential
-        // variable).
-        if (model) {
-          vars.push(model);
+  /**
+   * Set whether this block returns a value.
+   * @param {boolean} newBoolean True if there is an output.
+   * @param {(string|Array<string>|null)=} opt_check Returned type or list
+   *     of returned types.  Null or undefined if any type could be returned
+   *     (e.g. variable get).
+   */
+  setOutput(newBoolean, opt_check) {
+    if (newBoolean) {
+      if (opt_check === undefined) {
+        opt_check = null;
+      }
+      if (!this.outputConnection) {
+        this.outputConnection =
+            this.makeConnection_(ConnectionType.OUTPUT_VALUE);
+      }
+      this.outputConnection.setCheck(opt_check);
+    } else {
+      if (this.outputConnection) {
+        if (this.outputConnection.isConnected()) {
+          throw Error(
+              'Must disconnect output value before removing connection.');
         }
+        this.outputConnection.dispose();
+        this.outputConnection = null;
       }
     }
   }
-  return vars;
-};
 
-/**
- * Notification that a variable is renaming but keeping the same ID.  If the
- * variable is in use on this block, rerender to show the new name.
- * @param {!VariableModel} variable The variable being renamed.
- * @package
- */
-Block.prototype.updateVarName = function(variable) {
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    for (let j = 0, field; (field = input.fieldRow[j]); j++) {
-      if (field.referencesVariables() &&
-          variable.getId() === field.getValue()) {
-        field.refreshVariableName();
-      }
+  /**
+   * Set whether value inputs are arranged horizontally or vertically.
+   * @param {boolean} newBoolean True if inputs are horizontal.
+   */
+  setInputsInline(newBoolean) {
+    if (this.inputsInline !== newBoolean) {
+      eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CHANGE))(
+          this, 'inline', null, this.inputsInline, newBoolean));
+      this.inputsInline = newBoolean;
     }
   }
-};
 
-/**
- * Notification that a variable is renaming.
- * If the ID matches one of this block's variables, rename it.
- * @param {string} oldId ID of variable to rename.
- * @param {string} newId ID of new variable.  May be the same as oldId, but with
- *     an updated name.
- */
-Block.prototype.renameVarById = function(oldId, newId) {
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    for (let j = 0, field; (field = input.fieldRow[j]); j++) {
-      if (field.referencesVariables() && oldId === field.getValue()) {
-        field.setValue(newId);
+  /**
+   * Get whether value inputs are arranged horizontally or vertically.
+   * @return {boolean} True if inputs are horizontal.
+   */
+  getInputsInline() {
+    if (this.inputsInline !== undefined) {
+      // Set explicitly.
+      return this.inputsInline;
+    }
+    // Not defined explicitly.  Figure out what would look best.
+    for (let i = 1; i < this.inputList.length; i++) {
+      if (this.inputList[i - 1].type === inputTypes.DUMMY &&
+          this.inputList[i].type === inputTypes.DUMMY) {
+        // Two dummy inputs in a row.  Don't inline them.
+        return false;
+      }
+    }
+    for (let i = 1; i < this.inputList.length; i++) {
+      if (this.inputList[i - 1].type === inputTypes.VALUE &&
+          this.inputList[i].type === inputTypes.DUMMY) {
+        // Dummy input after a value input.  Inline them.
+        return true;
       }
     }
+    return false;
   }
-};
 
-/**
- * Returns the language-neutral value of the given field.
- * @param {string} name The name of the field.
- * @return {*} Value of the field or null if field does not exist.
- */
-Block.prototype.getFieldValue = function(name) {
-  const field = this.getField(name);
-  if (field) {
-    return field.getValue();
+  /**
+   * Set the block's output shape.
+   * @param {?number} outputShape Value representing an output shape.
+   */
+  setOutputShape(outputShape) {
+    this.outputShape_ = outputShape;
   }
-  return null;
-};
 
-/**
- * Sets the value of the given field for this block.
- * @param {*} newValue The value to set.
- * @param {string} name The name of the field to set the value of.
- */
-Block.prototype.setFieldValue = function(newValue, name) {
-  const field = this.getField(name);
-  if (!field) {
-    throw Error('Field "' + name + '" not found.');
+  /**
+   * Get the block's output shape.
+   * @return {?number} Value representing output shape if one exists.
+   */
+  getOutputShape() {
+    return this.outputShape_;
   }
-  field.setValue(newValue);
-};
 
-/**
- * Set whether this block can chain onto the bottom of another block.
- * @param {boolean} newBoolean True if there can be a previous statement.
- * @param {(string|Array<string>|null)=} opt_check Statement type or
- *     list of statement types.  Null/undefined if any type could be connected.
- */
-Block.prototype.setPreviousStatement = function(newBoolean, opt_check) {
-  if (newBoolean) {
-    if (opt_check === undefined) {
-      opt_check = null;
-    }
-    if (!this.previousConnection) {
-      this.previousConnection =
-          this.makeConnection_(ConnectionType.PREVIOUS_STATEMENT);
+  /**
+   * Get whether this block is enabled or not.
+   * @return {boolean} True if enabled.
+   */
+  isEnabled() {
+    return !this.disabled;
+  }
+
+  /**
+   * Set whether the block is enabled or not.
+   * @param {boolean} enabled True if enabled.
+   */
+  setEnabled(enabled) {
+    if (this.isEnabled() !== enabled) {
+      const oldValue = this.disabled;
+      this.disabled = !enabled;
+      eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CHANGE))(
+          this, 'disabled', null, oldValue, !enabled));
     }
-    this.previousConnection.setCheck(opt_check);
-  } else {
-    if (this.previousConnection) {
-      if (this.previousConnection.isConnected()) {
-        throw Error(
-            'Must disconnect previous statement before removing ' +
-            'connection.');
+  }
+
+  /**
+   * Get whether the block is disabled or not due to parents.
+   * The block's own disabled property is not considered.
+   * @return {boolean} True if disabled.
+   */
+  getInheritedDisabled() {
+    let ancestor = this.getSurroundParent();
+    while (ancestor) {
+      if (ancestor.disabled) {
+        return true;
       }
-      this.previousConnection.dispose();
-      this.previousConnection = null;
+      ancestor = ancestor.getSurroundParent();
     }
+    // Ran off the top.
+    return false;
   }
-};
 
-/**
- * Set whether another block can chain onto the bottom of this block.
- * @param {boolean} newBoolean True if there can be a next statement.
- * @param {(string|Array<string>|null)=} opt_check Statement type or
- *     list of statement types.  Null/undefined if any type could be connected.
- */
-Block.prototype.setNextStatement = function(newBoolean, opt_check) {
-  if (newBoolean) {
-    if (opt_check === undefined) {
-      opt_check = null;
+  /**
+   * Get whether the block is collapsed or not.
+   * @return {boolean} True if collapsed.
+   */
+  isCollapsed() {
+    return this.collapsed_;
+  }
+
+  /**
+   * Set whether the block is collapsed or not.
+   * @param {boolean} collapsed True if collapsed.
+   */
+  setCollapsed(collapsed) {
+    if (this.collapsed_ !== collapsed) {
+      eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CHANGE))(
+          this, 'collapsed', null, this.collapsed_, collapsed));
+      this.collapsed_ = collapsed;
     }
-    if (!this.nextConnection) {
-      this.nextConnection = this.makeConnection_(ConnectionType.NEXT_STATEMENT);
+  }
+
+  /**
+   * Create a human-readable text representation of this block and any children.
+   * @param {number=} opt_maxLength Truncate the string to this length.
+   * @param {string=} opt_emptyToken The placeholder string used to denote an
+   *     empty field. If not specified, '?' is used.
+   * @return {string} Text of block.
+   */
+  toString(opt_maxLength, opt_emptyToken) {
+    let text = [];
+    const emptyFieldPlaceholder = opt_emptyToken || '?';
+
+    // Temporarily set flag to navigate to all fields.
+    const prevNavigateFields = ASTNode.NAVIGATE_ALL_FIELDS;
+    ASTNode.NAVIGATE_ALL_FIELDS = true;
+
+    let node = ASTNode.createBlockNode(this);
+    const rootNode = node;
+
+    /**
+     * Whether or not to add parentheses around an input.
+     * @param {!Connection} connection The connection.
+     * @return {boolean} True if we should add parentheses around the input.
+     */
+    function shouldAddParentheses(connection) {
+      let checks = connection.getCheck();
+      if (!checks && connection.targetConnection) {
+        checks = connection.targetConnection.getCheck();
+      }
+      return !!checks &&
+          (checks.indexOf('Boolean') !== -1 || checks.indexOf('Number') !== -1);
     }
-    this.nextConnection.setCheck(opt_check);
-  } else {
-    if (this.nextConnection) {
-      if (this.nextConnection.isConnected()) {
-        throw Error(
-            'Must disconnect next statement before removing ' +
-            'connection.');
+
+    /**
+     * Check that we haven't circled back to the original root node.
+     */
+    function checkRoot() {
+      if (node && node.getType() === rootNode.getType() &&
+          node.getLocation() === rootNode.getLocation()) {
+        node = null;
       }
-      this.nextConnection.dispose();
-      this.nextConnection = null;
     }
-  }
-};
 
-/**
- * Set whether this block returns a value.
- * @param {boolean} newBoolean True if there is an output.
- * @param {(string|Array<string>|null)=} opt_check Returned type or list
- *     of returned types.  Null or undefined if any type could be returned
- *     (e.g. variable get).
- */
-Block.prototype.setOutput = function(newBoolean, opt_check) {
-  if (newBoolean) {
-    if (opt_check === undefined) {
-      opt_check = null;
+    // Traverse the AST building up our text string.
+    while (node) {
+      switch (node.getType()) {
+        case ASTNode.types.INPUT: {
+          const connection = /** @type {!Connection} */ (node.getLocation());
+          if (!node.in()) {
+            text.push(emptyFieldPlaceholder);
+          } else if (shouldAddParentheses(connection)) {
+            text.push('(');
+          }
+          break;
+        }
+        case ASTNode.types.FIELD: {
+          const field = /** @type {Field} */ (node.getLocation());
+          if (field.name !== constants.COLLAPSED_FIELD_NAME) {
+            text.push(field.getText());
+          }
+          break;
+        }
+      }
+
+      const current = node;
+      node = current.in() || current.next();
+      if (!node) {
+        // Can't go in or next, keep going out until we can go next.
+        node = current.out();
+        checkRoot();
+        while (node && !node.next()) {
+          node = node.out();
+          checkRoot();
+          // If we hit an input on the way up, possibly close out parentheses.
+          if (node && node.getType() === ASTNode.types.INPUT &&
+              shouldAddParentheses(
+                  /** @type {!Connection} */ (node.getLocation()))) {
+            text.push(')');
+          }
+        }
+        if (node) {
+          node = node.next();
+        }
+      }
     }
-    if (!this.outputConnection) {
-      this.outputConnection = this.makeConnection_(ConnectionType.OUTPUT_VALUE);
+
+    // Restore state of NAVIGATE_ALL_FIELDS.
+    ASTNode.NAVIGATE_ALL_FIELDS = prevNavigateFields;
+
+    // Run through our text array and simplify expression to remove parentheses
+    // around single field blocks.
+    // E.g. ['repeat', '(', '10', ')', 'times', 'do', '?']
+    for (let i = 2; i < text.length; i++) {
+      if (text[i - 2] === '(' && text[i] === ')') {
+        text[i - 2] = text[i - 1];
+        text.splice(i - 1, 2);
+      }
     }
-    this.outputConnection.setCheck(opt_check);
-  } else {
-    if (this.outputConnection) {
-      if (this.outputConnection.isConnected()) {
-        throw Error('Must disconnect output value before removing connection.');
+
+    // Join the text array, removing spaces around added parentheses.
+    text = text.reduce(function(acc, value) {
+      return acc + ((acc.substr(-1) === '(' || value === ')') ? '' : ' ') +
+          value;
+    }, '');
+    text = text.trim() || '???';
+    if (opt_maxLength) {
+      // TODO: Improve truncation so that text from this block is given
+      // priority. E.g. "1+2+3+4+5+6+7+8+9=0" should be "...6+7+8+9=0", not
+      // "1+2+3+4+5...". E.g. "1+2+3+4+5=6+7+8+9+0" should be "...4+5=6+7...".
+      if (text.length > opt_maxLength) {
+        text = text.substring(0, opt_maxLength - 3) + '...';
       }
-      this.outputConnection.dispose();
-      this.outputConnection = null;
     }
+    return text;
   }
-};
 
-/**
- * Set whether value inputs are arranged horizontally or vertically.
- * @param {boolean} newBoolean True if inputs are horizontal.
- */
-Block.prototype.setInputsInline = function(newBoolean) {
-  if (this.inputsInline !== newBoolean) {
-    eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CHANGE))(
-        this, 'inline', null, this.inputsInline, newBoolean));
-    this.inputsInline = newBoolean;
+  /**
+   * Shortcut for appending a value input row.
+   * @param {string} name Language-neutral identifier which may used to find
+   *     this input again.  Should be unique to this block.
+   * @return {!Input} The input object created.
+   */
+  appendValueInput(name) {
+    return this.appendInput_(inputTypes.VALUE, name);
   }
-};
 
-/**
- * Get whether value inputs are arranged horizontally or vertically.
- * @return {boolean} True if inputs are horizontal.
- */
-Block.prototype.getInputsInline = function() {
-  if (this.inputsInline !== undefined) {
-    // Set explicitly.
-    return this.inputsInline;
-  }
-  // Not defined explicitly.  Figure out what would look best.
-  for (let i = 1; i < this.inputList.length; i++) {
-    if (this.inputList[i - 1].type === inputTypes.DUMMY &&
-        this.inputList[i].type === inputTypes.DUMMY) {
-      // Two dummy inputs in a row.  Don't inline them.
-      return false;
-    }
-  }
-  for (let i = 1; i < this.inputList.length; i++) {
-    if (this.inputList[i - 1].type === inputTypes.VALUE &&
-        this.inputList[i].type === inputTypes.DUMMY) {
-      // Dummy input after a value input.  Inline them.
-      return true;
-    }
+  /**
+   * Shortcut for appending a statement input row.
+   * @param {string} name Language-neutral identifier which may used to find
+   *     this input again.  Should be unique to this block.
+   * @return {!Input} The input object created.
+   */
+  appendStatementInput(name) {
+    return this.appendInput_(inputTypes.STATEMENT, name);
   }
-  return false;
-};
 
-/**
- * Set the block's output shape.
- * @param {?number} outputShape Value representing an output shape.
- */
-Block.prototype.setOutputShape = function(outputShape) {
-  this.outputShape_ = outputShape;
-};
+  /**
+   * Shortcut for appending a dummy input row.
+   * @param {string=} opt_name Language-neutral identifier which may used to
+   *     find this input again.  Should be unique to this block.
+   * @return {!Input} The input object created.
+   */
+  appendDummyInput(opt_name) {
+    return this.appendInput_(inputTypes.DUMMY, opt_name || '');
+  }
 
-/**
- * Get the block's output shape.
- * @return {?number} Value representing output shape if one exists.
- */
-Block.prototype.getOutputShape = function() {
-  return this.outputShape_;
-};
+  /**
+   * Initialize this block using a cross-platform, internationalization-friendly
+   * JSON description.
+   * @param {!Object} json Structured data describing the block.
+   */
+  jsonInit(json) {
+    const warningPrefix = json['type'] ? 'Block "' + json['type'] + '": ' : '';
 
-/**
- * Get whether this block is enabled or not.
- * @return {boolean} True if enabled.
- */
-Block.prototype.isEnabled = function() {
-  return !this.disabled;
-};
+    // Validate inputs.
+    if (json['output'] && json['previousStatement']) {
+      throw Error(
+          warningPrefix +
+          'Must not have both an output and a previousStatement.');
+    }
 
-/**
- * Set whether the block is enabled or not.
- * @param {boolean} enabled True if enabled.
- */
-Block.prototype.setEnabled = function(enabled) {
-  if (this.isEnabled() !== enabled) {
-    const oldValue = this.disabled;
-    this.disabled = !enabled;
-    eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CHANGE))(
-        this, 'disabled', null, oldValue, !enabled));
-  }
-};
+    // Set basic properties of block.
+    // Makes styles backward compatible with old way of defining hat style.
+    if (json['style'] && json['style'].hat) {
+      this.hat = json['style'].hat;
+      // Must set to null so it doesn't error when checking for style and
+      // colour.
+      json['style'] = null;
+    }
 
-/**
- * Get whether the block is disabled or not due to parents.
- * The block's own disabled property is not considered.
- * @return {boolean} True if disabled.
- */
-Block.prototype.getInheritedDisabled = function() {
-  let ancestor = this.getSurroundParent();
-  while (ancestor) {
-    if (ancestor.disabled) {
-      return true;
+    if (json['style'] && json['colour']) {
+      throw Error(warningPrefix + 'Must not have both a colour and a style.');
+    } else if (json['style']) {
+      this.jsonInitStyle_(json, warningPrefix);
+    } else {
+      this.jsonInitColour_(json, warningPrefix);
     }
-    ancestor = ancestor.getSurroundParent();
-  }
-  // Ran off the top.
-  return false;
-};
 
-/**
- * Get whether the block is collapsed or not.
- * @return {boolean} True if collapsed.
- */
-Block.prototype.isCollapsed = function() {
-  return this.collapsed_;
-};
+    // Interpolate the message blocks.
+    let i = 0;
+    while (json['message' + i] !== undefined) {
+      this.interpolate_(
+          json['message' + i], json['args' + i] || [],
+          json['lastDummyAlign' + i], warningPrefix);
+      i++;
+    }
 
-/**
- * Set whether the block is collapsed or not.
- * @param {boolean} collapsed True if collapsed.
- */
-Block.prototype.setCollapsed = function(collapsed) {
-  if (this.collapsed_ !== collapsed) {
-    eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CHANGE))(
-        this, 'collapsed', null, this.collapsed_, collapsed));
-    this.collapsed_ = collapsed;
-  }
-};
+    if (json['inputsInline'] !== undefined) {
+      this.setInputsInline(json['inputsInline']);
+    }
+    // Set output and previous/next connections.
+    if (json['output'] !== undefined) {
+      this.setOutput(true, json['output']);
+    }
+    if (json['outputShape'] !== undefined) {
+      this.setOutputShape(json['outputShape']);
+    }
+    if (json['previousStatement'] !== undefined) {
+      this.setPreviousStatement(true, json['previousStatement']);
+    }
+    if (json['nextStatement'] !== undefined) {
+      this.setNextStatement(true, json['nextStatement']);
+    }
+    if (json['tooltip'] !== undefined) {
+      const rawValue = json['tooltip'];
+      const localizedText = parsing.replaceMessageReferences(rawValue);
+      this.setTooltip(localizedText);
+    }
+    if (json['enableContextMenu'] !== undefined) {
+      this.contextMenu = !!json['enableContextMenu'];
+    }
+    if (json['suppressPrefixSuffix'] !== undefined) {
+      this.suppressPrefixSuffix = !!json['suppressPrefixSuffix'];
+    }
+    if (json['helpUrl'] !== undefined) {
+      const rawValue = json['helpUrl'];
+      const localizedValue = parsing.replaceMessageReferences(rawValue);
+      this.setHelpUrl(localizedValue);
+    }
+    if (typeof json['extensions'] === 'string') {
+      console.warn(
+          warningPrefix +
+          'JSON attribute \'extensions\' should be an array of' +
+          ' strings. Found raw string in JSON for \'' + json['type'] +
+          '\' block.');
+      json['extensions'] = [json['extensions']];  // Correct and continue.
+    }
 
-/**
- * Create a human-readable text representation of this block and any children.
- * @param {number=} opt_maxLength Truncate the string to this length.
- * @param {string=} opt_emptyToken The placeholder string used to denote an
- *     empty field. If not specified, '?' is used.
- * @return {string} Text of block.
- */
-Block.prototype.toString = function(opt_maxLength, opt_emptyToken) {
-  let text = [];
-  const emptyFieldPlaceholder = opt_emptyToken || '?';
+    // Add the mutator to the block.
+    if (json['mutator'] !== undefined) {
+      Extensions.apply(json['mutator'], this, true);
+    }
 
-  // Temporarily set flag to navigate to all fields.
-  const prevNavigateFields = ASTNode.NAVIGATE_ALL_FIELDS;
-  ASTNode.NAVIGATE_ALL_FIELDS = true;
+    const extensionNames = json['extensions'];
+    if (Array.isArray(extensionNames)) {
+      for (let j = 0; j < extensionNames.length; j++) {
+        Extensions.apply(extensionNames[j], this, false);
+      }
+    }
+  }
 
-  let node = ASTNode.createBlockNode(this);
-  const rootNode = node;
+  /**
+   * Initialize the colour of this block from the JSON description.
+   * @param {!Object} json Structured data describing the block.
+   * @param {string} warningPrefix Warning prefix string identifying block.
+   * @private
+   */
+  jsonInitColour_(json, warningPrefix) {
+    if ('colour' in json) {
+      if (json['colour'] === undefined) {
+        console.warn(warningPrefix + 'Undefined colour value.');
+      } else {
+        const rawValue = json['colour'];
+        try {
+          this.setColour(rawValue);
+        } catch (e) {
+          console.warn(warningPrefix + 'Illegal colour value: ', rawValue);
+        }
+      }
+    }
+  }
 
   /**
-   * Whether or not to add parentheses around an input.
-   * @param {!Connection} connection The connection.
-   * @return {boolean} True if we should add parentheses around the input.
+   * Initialize the style of this block from the JSON description.
+   * @param {!Object} json Structured data describing the block.
+   * @param {string} warningPrefix Warning prefix string identifying block.
+   * @private
    */
-  function shouldAddParentheses(connection) {
-    let checks = connection.getCheck();
-    if (!checks && connection.targetConnection) {
-      checks = connection.targetConnection.getCheck();
+  jsonInitStyle_(json, warningPrefix) {
+    const blockStyleName = json['style'];
+    try {
+      this.setStyle(blockStyleName);
+    } catch (styleError) {
+      console.warn(warningPrefix + 'Style does not exist: ', blockStyleName);
     }
-    return !!checks &&
-        (checks.indexOf('Boolean') !== -1 || checks.indexOf('Number') !== -1);
   }
 
   /**
-   * Check that we haven't circled back to the original root node.
+   * Add key/values from mixinObj to this block object. By default, this method
+   * will check that the keys in mixinObj will not overwrite existing values in
+   * the block, including prototype values. This provides some insurance against
+   * mixin / extension incompatibilities with future block features. This check
+   * can be disabled by passing true as the second argument.
+   * @param {!Object} mixinObj The key/values pairs to add to this block object.
+   * @param {boolean=} opt_disableCheck Option flag to disable overwrite checks.
    */
-  function checkRoot() {
-    if (node && node.getType() === rootNode.getType() &&
-        node.getLocation() === rootNode.getLocation()) {
-      node = null;
+  mixin(mixinObj, opt_disableCheck) {
+    if (opt_disableCheck !== undefined &&
+        typeof opt_disableCheck !== 'boolean') {
+      throw Error('opt_disableCheck must be a boolean if provided');
     }
-  }
-
-  // Traverse the AST building up our text string.
-  while (node) {
-    switch (node.getType()) {
-      case ASTNode.types.INPUT: {
-        const connection = /** @type {!Connection} */ (node.getLocation());
-        if (!node.in()) {
-          text.push(emptyFieldPlaceholder);
-        } else if (shouldAddParentheses(connection)) {
-          text.push('(');
+    if (!opt_disableCheck) {
+      const overwrites = [];
+      for (const key in mixinObj) {
+        if (this[key] !== undefined) {
+          overwrites.push(key);
         }
-        break;
       }
-      case ASTNode.types.FIELD: {
-        const field = /** @type {Field} */ (node.getLocation());
-        if (field.name !== constants.COLLAPSED_FIELD_NAME) {
-          text.push(field.getText());
-        }
-        break;
+      if (overwrites.length) {
+        throw Error(
+            'Mixin will overwrite block members: ' +
+            JSON.stringify(overwrites));
       }
     }
+    object.mixin(this, mixinObj);
+  }
 
-    const current = node;
-    node = current.in() || current.next();
-    if (!node) {
-      // Can't go in or next, keep going out until we can go next.
-      node = current.out();
-      checkRoot();
-      while (node && !node.next()) {
-        node = node.out();
-        checkRoot();
-        // If we hit an input on the way up, possibly close out parentheses.
-        if (node && node.getType() === ASTNode.types.INPUT &&
-            shouldAddParentheses(
-                /** @type {!Connection} */ (node.getLocation()))) {
-          text.push(')');
+  /**
+   * Interpolate a message description onto the block.
+   * @param {string} message Text contains interpolation tokens (%1, %2, ...)
+   *     that match with fields or inputs defined in the args array.
+   * @param {!Array} args Array of arguments to be interpolated.
+   * @param {string|undefined} lastDummyAlign If a dummy input is added at the
+   *     end, how should it be aligned?
+   * @param {string} warningPrefix Warning prefix string identifying block.
+   * @private
+   */
+  interpolate_(message, args, lastDummyAlign, warningPrefix) {
+    const tokens = parsing.tokenizeInterpolation(message);
+    this.validateTokens_(tokens, args.length);
+    const elements = this.interpolateArguments_(tokens, args, lastDummyAlign);
+
+    // An array of [field, fieldName] tuples.
+    const fieldStack = [];
+    for (let i = 0, element; (element = elements[i]); i++) {
+      if (this.isInputKeyword_(element['type'])) {
+        const input = this.inputFromJson_(element, warningPrefix);
+        // Should never be null, but just in case.
+        if (input) {
+          for (let j = 0, tuple; (tuple = fieldStack[j]); j++) {
+            input.appendField(tuple[0], tuple[1]);
+          }
+          fieldStack.length = 0;
+        }
+      } else {
+        // All other types, including ones starting with 'input_' get routed
+        // here.
+        const field = this.fieldFromJson_(element);
+        if (field) {
+          fieldStack.push([field, element['name']]);
         }
-      }
-      if (node) {
-        node = node.next();
       }
     }
   }
 
-  // Restore state of NAVIGATE_ALL_FIELDS.
-  ASTNode.NAVIGATE_ALL_FIELDS = prevNavigateFields;
-
-  // Run through our text array and simplify expression to remove parentheses
-  // around single field blocks.
-  // E.g. ['repeat', '(', '10', ')', 'times', 'do', '?']
-  for (let i = 2; i < text.length; i++) {
-    if (text[i - 2] === '(' && text[i] === ')') {
-      text[i - 2] = text[i - 1];
-      text.splice(i - 1, 2);
+  /**
+   * Validates that the tokens are within the correct bounds, with no
+   * duplicates, and that all of the arguments are referred to. Throws errors if
+   * any of these things are not true.
+   * @param {!Array<string|number>} tokens An array of tokens to validate
+   * @param {number} argsCount The number of args that need to be referred to.
+   * @private
+   */
+  validateTokens_(tokens, argsCount) {
+    const visitedArgsHash = [];
+    let visitedArgsCount = 0;
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      if (typeof token !== 'number') {
+        continue;
+      }
+      if (token < 1 || token > argsCount) {
+        throw Error(
+            'Block "' + this.type + '": ' +
+            'Message index %' + token + ' out of range.');
+      }
+      if (visitedArgsHash[token]) {
+        throw Error(
+            'Block "' + this.type + '": ' +
+            'Message index %' + token + ' duplicated.');
+      }
+      visitedArgsHash[token] = true;
+      visitedArgsCount++;
     }
-  }
-
-  // Join the text array, removing spaces around added parentheses.
-  text = text.reduce(function(acc, value) {
-    return acc + ((acc.substr(-1) === '(' || value === ')') ? '' : ' ') + value;
-  }, '');
-  text = text.trim() || '???';
-  if (opt_maxLength) {
-    // TODO: Improve truncation so that text from this block is given priority.
-    // E.g. "1+2+3+4+5+6+7+8+9=0" should be "...6+7+8+9=0", not "1+2+3+4+5...".
-    // E.g. "1+2+3+4+5=6+7+8+9+0" should be "...4+5=6+7...".
-    if (text.length > opt_maxLength) {
-      text = text.substring(0, opt_maxLength - 3) + '...';
+    if (visitedArgsCount !== argsCount) {
+      throw Error(
+          'Block "' + this.type + '": ' +
+          'Message does not reference all ' + argsCount + ' arg(s).');
     }
   }
-  return text;
-};
-
-/**
- * Shortcut for appending a value input row.
- * @param {string} name Language-neutral identifier which may used to find this
- *     input again.  Should be unique to this block.
- * @return {!Input} The input object created.
- */
-Block.prototype.appendValueInput = function(name) {
-  return this.appendInput_(inputTypes.VALUE, name);
-};
-
-/**
- * Shortcut for appending a statement input row.
- * @param {string} name Language-neutral identifier which may used to find this
- *     input again.  Should be unique to this block.
- * @return {!Input} The input object created.
- */
-Block.prototype.appendStatementInput = function(name) {
-  return this.appendInput_(inputTypes.STATEMENT, name);
-};
-
-/**
- * Shortcut for appending a dummy input row.
- * @param {string=} opt_name Language-neutral identifier which may used to find
- *     this input again.  Should be unique to this block.
- * @return {!Input} The input object created.
- */
-Block.prototype.appendDummyInput = function(opt_name) {
-  return this.appendInput_(inputTypes.DUMMY, opt_name || '');
-};
-
-/**
- * Initialize this block using a cross-platform, internationalization-friendly
- * JSON description.
- * @param {!Object} json Structured data describing the block.
- */
-Block.prototype.jsonInit = function(json) {
-  const warningPrefix = json['type'] ? 'Block "' + json['type'] + '": ' : '';
-
-  // Validate inputs.
-  if (json['output'] && json['previousStatement']) {
-    throw Error(
-        warningPrefix +
-        'Must not have both an output and a previousStatement.');
-  }
 
-  // Set basic properties of block.
-  // Makes styles backward compatible with old way of defining hat style.
-  if (json['style'] && json['style'].hat) {
-    this.hat = json['style'].hat;
-    // Must set to null so it doesn't error when checking for style and colour.
-    json['style'] = null;
-  }
+  /**
+   * Inserts args in place of numerical tokens. String args are converted to
+   * JSON that defines a label field. If necessary an extra dummy input is added
+   * to the end of the elements.
+   * @param {!Array<!string|number>} tokens The tokens to interpolate
+   * @param {!Array<!Object|string>} args The arguments to insert.
+   * @param {string|undefined} lastDummyAlign The alignment the added dummy
+   *     input should have, if we are required to add one.
+   * @return {!Array<!Object>} The JSON definitions of field and inputs to add
+   *     to the block.
+   * @private
+   */
+  interpolateArguments_(tokens, args, lastDummyAlign) {
+    const elements = [];
+    for (let i = 0; i < tokens.length; i++) {
+      let element = tokens[i];
+      if (typeof element === 'number') {
+        element = args[element - 1];
+      }
+      // Args can be strings, which is why this isn't elseif.
+      if (typeof element === 'string') {
+        element = this.stringToFieldJson_(element);
+        if (!element) {
+          continue;
+        }
+      }
+      elements.push(element);
+    }
 
-  if (json['style'] && json['colour']) {
-    throw Error(warningPrefix + 'Must not have both a colour and a style.');
-  } else if (json['style']) {
-    this.jsonInitStyle_(json, warningPrefix);
-  } else {
-    this.jsonInitColour_(json, warningPrefix);
-  }
+    const length = elements.length;
+    if (length && !this.isInputKeyword_(elements[length - 1]['type'])) {
+      const dummyInput = {'type': 'input_dummy'};
+      if (lastDummyAlign) {
+        dummyInput['align'] = lastDummyAlign;
+      }
+      elements.push(dummyInput);
+    }
 
-  // Interpolate the message blocks.
-  let i = 0;
-  while (json['message' + i] !== undefined) {
-    this.interpolate_(
-        json['message' + i], json['args' + i] || [], json['lastDummyAlign' + i],
-        warningPrefix);
-    i++;
+    return elements;
   }
 
-  if (json['inputsInline'] !== undefined) {
-    this.setInputsInline(json['inputsInline']);
-  }
-  // Set output and previous/next connections.
-  if (json['output'] !== undefined) {
-    this.setOutput(true, json['output']);
-  }
-  if (json['outputShape'] !== undefined) {
-    this.setOutputShape(json['outputShape']);
-  }
-  if (json['previousStatement'] !== undefined) {
-    this.setPreviousStatement(true, json['previousStatement']);
-  }
-  if (json['nextStatement'] !== undefined) {
-    this.setNextStatement(true, json['nextStatement']);
-  }
-  if (json['tooltip'] !== undefined) {
-    const rawValue = json['tooltip'];
-    const localizedText = parsing.replaceMessageReferences(rawValue);
-    this.setTooltip(localizedText);
-  }
-  if (json['enableContextMenu'] !== undefined) {
-    this.contextMenu = !!json['enableContextMenu'];
-  }
-  if (json['suppressPrefixSuffix'] !== undefined) {
-    this.suppressPrefixSuffix = !!json['suppressPrefixSuffix'];
-  }
-  if (json['helpUrl'] !== undefined) {
-    const rawValue = json['helpUrl'];
-    const localizedValue = parsing.replaceMessageReferences(rawValue);
-    this.setHelpUrl(localizedValue);
-  }
-  if (typeof json['extensions'] === 'string') {
-    console.warn(
-        warningPrefix + 'JSON attribute \'extensions\' should be an array of' +
-        ' strings. Found raw string in JSON for \'' + json['type'] +
-        '\' block.');
-    json['extensions'] = [json['extensions']];  // Correct and continue.
+  /**
+   * Creates a field from the JSON definition of a field. If a field with the
+   * given type cannot be found, this attempts to create a different field using
+   * the 'alt' property of the JSON definition (if it exists).
+   * @param {{alt:(string|undefined)}} element The element to try to turn into a
+   *     field.
+   * @return {?Field} The field defined by the JSON, or null if one
+   *     couldn't be created.
+   * @private
+   */
+  fieldFromJson_(element) {
+    const field = fieldRegistry.fromJson(element);
+    if (!field && element['alt']) {
+      if (typeof element['alt'] === 'string') {
+        const json = this.stringToFieldJson_(element['alt']);
+        return json ? this.fieldFromJson_(json) : null;
+      }
+      return this.fieldFromJson_(element['alt']);
+    }
+    return field;
   }
 
-  // Add the mutator to the block.
-  if (json['mutator'] !== undefined) {
-    Extensions.apply(json['mutator'], this, true);
-  }
+  /**
+   * Creates an input from the JSON definition of an input. Sets the input's
+   * check and alignment if they are provided.
+   * @param {!Object} element The JSON to turn into an input.
+   * @param {string} warningPrefix The prefix to add to warnings to help the
+   *     developer debug.
+   * @return {?Input} The input that has been created, or null if one
+   *     could not be created for some reason (should never happen).
+   * @private
+   */
+  inputFromJson_(element, warningPrefix) {
+    const alignmentLookup = {
+      'LEFT': Align.LEFT,
+      'RIGHT': Align.RIGHT,
+      'CENTRE': Align.CENTRE,
+      'CENTER': Align.CENTRE,
+    };
 
-  const extensionNames = json['extensions'];
-  if (Array.isArray(extensionNames)) {
-    for (let j = 0; j < extensionNames.length; j++) {
-      Extensions.apply(extensionNames[j], this, false);
+    let input = null;
+    switch (element['type']) {
+      case 'input_value':
+        input = this.appendValueInput(element['name']);
+        break;
+      case 'input_statement':
+        input = this.appendStatementInput(element['name']);
+        break;
+      case 'input_dummy':
+        input = this.appendDummyInput(element['name']);
+        break;
+    }
+    // Should never be hit because of interpolate_'s checks, but just in case.
+    if (!input) {
+      return null;
     }
-  }
-};
 
-/**
- * Initialize the colour of this block from the JSON description.
- * @param {!Object} json Structured data describing the block.
- * @param {string} warningPrefix Warning prefix string identifying block.
- * @private
- */
-Block.prototype.jsonInitColour_ = function(json, warningPrefix) {
-  if ('colour' in json) {
-    if (json['colour'] === undefined) {
-      console.warn(warningPrefix + 'Undefined colour value.');
-    } else {
-      const rawValue = json['colour'];
-      try {
-        this.setColour(rawValue);
-      } catch (e) {
-        console.warn(warningPrefix + 'Illegal colour value: ', rawValue);
+    if (element['check']) {
+      input.setCheck(element['check']);
+    }
+    if (element['align']) {
+      const alignment = alignmentLookup[element['align'].toUpperCase()];
+      if (alignment === undefined) {
+        console.warn(warningPrefix + 'Illegal align value: ', element['align']);
+      } else {
+        input.setAlign(alignment);
       }
     }
+    return input;
   }
-};
 
-/**
- * Initialize the style of this block from the JSON description.
- * @param {!Object} json Structured data describing the block.
- * @param {string} warningPrefix Warning prefix string identifying block.
- * @private
- */
-Block.prototype.jsonInitStyle_ = function(json, warningPrefix) {
-  const blockStyleName = json['style'];
-  try {
-    this.setStyle(blockStyleName);
-  } catch (styleError) {
-    console.warn(warningPrefix + 'Style does not exist: ', blockStyleName);
+  /**
+   * Returns true if the given string matches one of the input keywords.
+   * @param {string} str The string to check.
+   * @return {boolean} True if the given string matches one of the input
+   *     keywords, false otherwise.
+   * @private
+   */
+  isInputKeyword_(str) {
+    return str === 'input_value' || str === 'input_statement' ||
+        str === 'input_dummy';
   }
-};
 
-/**
- * Add key/values from mixinObj to this block object. By default, this method
- * will check that the keys in mixinObj will not overwrite existing values in
- * the block, including prototype values. This provides some insurance against
- * mixin / extension incompatibilities with future block features. This check
- * can be disabled by passing true as the second argument.
- * @param {!Object} mixinObj The key/values pairs to add to this block object.
- * @param {boolean=} opt_disableCheck Option flag to disable overwrite checks.
- */
-Block.prototype.mixin = function(mixinObj, opt_disableCheck) {
-  if (opt_disableCheck !== undefined && typeof opt_disableCheck !== 'boolean') {
-    throw Error('opt_disableCheck must be a boolean if provided');
-  }
-  if (!opt_disableCheck) {
-    const overwrites = [];
-    for (const key in mixinObj) {
-      if (this[key] !== undefined) {
-        overwrites.push(key);
-      }
+  /**
+   * Turns a string into the JSON definition of a label field. If the string
+   * becomes an empty string when trimmed, this returns null.
+   * @param {string} str String to turn into the JSON definition of a label
+   *     field.
+   * @return {?{text: string, type: string}} The JSON definition or null.
+   * @private
+   */
+  stringToFieldJson_(str) {
+    str = str.trim();
+    if (str) {
+      return {
+        'type': 'field_label',
+        'text': str,
+      };
     }
-    if (overwrites.length) {
-      throw Error(
-          'Mixin will overwrite block members: ' + JSON.stringify(overwrites));
+    return null;
+  }
+
+  /**
+   * Add a value input, statement input or local variable to this block.
+   * @param {number} type One of Blockly.inputTypes.
+   * @param {string} name Language-neutral identifier which may used to find
+   *     this input again.  Should be unique to this block.
+   * @return {!Input} The input object created.
+   * @protected
+   */
+  appendInput_(type, name) {
+    let connection = null;
+    if (type === inputTypes.VALUE || type === inputTypes.STATEMENT) {
+      connection = this.makeConnection_(type);
     }
+    if (type === inputTypes.STATEMENT) {
+      this.statementInputCount++;
+    }
+    const input = new Input(type, name, this, connection);
+    // Append input to list.
+    this.inputList.push(input);
+    return input;
   }
-  object.mixin(this, mixinObj);
-};
 
-/**
- * Interpolate a message description onto the block.
- * @param {string} message Text contains interpolation tokens (%1, %2, ...)
- *     that match with fields or inputs defined in the args array.
- * @param {!Array} args Array of arguments to be interpolated.
- * @param {string|undefined} lastDummyAlign If a dummy input is added at the
- *     end, how should it be aligned?
- * @param {string} warningPrefix Warning prefix string identifying block.
- * @private
- */
-Block.prototype.interpolate_ = function(
-    message, args, lastDummyAlign, warningPrefix) {
-  const tokens = parsing.tokenizeInterpolation(message);
-  this.validateTokens_(tokens, args.length);
-  const elements = this.interpolateArguments_(tokens, args, lastDummyAlign);
-
-  // An array of [field, fieldName] tuples.
-  const fieldStack = [];
-  for (let i = 0, element; (element = elements[i]); i++) {
-    if (this.isInputKeyword_(element['type'])) {
-      const input = this.inputFromJson_(element, warningPrefix);
-      // Should never be null, but just in case.
-      if (input) {
-        for (let j = 0, tuple; (tuple = fieldStack[j]); j++) {
-          input.appendField(tuple[0], tuple[1]);
+  /**
+   * Move a named input to a different location on this block.
+   * @param {string} name The name of the input to move.
+   * @param {?string} refName Name of input that should be after the moved
+   *     input,
+   *   or null to be the input at the end.
+   */
+  moveInputBefore(name, refName) {
+    if (name === refName) {
+      return;
+    }
+    // Find both inputs.
+    let inputIndex = -1;
+    let refIndex = refName ? -1 : this.inputList.length;
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      if (input.name === name) {
+        inputIndex = i;
+        if (refIndex !== -1) {
+          break;
+        }
+      } else if (refName && input.name === refName) {
+        refIndex = i;
+        if (inputIndex !== -1) {
+          break;
         }
-        fieldStack.length = 0;
-      }
-    } else {
-      // All other types, including ones starting with 'input_' get routed here.
-      const field = this.fieldFromJson_(element);
-      if (field) {
-        fieldStack.push([field, element['name']]);
       }
     }
+    if (inputIndex === -1) {
+      throw Error('Named input "' + name + '" not found.');
+    }
+    if (refIndex === -1) {
+      throw Error('Reference input "' + refName + '" not found.');
+    }
+    this.moveNumberedInputBefore(inputIndex, refIndex);
   }
-};
 
-/**
- * Validates that the tokens are within the correct bounds, with no duplicates,
- * and that all of the arguments are referred to. Throws errors if any of these
- * things are not true.
- * @param {!Array<string|number>} tokens An array of tokens to validate
- * @param {number} argsCount The number of args that need to be referred to.
- * @private
- */
-Block.prototype.validateTokens_ = function(tokens, argsCount) {
-  const visitedArgsHash = [];
-  let visitedArgsCount = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (typeof token !== 'number') {
-      continue;
-    }
-    if (token < 1 || token > argsCount) {
-      throw Error(
-          'Block "' + this.type + '": ' +
-          'Message index %' + token + ' out of range.');
+  /**
+   * Move a numbered input to a different location on this block.
+   * @param {number} inputIndex Index of the input to move.
+   * @param {number} refIndex Index of input that should be after the moved
+   *     input.
+   */
+  moveNumberedInputBefore(inputIndex, refIndex) {
+    // Validate arguments.
+    if (inputIndex === refIndex) {
+      throw Error('Can\'t move input to itself.');
     }
-    if (visitedArgsHash[token]) {
-      throw Error(
-          'Block "' + this.type + '": ' +
-          'Message index %' + token + ' duplicated.');
+    if (inputIndex >= this.inputList.length) {
+      throw RangeError('Input index ' + inputIndex + ' out of bounds.');
     }
-    visitedArgsHash[token] = true;
-    visitedArgsCount++;
-  }
-  if (visitedArgsCount !== argsCount) {
-    throw Error(
-        'Block "' + this.type + '": ' +
-        'Message does not reference all ' + argsCount + ' arg(s).');
+    if (refIndex > this.inputList.length) {
+      throw RangeError('Reference input ' + refIndex + ' out of bounds.');
+    }
+    // Remove input.
+    const input = this.inputList[inputIndex];
+    this.inputList.splice(inputIndex, 1);
+    if (inputIndex < refIndex) {
+      refIndex--;
+    }
+    // Reinsert input.
+    this.inputList.splice(refIndex, 0, input);
   }
-};
 
-/**
- * Inserts args in place of numerical tokens. String args are converted to JSON
- * that defines a label field. If necessary an extra dummy input is added to
- * the end of the elements.
- * @param {!Array<!string|number>} tokens The tokens to interpolate
- * @param {!Array<!Object|string>} args The arguments to insert.
- * @param {string|undefined} lastDummyAlign The alignment the added dummy input
- *     should have, if we are required to add one.
- * @return {!Array<!Object>} The JSON definitions of field and inputs to add
- *     to the block.
- * @private
- */
-Block.prototype.interpolateArguments_ = function(tokens, args, lastDummyAlign) {
-  const elements = [];
-  for (let i = 0; i < tokens.length; i++) {
-    let element = tokens[i];
-    if (typeof element === 'number') {
-      element = args[element - 1];
-    }
-    // Args can be strings, which is why this isn't elseif.
-    if (typeof element === 'string') {
-      element = this.stringToFieldJson_(element);
-      if (!element) {
-        continue;
+  /**
+   * Remove an input from this block.
+   * @param {string} name The name of the input.
+   * @param {boolean=} opt_quiet True to prevent an error if input is not
+   *     present.
+   * @return {boolean} True if operation succeeds, false if input is not present
+   *     and opt_quiet is true.
+   * @throws {Error} if the input is not present and opt_quiet is not true.
+   */
+  removeInput(name, opt_quiet) {
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      if (input.name === name) {
+        if (input.type === inputTypes.STATEMENT) {
+          this.statementInputCount--;
+        }
+        input.dispose();
+        this.inputList.splice(i, 1);
+        return true;
       }
     }
-    elements.push(element);
-  }
-
-  const length = elements.length;
-  if (length && !this.isInputKeyword_(elements[length - 1]['type'])) {
-    const dummyInput = {'type': 'input_dummy'};
-    if (lastDummyAlign) {
-      dummyInput['align'] = lastDummyAlign;
+    if (opt_quiet) {
+      return false;
     }
-    elements.push(dummyInput);
+    throw Error('Input not found: ' + name);
   }
 
-  return elements;
-};
-
-/**
- * Creates a field from the JSON definition of a field. If a field with the
- * given type cannot be found, this attempts to create a different field using
- * the 'alt' property of the JSON definition (if it exists).
- * @param {{alt:(string|undefined)}} element The element to try to turn into a
- *     field.
- * @return {?Field} The field defined by the JSON, or null if one
- *     couldn't be created.
- * @private
- */
-Block.prototype.fieldFromJson_ = function(element) {
-  const field = fieldRegistry.fromJson(element);
-  if (!field && element['alt']) {
-    if (typeof element['alt'] === 'string') {
-      const json = this.stringToFieldJson_(element['alt']);
-      return json ? this.fieldFromJson_(json) : null;
+  /**
+   * Fetches the named input object.
+   * @param {string} name The name of the input.
+   * @return {?Input} The input object, or null if input does not exist.
+   */
+  getInput(name) {
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      if (input.name === name) {
+        return input;
+      }
     }
-    return this.fieldFromJson_(element['alt']);
+    // This input does not exist.
+    return null;
   }
-  return field;
-};
 
-/**
- * Creates an input from the JSON definition of an input. Sets the input's check
- * and alignment if they are provided.
- * @param {!Object} element The JSON to turn into an input.
- * @param {string} warningPrefix The prefix to add to warnings to help the
- *     developer debug.
- * @return {?Input} The input that has been created, or null if one
- *     could not be created for some reason (should never happen).
- * @private
- */
-Block.prototype.inputFromJson_ = function(element, warningPrefix) {
-  const alignmentLookup = {
-    'LEFT': Align.LEFT,
-    'RIGHT': Align.RIGHT,
-    'CENTRE': Align.CENTRE,
-    'CENTER': Align.CENTRE,
-  };
-
-  let input = null;
-  switch (element['type']) {
-    case 'input_value':
-      input = this.appendValueInput(element['name']);
-      break;
-    case 'input_statement':
-      input = this.appendStatementInput(element['name']);
-      break;
-    case 'input_dummy':
-      input = this.appendDummyInput(element['name']);
-      break;
-  }
-  // Should never be hit because of interpolate_'s checks, but just in case.
-  if (!input) {
-    return null;
+  /**
+   * Fetches the block attached to the named input.
+   * @param {string} name The name of the input.
+   * @return {?Block} The attached value block, or null if the input is
+   *     either disconnected or if the input does not exist.
+   */
+  getInputTargetBlock(name) {
+    const input = this.getInput(name);
+    return input && input.connection && input.connection.targetBlock();
   }
 
-  if (element['check']) {
-    input.setCheck(element['check']);
+  /**
+   * Returns the comment on this block (or null if there is no comment).
+   * @return {?string} Block's comment.
+   */
+  getCommentText() {
+    return this.commentModel.text;
   }
-  if (element['align']) {
-    const alignment = alignmentLookup[element['align'].toUpperCase()];
-    if (alignment === undefined) {
-      console.warn(warningPrefix + 'Illegal align value: ', element['align']);
-    } else {
-      input.setAlign(alignment);
+
+  /**
+   * Set this block's comment text.
+   * @param {?string} text The text, or null to delete.
+   */
+  setCommentText(text) {
+    if (this.commentModel.text === text) {
+      return;
     }
+    eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CHANGE))(
+        this, 'comment', null, this.commentModel.text, text));
+    this.commentModel.text = text;
+    this.comment = text;  // For backwards compatibility.
   }
-  return input;
-};
-
-/**
- * Returns true if the given string matches one of the input keywords.
- * @param {string} str The string to check.
- * @return {boolean} True if the given string matches one of the input keywords,
- *     false otherwise.
- * @private
- */
-Block.prototype.isInputKeyword_ = function(str) {
-  return str === 'input_value' || str === 'input_statement' ||
-      str === 'input_dummy';
-};
 
-/**
- * Turns a string into the JSON definition of a label field. If the string
- * becomes an empty string when trimmed, this returns null.
- * @param {string} str String to turn into the JSON definition of a label field.
- * @return {?{text: string, type: string}} The JSON definition or null.
- * @private
- */
-Block.prototype.stringToFieldJson_ = function(str) {
-  str = str.trim();
-  if (str) {
-    return {
-      'type': 'field_label',
-      'text': str,
-    };
+  /**
+   * Set this block's warning text.
+   * @param {?string} _text The text, or null to delete.
+   * @param {string=} _opt_id An optional ID for the warning text to be able to
+   *     maintain multiple warnings.
+   */
+  setWarningText(_text, _opt_id) {
+    // NOP.
   }
-  return null;
-};
 
-/**
- * Add a value input, statement input or local variable to this block.
- * @param {number} type One of Blockly.inputTypes.
- * @param {string} name Language-neutral identifier which may used to find this
- *     input again.  Should be unique to this block.
- * @return {!Input} The input object created.
- * @protected
- */
-Block.prototype.appendInput_ = function(type, name) {
-  let connection = null;
-  if (type === inputTypes.VALUE || type === inputTypes.STATEMENT) {
-    connection = this.makeConnection_(type);
+  /**
+   * Give this block a mutator dialog.
+   * @param {Mutator} _mutator A mutator dialog instance or null to
+   *     remove.
+   */
+  setMutator(_mutator) {
+    // NOP.
   }
-  if (type === inputTypes.STATEMENT) {
-    this.statementInputCount++;
+
+  /**
+   * Return the coordinates of the top-left corner of this block relative to the
+   * drawing surface's origin (0,0), in workspace units.
+   * @return {!Coordinate} Object with .x and .y properties.
+   */
+  getRelativeToSurfaceXY() {
+    return this.xy_;
   }
-  const input = new Input(type, name, this, connection);
-  // Append input to list.
-  this.inputList.push(input);
-  return input;
-};
 
-/**
- * Move a named input to a different location on this block.
- * @param {string} name The name of the input to move.
- * @param {?string} refName Name of input that should be after the moved input,
- *   or null to be the input at the end.
- */
-Block.prototype.moveInputBefore = function(name, refName) {
-  if (name === refName) {
-    return;
-  }
-  // Find both inputs.
-  let inputIndex = -1;
-  let refIndex = refName ? -1 : this.inputList.length;
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    if (input.name === name) {
-      inputIndex = i;
-      if (refIndex !== -1) {
-        break;
-      }
-    } else if (refName && input.name === refName) {
-      refIndex = i;
-      if (inputIndex !== -1) {
-        break;
-      }
+  /**
+   * Move a block by a relative offset.
+   * @param {number} dx Horizontal offset, in workspace units.
+   * @param {number} dy Vertical offset, in workspace units.
+   */
+  moveBy(dx, dy) {
+    if (this.parentBlock_) {
+      throw Error('Block has parent.');
     }
+    const event = /** @type {!BlockMove} */ (
+        new (eventUtils.get(eventUtils.BLOCK_MOVE))(this));
+    this.xy_.translate(dx, dy);
+    event.recordNew();
+    eventUtils.fire(event);
   }
-  if (inputIndex === -1) {
-    throw Error('Named input "' + name + '" not found.');
-  }
-  if (refIndex === -1) {
-    throw Error('Reference input "' + refName + '" not found.');
-  }
-  this.moveNumberedInputBefore(inputIndex, refIndex);
-};
 
-/**
- * Move a numbered input to a different location on this block.
- * @param {number} inputIndex Index of the input to move.
- * @param {number} refIndex Index of input that should be after the moved input.
- */
-Block.prototype.moveNumberedInputBefore = function(inputIndex, refIndex) {
-  // Validate arguments.
-  if (inputIndex === refIndex) {
-    throw Error('Can\'t move input to itself.');
-  }
-  if (inputIndex >= this.inputList.length) {
-    throw RangeError('Input index ' + inputIndex + ' out of bounds.');
-  }
-  if (refIndex > this.inputList.length) {
-    throw RangeError('Reference input ' + refIndex + ' out of bounds.');
-  }
-  // Remove input.
-  const input = this.inputList[inputIndex];
-  this.inputList.splice(inputIndex, 1);
-  if (inputIndex < refIndex) {
-    refIndex--;
+  /**
+   * Create a connection of the specified type.
+   * @param {number} type The type of the connection to create.
+   * @return {!Connection} A new connection of the specified type.
+   * @protected
+   */
+  makeConnection_(type) {
+    return new Connection(this, type);
   }
-  // Reinsert input.
-  this.inputList.splice(refIndex, 0, input);
-};
 
-/**
- * Remove an input from this block.
- * @param {string} name The name of the input.
- * @param {boolean=} opt_quiet True to prevent an error if input is not present.
- * @return {boolean} True if operation succeeds, false if input is not present
- *     and opt_quiet is true.
- * @throws {Error} if the input is not present and opt_quiet is not true.
- */
-Block.prototype.removeInput = function(name, opt_quiet) {
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    if (input.name === name) {
-      if (input.type === inputTypes.STATEMENT) {
-        this.statementInputCount--;
-      }
-      input.dispose();
-      this.inputList.splice(i, 1);
-      return true;
+  /**
+   * Recursively checks whether all statement and value inputs are filled with
+   * blocks. Also checks all following statement blocks in this stack.
+   * @param {boolean=} opt_shadowBlocksAreFilled An optional argument
+   *     controlling whether shadow blocks are counted as filled. Defaults to
+   *     true.
+   * @return {boolean} True if all inputs are filled, false otherwise.
+   */
+  allInputsFilled(opt_shadowBlocksAreFilled) {
+    // Account for the shadow block filledness toggle.
+    if (opt_shadowBlocksAreFilled === undefined) {
+      opt_shadowBlocksAreFilled = true;
     }
-  }
-  if (opt_quiet) {
-    return false;
-  }
-  throw Error('Input not found: ' + name);
-};
-
-/**
- * Fetches the named input object.
- * @param {string} name The name of the input.
- * @return {?Input} The input object, or null if input does not exist.
- */
-Block.prototype.getInput = function(name) {
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    if (input.name === name) {
-      return input;
+    if (!opt_shadowBlocksAreFilled && this.isShadow()) {
+      return false;
     }
-  }
-  // This input does not exist.
-  return null;
-};
 
-/**
- * Fetches the block attached to the named input.
- * @param {string} name The name of the input.
- * @return {?Block} The attached value block, or null if the input is
- *     either disconnected or if the input does not exist.
- */
-Block.prototype.getInputTargetBlock = function(name) {
-  const input = this.getInput(name);
-  return input && input.connection && input.connection.targetBlock();
-};
+    // Recursively check each input block of the current block.
+    for (let i = 0, input; (input = this.inputList[i]); i++) {
+      if (!input.connection) {
+        continue;
+      }
+      const target = input.connection.targetBlock();
+      if (!target || !target.allInputsFilled(opt_shadowBlocksAreFilled)) {
+        return false;
+      }
+    }
 
-/**
- * Returns the comment on this block (or null if there is no comment).
- * @return {?string} Block's comment.
- */
-Block.prototype.getCommentText = function() {
-  return this.commentModel.text;
-};
+    // Recursively check the next block after the current block.
+    const next = this.getNextBlock();
+    if (next) {
+      return next.allInputsFilled(opt_shadowBlocksAreFilled);
+    }
 
-/**
- * Set this block's comment text.
- * @param {?string} text The text, or null to delete.
- */
-Block.prototype.setCommentText = function(text) {
-  if (this.commentModel.text === text) {
-    return;
+    return true;
   }
-  eventUtils.fire(new (eventUtils.get(eventUtils.BLOCK_CHANGE))(
-      this, 'comment', null, this.commentModel.text, text));
-  this.commentModel.text = text;
-  this.comment = text;  // For backwards compatibility.
-};
-
-/**
- * Set this block's warning text.
- * @param {?string} _text The text, or null to delete.
- * @param {string=} _opt_id An optional ID for the warning text to be able to
- *     maintain multiple warnings.
- */
-Block.prototype.setWarningText = function(_text, _opt_id) {
-  // NOP.
-};
-
-/**
- * Give this block a mutator dialog.
- * @param {Mutator} _mutator A mutator dialog instance or null to
- *     remove.
- */
-Block.prototype.setMutator = function(_mutator) {
-  // NOP.
-};
 
-/**
- * Return the coordinates of the top-left corner of this block relative to the
- * drawing surface's origin (0,0), in workspace units.
- * @return {!Coordinate} Object with .x and .y properties.
- */
-Block.prototype.getRelativeToSurfaceXY = function() {
-  return this.xy_;
-};
+  /**
+   * This method returns a string describing this Block in developer terms (type
+   * name and ID; English only).
+   *
+   * Intended to on be used in console logs and errors. If you need a string
+   * that uses the user's native language (including block text, field values,
+   * and child blocks), use [toString()]{@link Block#toString}.
+   * @return {string} The description.
+   */
+  toDevString() {
+    let msg = this.type ? '"' + this.type + '" block' : 'Block';
+    if (this.id) {
+      msg += ' (id="' + this.id + '")';
+    }
+    return msg;
+  }
+}
 
 /**
- * Move a block by a relative offset.
- * @param {number} dx Horizontal offset, in workspace units.
- * @param {number} dy Vertical offset, in workspace units.
+ * @typedef {{
+ *            text:?string,
+ *            pinned:boolean,
+ *            size:Size
+ *          }}
  */
-Block.prototype.moveBy = function(dx, dy) {
-  if (this.parentBlock_) {
-    throw Error('Block has parent.');
-  }
-  const event = new (eventUtils.get(eventUtils.BLOCK_MOVE))(this);
-  this.xy_.translate(dx, dy);
-  event.recordNew();
-  eventUtils.fire(event);
-};
+Block.CommentModel;
 
 /**
- * Create a connection of the specified type.
- * @param {number} type The type of the connection to create.
- * @return {!Connection} A new connection of the specified type.
- * @protected
+ * An optional callback method to use whenever the block's parent workspace
+ * changes. This is usually only called from the constructor, the block type
+ * initializer function, or an extension initializer function.
+ * @type {undefined|?function(Abstract)}
  */
-Block.prototype.makeConnection_ = function(type) {
-  return new Connection(this, type);
-};
+Block.prototype.onchange;
 
 /**
- * Recursively checks whether all statement and value inputs are filled with
- * blocks. Also checks all following statement blocks in this stack.
- * @param {boolean=} opt_shadowBlocksAreFilled An optional argument controlling
- *     whether shadow blocks are counted as filled. Defaults to true.
- * @return {boolean} True if all inputs are filled, false otherwise.
+ * The language-neutral ID given to the collapsed input.
+ * @const {string}
  */
-Block.prototype.allInputsFilled = function(opt_shadowBlocksAreFilled) {
-  // Account for the shadow block filledness toggle.
-  if (opt_shadowBlocksAreFilled === undefined) {
-    opt_shadowBlocksAreFilled = true;
-  }
-  if (!opt_shadowBlocksAreFilled && this.isShadow()) {
-    return false;
-  }
-
-  // Recursively check each input block of the current block.
-  for (let i = 0, input; (input = this.inputList[i]); i++) {
-    if (!input.connection) {
-      continue;
-    }
-    const target = input.connection.targetBlock();
-    if (!target || !target.allInputsFilled(opt_shadowBlocksAreFilled)) {
-      return false;
-    }
-  }
-
-  // Recursively check the next block after the current block.
-  const next = this.getNextBlock();
-  if (next) {
-    return next.allInputsFilled(opt_shadowBlocksAreFilled);
-  }
-
-  return true;
-};
+Block.COLLAPSED_INPUT_NAME = constants.COLLAPSED_INPUT_NAME;
 
 /**
- * This method returns a string describing this Block in developer terms (type
- * name and ID; English only).
- *
- * Intended to on be used in console logs and errors. If you need a string that
- * uses the user's native language (including block text, field values, and
- * child blocks), use [toString()]{@link Block#toString}.
- * @return {string} The description.
+ * The language-neutral ID given to the collapsed field.
+ * @const {string}
  */
-Block.prototype.toDevString = function() {
-  let msg = this.type ? '"' + this.type + '" block' : 'Block';
-  if (this.id) {
-    msg += ' (id="' + this.id + '")';
-  }
-  return msg;
-};
+Block.COLLAPSED_FIELD_NAME = constants.COLLAPSED_FIELD_NAME;
 
 exports.Block = Block;