Migrate core/variables.js to goog.module syntax (#5321)

* Migrate core/variables.js to ES6 const/let * Migrate core/variables.js to goog.module * Migrate core/variables.js to named requires * clang-format core/variables.js * Add JSDoc and make testdeps function test-only * Fix return type for getTestDeps * Migrate to new style of exposing methods for mocking in core/variables.js
2026-01-13 20:07:08 +01:00 · 2021-08-12 09:55:38 -07:00
parent 8a48ba2642
commit c86c8f8e92
3 changed files with 189 additions and 219 deletions
--- a/core/variables.js
+++ b/core/variables.js
@@ -14,44 +14,36 @@
 * @name Blockly.Variables
 * @namespace
 */
-goog.provide('Blockly.Variables');
+goog.module('Blockly.Variables');
+goog.module.declareLegacyNamespace();

-goog.require('Blockly.Blocks');
-goog.require('Blockly.internalConstants');
-goog.require('Blockly.Msg');
-goog.require('Blockly.utils');
-goog.require('Blockly.utils.xml');
-goog.require('Blockly.VariableModel');
-goog.require('Blockly.Xml');
+const Blocks = goog.require('Blockly.Blocks');
+const Msg = goog.require('Blockly.Msg');
+const VariableModel = goog.require('Blockly.VariableModel');
+/* eslint-disable-next-line no-unused-vars */
+const Workspace = goog.requireType('Blockly.Workspace');
+const Xml = goog.require('Blockly.Xml');
+const utilsXml = goog.require('Blockly.utils.xml');

-goog.requireType('Blockly.Workspace');
-
-
-/**
- * Constant to separate variable names from procedures and generated functions
- * when running generators.
- * @deprecated Use Blockly.internalConstants.VARIABLE_CATEGORY_NAME
- */
-Blockly.Variables.NAME_TYPE = Blockly.internalConstants.VARIABLE_CATEGORY_NAME;

 /**
 * Find all user-created variables that are in use in the workspace.
 * For use by generators.
 * To get a list of all variables on a workspace, including unused variables,
 * call Workspace.getAllVariables.
- * @param {!Blockly.Workspace} ws The workspace to search for variables.
- * @return {!Array<!Blockly.VariableModel>} Array of variable models.
+ * @param {!Workspace} ws The workspace to search for variables.
+ * @return {!Array<!VariableModel>} Array of variable models.
 */
-Blockly.Variables.allUsedVarModels = function(ws) {
-  var blocks = ws.getAllBlocks(false);
-  var variableHash = Object.create(null);
+const allUsedVarModels = function(ws) {
+  const blocks = ws.getAllBlocks(false);
+  const variableHash = Object.create(null);
  // Iterate through every block and add each variable to the hash.
-  for (var i = 0; i < blocks.length; i++) {
-    var blockVariables = blocks[i].getVarModels();
+  for (let i = 0; i < blocks.length; i++) {
+    const blockVariables = blocks[i].getVarModels();
    if (blockVariables) {
-      for (var j = 0; j < blockVariables.length; j++) {
-        var variable = blockVariables[j];
-        var id = variable.getId();
+      for (let j = 0; j < blockVariables.length; j++) {
+        const variable = blockVariables[j];
+        const id = variable.getId();
        if (id) {
          variableHash[id] = variable;
        }
@@ -59,18 +51,18 @@ Blockly.Variables.allUsedVarModels = function(ws) {
    }
  }
  // Flatten the hash into a list.
-  var variableList = [];
-  for (var id in variableHash) {
+  const variableList = [];
+  for (const id in variableHash) {
    variableList.push(variableHash[id]);
  }
  return variableList;
 };
+exports.allUsedVarModels = allUsedVarModels;

 /**
- * @private
 * @type {Object<string,boolean>}
 */
-Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_ = {};
+const ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE = {};

 /**
 * Find all developer variables used by blocks in the workspace.
@@ -79,29 +71,28 @@ Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_ = {};
 * To declare developer variables, define the getDeveloperVariables function on
 * your block and return a list of variable names.
 * For use by generators.
- * @param {!Blockly.Workspace} workspace The workspace to search.
+ * @param {!Workspace} workspace The workspace to search.
 * @return {!Array<string>} A list of non-duplicated variable names.
 */
-Blockly.Variables.allDeveloperVariables = function(workspace) {
-  var blocks = workspace.getAllBlocks(false);
-  var variableHash = Object.create(null);
-  for (var i = 0, block; (block = blocks[i]); i++) {
-    var getDeveloperVariables = block.getDeveloperVariables;
+const allDeveloperVariables = function(workspace) {
+  const blocks = workspace.getAllBlocks(false);
+  const variableHash = Object.create(null);
+  for (let i = 0, block; (block = blocks[i]); i++) {
+    let getDeveloperVariables = block.getDeveloperVariables;
    if (!getDeveloperVariables && block.getDeveloperVars) {
      // August 2018: getDeveloperVars() was deprecated and renamed
      // getDeveloperVariables().
      getDeveloperVariables = block.getDeveloperVars;
-      if (!Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_[
-          block.type]) {
-        console.warn('Function getDeveloperVars() deprecated. Use ' +
+      if (!ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE[block.type]) {
+        console.warn(
+            'Function getDeveloperVars() deprecated. Use ' +
            'getDeveloperVariables() (block type \'' + block.type + '\')');
-        Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_[
-            block.type] = true;
+        ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE[block.type] = true;
      }
    }
    if (getDeveloperVariables) {
-      var devVars = getDeveloperVariables();
-      for (var j = 0; j < devVars.length; j++) {
+      const devVars = getDeveloperVariables();
+      for (let j = 0; j < devVars.length; j++) {
        variableHash[devVars[j]] = true;
      }
    }
@@ -110,57 +101,57 @@ Blockly.Variables.allDeveloperVariables = function(workspace) {
  // Flatten the hash into a list.
  return Object.keys(variableHash);
 };
+exports.allDeveloperVariables = allDeveloperVariables;

 /**
 * Construct the elements (blocks and button) required by the flyout for the
 * variable category.
- * @param {!Blockly.Workspace} workspace The workspace containing variables.
+ * @param {!Workspace} workspace The workspace containing variables.
 * @return {!Array<!Element>} Array of XML elements.
 */
-Blockly.Variables.flyoutCategory = function(workspace) {
-  var xmlList = [];
-  var button = document.createElement('button');
+const flyoutCategory = function(workspace) {
+  let xmlList = [];
+  const button = document.createElement('button');
  button.setAttribute('text', '%{BKY_NEW_VARIABLE}');
  button.setAttribute('callbackKey', 'CREATE_VARIABLE');

  workspace.registerButtonCallback('CREATE_VARIABLE', function(button) {
-    Blockly.Variables.createVariableButtonHandler(button.getTargetWorkspace());
+    createVariableButtonHandler(button.getTargetWorkspace());
  });

  xmlList.push(button);

-  var blockList = Blockly.Variables.flyoutCategoryBlocks(workspace);
+  const blockList = flyoutCategoryBlocks(workspace);
  xmlList = xmlList.concat(blockList);
  return xmlList;
 };
+exports.flyoutCategory = flyoutCategory;

 /**
 * Construct the blocks required by the flyout for the variable category.
- * @param {!Blockly.Workspace} workspace The workspace containing variables.
+ * @param {!Workspace} workspace The workspace containing variables.
 * @return {!Array<!Element>} Array of XML block elements.
 */
-Blockly.Variables.flyoutCategoryBlocks = function(workspace) {
-  var variableModelList = workspace.getVariablesOfType('');
+const flyoutCategoryBlocks = function(workspace) {
+  const variableModelList = workspace.getVariablesOfType('');

-  var xmlList = [];
+  const xmlList = [];
  if (variableModelList.length > 0) {
    // New variables are added to the end of the variableModelList.
-    var mostRecentVariable = variableModelList[variableModelList.length - 1];
-    if (Blockly.Blocks['variables_set']) {
-      var block = Blockly.utils.xml.createElement('block');
+    const mostRecentVariable = variableModelList[variableModelList.length - 1];
+    if (Blocks['variables_set']) {
+      const block = utilsXml.createElement('block');
      block.setAttribute('type', 'variables_set');
-      block.setAttribute('gap', Blockly.Blocks['math_change'] ? 8 : 24);
-      block.appendChild(
-          Blockly.Variables.generateVariableFieldDom(mostRecentVariable));
+      block.setAttribute('gap', Blocks['math_change'] ? 8 : 24);
+      block.appendChild(generateVariableFieldDom(mostRecentVariable));
      xmlList.push(block);
    }
-    if (Blockly.Blocks['math_change']) {
-      var block = Blockly.utils.xml.createElement('block');
+    if (Blocks['math_change']) {
+      const block = utilsXml.createElement('block');
      block.setAttribute('type', 'math_change');
-      block.setAttribute('gap', Blockly.Blocks['variables_get'] ? 20 : 8);
-      block.appendChild(
-          Blockly.Variables.generateVariableFieldDom(mostRecentVariable));
-      var value = Blockly.Xml.textToDom(
+      block.setAttribute('gap', Blocks['variables_get'] ? 20 : 8);
+      block.appendChild(generateVariableFieldDom(mostRecentVariable));
+      const value = Xml.textToDom(
          '<value name="DELTA">' +
          '<shadow type="math_number">' +
          '<field name="NUM">1</field>' +
@@ -170,35 +161,35 @@ Blockly.Variables.flyoutCategoryBlocks = function(workspace) {
      xmlList.push(block);
    }

-    if (Blockly.Blocks['variables_get']) {
-      variableModelList.sort(Blockly.VariableModel.compareByName);
-      for (var i = 0, variable; (variable = variableModelList[i]); i++) {
-        var block = Blockly.utils.xml.createElement('block');
+    if (Blocks['variables_get']) {
+      variableModelList.sort(VariableModel.compareByName);
+      for (let i = 0, variable; (variable = variableModelList[i]); i++) {
+        const block = utilsXml.createElement('block');
        block.setAttribute('type', 'variables_get');
        block.setAttribute('gap', 8);
-        block.appendChild(Blockly.Variables.generateVariableFieldDom(variable));
+        block.appendChild(generateVariableFieldDom(variable));
        xmlList.push(block);
      }
    }
  }
  return xmlList;
 };
+exports.flyoutCategoryBlocks = flyoutCategoryBlocks;

-Blockly.Variables.VAR_LETTER_OPTIONS = 'ijkmnopqrstuvwxyzabcdefgh';  // No 'l'.
+const VAR_LETTER_OPTIONS = 'ijkmnopqrstuvwxyzabcdefgh';  // No 'l'.
+exports.VAR_LETTER_OPTIONS = VAR_LETTER_OPTIONS;

 /**
 * Return a new variable name that is not yet being used. This will try to
 * generate single letter variable names in the range 'i' to 'z' to start with.
 * If no unique name is located it will try 'i' to 'z', 'a' to 'h',
 * then 'i2' to 'z2' etc.  Skip 'l'.
- * @param {!Blockly.Workspace} workspace The workspace to be unique in.
+ * @param {!Workspace} workspace The workspace to be unique in.
 * @return {string} New variable name.
 */
-Blockly.Variables.generateUniqueName = function(workspace) {
-  return Blockly.Variables.generateUniqueNameFromOptions(
-      Blockly.Variables.VAR_LETTER_OPTIONS.charAt(0),
-      workspace.getAllVariableNames()
-  );
+exports.generateUniqueName = function(workspace) {
+  return generateUniqueNameFromOptions(
+      VAR_LETTER_OPTIONS.charAt(0), workspace.getAllVariableNames());
 };

 /**
@@ -209,20 +200,20 @@ Blockly.Variables.generateUniqueName = function(workspace) {
 * @param {!Array<string>} usedNames A list of all of the used names.
 * @return {string} A unique name that is not present in the usedNames array.
 */
-Blockly.Variables.generateUniqueNameFromOptions = function(startChar, usedNames) {
+const generateUniqueNameFromOptions = function(startChar, usedNames) {
  if (!usedNames.length) {
    return startChar;
  }

-  var letters = Blockly.Variables.VAR_LETTER_OPTIONS;
-  var suffix = '';
-  var letterIndex = letters.indexOf(startChar);
-  var potName = startChar;
+  const letters = VAR_LETTER_OPTIONS;
+  let suffix = '';
+  let letterIndex = letters.indexOf(startChar);
+  let potName = startChar;

  // eslint-disable-next-line no-constant-condition
  while (true) {
-    var inUse = false;
-    for (var i = 0; i < usedNames.length; i++) {
+    let inUse = false;
+    for (let i = 0; i < usedNames.length; i++) {
      if (usedNames[i].toLowerCase() == potName) {
        inUse = true;
        break;
@@ -241,6 +232,7 @@ Blockly.Variables.generateUniqueNameFromOptions = function(startChar, usedNames)
    potName = letters.charAt(letterIndex) + suffix;
  }
 };
+exports.generateUniqueNameFromOptions = generateUniqueNameFromOptions;

 /**
 * Handles "Create Variable" button in the default variables toolbox category.
@@ -251,7 +243,7 @@ Blockly.Variables.generateUniqueNameFromOptions = function(startChar, usedNames)
 * types and after-creation processing. More complex customization (e.g.,
 * prompting for variable type) is beyond the scope of this function.
 *
- * @param {!Blockly.Workspace} workspace The workspace on which to create the
+ * @param {!Workspace} workspace The workspace on which to create the
 *     variable.
 * @param {function(?string=)=} opt_callback A callback. It will be passed an
 *     acceptable new variable name, or null if change is to be aborted (cancel
@@ -259,107 +251,88 @@ Blockly.Variables.generateUniqueNameFromOptions = function(startChar, usedNames)
 * @param {string=} opt_type The type of the variable like 'int', 'string', or
 *     ''. This will default to '', which is a specific type.
 */
-Blockly.Variables.createVariableButtonHandler = function(
+const createVariableButtonHandler = function(
    workspace, opt_callback, opt_type) {
-  var type = opt_type || '';
+  const type = opt_type || '';
  // This function needs to be named so it can be called recursively.
-  var promptAndCheckWithAlert = function(defaultName) {
-    Blockly.Variables.promptName(Blockly.Msg['NEW_VARIABLE_TITLE'], defaultName,
-        function(text) {
-          if (text) {
-            var existing =
-                Blockly.Variables.nameUsedWithAnyType(text, workspace);
-            if (existing) {
-              if (existing.type == type) {
-                var msg = Blockly.Msg['VARIABLE_ALREADY_EXISTS'].replace(
-                    '%1', existing.name);
-              } else {
-                var msg =
-                    Blockly.Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE'];
-                msg = msg.replace('%1', existing.name).replace('%2', existing.type);
-              }
-              Blockly.alert(msg,
-                  function() {
-                    promptAndCheckWithAlert(text);  // Recurse
-                  });
-            } else {
-              // No conflict
-              workspace.createVariable(text, type);
-              if (opt_callback) {
-                opt_callback(text);
-              }
-            }
+  const promptAndCheckWithAlert = function(defaultName) {
+    promptName(Msg['NEW_VARIABLE_TITLE'], defaultName, function(text) {
+      if (text) {
+        const existing = nameUsedWithAnyType(text, workspace);
+        if (existing) {
+          let msg;
+          if (existing.type == type) {
+            msg = Msg['VARIABLE_ALREADY_EXISTS'].replace('%1', existing.name);
          } else {
-            // User canceled prompt.
-            if (opt_callback) {
-              opt_callback(null);
-            }
+            msg = Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE'];
+            msg = msg.replace('%1', existing.name).replace('%2', existing.type);
          }
-        });
+          Blockly.alert(msg, function() {
+            promptAndCheckWithAlert(text);  // Recurse
+          });
+        } else {
+          // No conflict
+          workspace.createVariable(text, type);
+          if (opt_callback) {
+            opt_callback(text);
+          }
+        }
+      } else {
+        // User canceled prompt.
+        if (opt_callback) {
+          opt_callback(null);
+        }
+      }
+    });
  };
  promptAndCheckWithAlert('');
 };
-
-/**
- * Original name of Blockly.Variables.createVariableButtonHandler(..).
- * @deprecated Use Blockly.Variables.createVariableButtonHandler(..).
- *
- * @param {!Blockly.Workspace} workspace The workspace on which to create the
- *     variable.
- * @param {function(?string=)=} opt_callback A callback. It will be passed an
- *     acceptable new variable name, or null if change is to be aborted (cancel
- *     button), or undefined if an existing variable was chosen.
- * @param {string=} opt_type The type of the variable like 'int', 'string', or
- *     ''. This will default to '', which is a specific type.
- */
-Blockly.Variables.createVariable =
-    Blockly.Variables.createVariableButtonHandler;
+exports.createVariableButtonHandler = createVariableButtonHandler;

 /**
 * Opens a prompt that allows the user to enter a new name for a variable.
 * Triggers a rename if the new name is valid. Or re-prompts if there is a
 * collision.
- * @param {!Blockly.Workspace} workspace The workspace on which to rename the
+ * @param {!Workspace} workspace The workspace on which to rename the
 *     variable.
- * @param {!Blockly.VariableModel} variable Variable to rename.
+ * @param {!VariableModel} variable Variable to rename.
 * @param {function(?string=)=} opt_callback A callback. It will
 *     be passed an acceptable new variable name, or null if change is to be
 *     aborted (cancel button), or undefined if an existing variable was chosen.
 */
-Blockly.Variables.renameVariable = function(workspace, variable, opt_callback) {
+const renameVariable = function(workspace, variable, opt_callback) {
  // This function needs to be named so it can be called recursively.
-  var promptAndCheckWithAlert = function(defaultName) {
-    var promptText =
-        Blockly.Msg['RENAME_VARIABLE_TITLE'].replace('%1', variable.name);
-    Blockly.Variables.promptName(promptText, defaultName,
-        function(newName) {
-          if (newName) {
-            var existing = Blockly.Variables.nameUsedWithOtherType_(newName,
-                variable.type, workspace);
-            if (existing) {
-              var msg = Blockly.Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE']
-                  .replace('%1', existing.name)
-                  .replace('%2', existing.type);
-              Blockly.alert(msg,
-                  function() {
-                    promptAndCheckWithAlert(newName);  // Recurse
-                  });
-            } else {
-              workspace.renameVariableById(variable.getId(), newName);
-              if (opt_callback) {
-                opt_callback(newName);
-              }
-            }
-          } else {
-            // User canceled prompt.
-            if (opt_callback) {
-              opt_callback(null);
-            }
+  const promptAndCheckWithAlert = function(defaultName) {
+    const promptText =
+        Msg['RENAME_VARIABLE_TITLE'].replace('%1', variable.name);
+    promptName(promptText, defaultName, function(newName) {
+      if (newName) {
+        const existing =
+            nameUsedWithOtherType(newName, variable.type, workspace);
+        if (existing) {
+          const msg = Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE']
+                          .replace('%1', existing.name)
+                          .replace('%2', existing.type);
+          Blockly.alert(msg, function() {
+            promptAndCheckWithAlert(newName);  // Recurse
+          });
+        } else {
+          workspace.renameVariableById(variable.getId(), newName);
+          if (opt_callback) {
+            opt_callback(newName);
          }
-        });
+        }
+      } else {
+        // User canceled prompt.
+        if (opt_callback) {
+          opt_callback(null);
+        }
+      }
+    });
  };
  promptAndCheckWithAlert('');
 };
+exports.renameVariable = renameVariable;

 /**
 * Prompt the user for a new variable name.
@@ -368,14 +341,13 @@ Blockly.Variables.renameVariable = function(workspace, variable, opt_callback) {
 * @param {function(?string)} callback A callback. It will return the new
 *     variable name, or null if the user picked something illegal.
 */
-Blockly.Variables.promptName = function(promptText, defaultText, callback) {
+const promptName = function(promptText, defaultText, callback) {
  Blockly.prompt(promptText, defaultText, function(newVar) {
    // Merge runs of whitespace.  Strip leading and trailing whitespace.
    // Beyond this, all names are legal.
    if (newVar) {
      newVar = newVar.replace(/[\s\xa0]+/g, ' ').trim();
-      if (newVar == Blockly.Msg['RENAME_VARIABLE'] ||
-          newVar == Blockly.Msg['NEW_VARIABLE']) {
+      if (newVar == Msg['RENAME_VARIABLE'] || newVar == Msg['NEW_VARIABLE']) {
        // Ok, not ALL names are legal...
        newVar = null;
      }
@@ -383,23 +355,23 @@ Blockly.Variables.promptName = function(promptText, defaultText, callback) {
    callback(newVar);
  });
 };
+exports.promptName = promptName;

 /**
 * Check whether there exists a variable with the given name but a different
 * type.
 * @param {string} name The name to search for.
 * @param {string} type The type to exclude from the search.
- * @param {!Blockly.Workspace} workspace The workspace to search for the
+ * @param {!Workspace} workspace The workspace to search for the
 *     variable.
- * @return {?Blockly.VariableModel} The variable with the given name and a
+ * @return {?VariableModel} The variable with the given name and a
 *     different type, or null if none was found.
- * @private
 */
-Blockly.Variables.nameUsedWithOtherType_ = function(name, type, workspace) {
-  var allVariables = workspace.getVariableMap().getAllVariables();
+const nameUsedWithOtherType = function(name, type, workspace) {
+  const allVariables = workspace.getVariableMap().getAllVariables();

  name = name.toLowerCase();
-  for (var i = 0, variable; (variable = allVariables[i]); i++) {
+  for (let i = 0, variable; (variable = allVariables[i]); i++) {
    if (variable.name.toLowerCase() == name && variable.type != type) {
      return variable;
    }
@@ -410,84 +382,82 @@ Blockly.Variables.nameUsedWithOtherType_ = function(name, type, workspace) {
 /**
 * Check whether there exists a variable with the given name of any type.
 * @param {string} name The name to search for.
- * @param {!Blockly.Workspace} workspace The workspace to search for the
+ * @param {!Workspace} workspace The workspace to search for the
 *     variable.
- * @return {?Blockly.VariableModel} The variable with the given name,
+ * @return {?VariableModel} The variable with the given name,
 *     or null if none was found.
 */
-Blockly.Variables.nameUsedWithAnyType = function(name, workspace) {
-  var allVariables = workspace.getVariableMap().getAllVariables();
+const nameUsedWithAnyType = function(name, workspace) {
+  const allVariables = workspace.getVariableMap().getAllVariables();

  name = name.toLowerCase();
-  for (var i = 0, variable; (variable = allVariables[i]); i++) {
+  for (let i = 0, variable; (variable = allVariables[i]); i++) {
    if (variable.name.toLowerCase() == name) {
      return variable;
    }
  }
  return null;
 };
+exports.nameUsedWithAnyType = nameUsedWithAnyType;

 /**
 * Generate DOM objects representing a variable field.
- * @param {!Blockly.VariableModel} variableModel The variable model to
+ * @param {!VariableModel} variableModel The variable model to
 *     represent.
 * @return {?Element} The generated DOM.
- * @public
 */
-Blockly.Variables.generateVariableFieldDom = function(variableModel) {
+const generateVariableFieldDom = function(variableModel) {
  /* Generates the following XML:
   * <field name="VAR" id="goKTKmYJ8DhVHpruv" variabletype="int">foo</field>
   */
-  var field = Blockly.utils.xml.createElement('field');
+  const field = utilsXml.createElement('field');
  field.setAttribute('name', 'VAR');
  field.setAttribute('id', variableModel.getId());
  field.setAttribute('variabletype', variableModel.type);
-  var name = Blockly.utils.xml.createTextNode(variableModel.name);
+  const name = utilsXml.createTextNode(variableModel.name);
  field.appendChild(name);
  return field;
 };
+exports.generateVariableFieldDom = generateVariableFieldDom;

 /**
 * Helper function to look up or create a variable on the given workspace.
 * If no variable exists, creates and returns it.
- * @param {!Blockly.Workspace} workspace The workspace to search for the
+ * @param {!Workspace} workspace The workspace to search for the
 *     variable.  It may be a flyout workspace or main workspace.
 * @param {?string} id The ID to use to look up or create the variable, or null.
 * @param {string=} opt_name The string to use to look up or create the
 *     variable.
 * @param {string=} opt_type The type to use to look up or create the variable.
- * @return {!Blockly.VariableModel} The variable corresponding to the given ID
+ * @return {!VariableModel} The variable corresponding to the given ID
 *     or name + type combination.
 */
-Blockly.Variables.getOrCreateVariablePackage = function(workspace, id, opt_name,
-    opt_type) {
-  var variable = Blockly.Variables.getVariable(workspace, id, opt_name,
-      opt_type);
+const getOrCreateVariablePackage = function(workspace, id, opt_name, opt_type) {
+  let variable = getVariable(workspace, id, opt_name, opt_type);
  if (!variable) {
-    variable = Blockly.Variables.createVariable_(workspace, id, opt_name,
-        opt_type);
+    variable = createVariable(workspace, id, opt_name, opt_type);
  }
  return variable;
 };
+exports.getOrCreateVariablePackage = getOrCreateVariablePackage;

 /**
 * Look up  a variable on the given workspace.
 * Always looks in the main workspace before looking in the flyout workspace.
 * Always prefers lookup by ID to lookup by name + type.
- * @param {!Blockly.Workspace} workspace The workspace to search for the
+ * @param {!Workspace} workspace The workspace to search for the
 *     variable.  It may be a flyout workspace or main workspace.
 * @param {?string} id The ID to use to look up the variable, or null.
 * @param {string=} opt_name The string to use to look up the variable.
 *     Only used if lookup by ID fails.
 * @param {string=} opt_type The type to use to look up the variable.
 *     Only used if lookup by ID fails.
- * @return {?Blockly.VariableModel} The variable corresponding to the given ID
+ * @return {?VariableModel} The variable corresponding to the given ID
 *     or name + type combination, or null if not found.
- * @public
 */
-Blockly.Variables.getVariable = function(workspace, id, opt_name, opt_type) {
-  var potentialVariableMap = workspace.getPotentialVariableMap();
-  var variable = null;
+const getVariable = function(workspace, id, opt_name, opt_type) {
+  const potentialVariableMap = workspace.getPotentialVariableMap();
+  let variable = null;
  // Try to just get the variable, by ID if possible.
  if (id) {
    // Look in the real variable map before checking the potential variable map.
@@ -513,29 +483,28 @@ Blockly.Variables.getVariable = function(workspace, id, opt_name, opt_type) {
  }
  return variable;
 };
+exports.getVariable = getVariable;

 /**
 * Helper function to create a variable on the given workspace.
- * @param {!Blockly.Workspace} workspace The workspace in which to create the
+ * @param {!Workspace} workspace The workspace in which to create the
 * variable.  It may be a flyout workspace or main workspace.
 * @param {?string} id The ID to use to create the variable, or null.
 * @param {string=} opt_name The string to use to create the variable.
 * @param {string=} opt_type The type to use to create the variable.
- * @return {!Blockly.VariableModel} The variable corresponding to the given ID
+ * @return {!VariableModel} The variable corresponding to the given ID
 *     or name + type combination.
- * @private
 */
-Blockly.Variables.createVariable_ = function(workspace, id, opt_name,
-    opt_type) {
-  var potentialVariableMap = workspace.getPotentialVariableMap();
+const createVariable = function(workspace, id, opt_name, opt_type) {
+  const potentialVariableMap = workspace.getPotentialVariableMap();
  // Variables without names get uniquely named for this workspace.
  if (!opt_name) {
-    var ws = workspace.isFlyout ? workspace.targetWorkspace : workspace;
-    opt_name = Blockly.Variables.generateUniqueName(ws);
+    const ws = workspace.isFlyout ? workspace.targetWorkspace : workspace;
+    opt_name = exports.generateUniqueName(ws);
  }

  // Create a potential variable if in the flyout.
-  var variable = null;
+  let variable = null;
  if (potentialVariableMap) {
    variable = potentialVariableMap.createVariable(opt_name, opt_type, id);
  } else {  // In the main workspace, create a real variable.
@@ -548,20 +517,19 @@ Blockly.Variables.createVariable_ = function(workspace, id, opt_name,
 * Helper function to get the list of variables that have been added to the
 * workspace after adding a new block, using the given list of variables that
 * were in the workspace before the new block was added.
- * @param {!Blockly.Workspace} workspace The workspace to inspect.
- * @param {!Array<!Blockly.VariableModel>} originalVariables The array of
+ * @param {!Workspace} workspace The workspace to inspect.
+ * @param {!Array<!VariableModel>} originalVariables The array of
 *     variables that existed in the workspace before adding the new block.
- * @return {!Array<!Blockly.VariableModel>} The new array of variables that
+ * @return {!Array<!VariableModel>} The new array of variables that
 *     were freshly added to the workspace after creating the new block,
 *     or [] if no new variables were added to the workspace.
- * @package
 */
-Blockly.Variables.getAddedVariables = function(workspace, originalVariables) {
-  var allCurrentVariables = workspace.getAllVariables();
-  var addedVariables = [];
+const getAddedVariables = function(workspace, originalVariables) {
+  const allCurrentVariables = workspace.getAllVariables();
+  const addedVariables = [];
  if (originalVariables.length != allCurrentVariables.length) {
-    for (var i = 0; i < allCurrentVariables.length; i++) {
-      var variable = allCurrentVariables[i];
+    for (let i = 0; i < allCurrentVariables.length; i++) {
+      const variable = allCurrentVariables[i];
      // For any variable that is present in allCurrentVariables but not
      // present in originalVariables, add the variable to addedVariables.
      if (originalVariables.indexOf(variable) == -1) {
@@ -571,3 +539,5 @@ Blockly.Variables.getAddedVariables = function(workspace, originalVariables) {
  }
  return addedVariables;
 };
+/** @package */
+exports.getAddedVariables = getAddedVariables;
--- a/tests/deps.js
+++ b/tests/deps.js
@@ -213,7 +213,7 @@ goog.addDependency('../../core/utils/useragent.js', ['Blockly.utils.userAgent'],
 goog.addDependency('../../core/utils/xml.js', ['Blockly.utils.xml'], []);
 goog.addDependency('../../core/variable_map.js', ['Blockly.VariableMap'], ['Blockly.Events', 'Blockly.Events.VarDelete', 'Blockly.Events.VarRename', 'Blockly.Msg', 'Blockly.Names', 'Blockly.VariableModel', 'Blockly.utils', 'Blockly.utils.object'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/variable_model.js', ['Blockly.VariableModel'], ['Blockly.Events', 'Blockly.Events.VarCreate', 'Blockly.utils'], {'lang': 'es6', 'module': 'goog'});
-goog.addDependency('../../core/variables.js', ['Blockly.Variables'], ['Blockly.Blocks', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Xml', 'Blockly.internalConstants', 'Blockly.utils', 'Blockly.utils.xml']);
+goog.addDependency('../../core/variables.js', ['Blockly.Variables'], ['Blockly.Blocks', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Xml', 'Blockly.utils.xml'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/variables_dynamic.js', ['Blockly.VariablesDynamic'], ['Blockly.Blocks', 'Blockly.Msg', 'Blockly.VariableModel', 'Blockly.Variables', 'Blockly.utils.xml'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/warning.js', ['Blockly.Warning'], ['Blockly.Bubble', 'Blockly.Events', 'Blockly.Events.BubbleOpen', 'Blockly.Icon', 'Blockly.utils.Svg', 'Blockly.utils.dom', 'Blockly.utils.object'], {'lang': 'es6', 'module': 'goog'});
 goog.addDependency('../../core/widgetdiv.js', ['Blockly.WidgetDiv'], ['Blockly.common', 'Blockly.utils.dom']);
--- a/tests/mocha/field_variable_test.js
+++ b/tests/mocha/field_variable_test.js
@@ -11,8 +11,8 @@ suite('Variable Fields', function() {
    sharedTestSetup.call(this);
    this.workspace = new Blockly.Workspace();
    // Stub for default variable name.
-    sinon.stub(Blockly.Variables, 'generateUniqueName')
-        .returns(FAKE_VARIABLE_NAME);
+    sinon.stub(Blockly.Variables, 'generateUniqueName').returns(
+      FAKE_VARIABLE_NAME);
  });
  teardown(function() {
    sharedTestTeardown.call(this);