chore: Migrate core/ to Typescript, actually (#6299)

* fix: convert files to typescript

* fix: add alias for AnyDuringMigration so that tsc will run

* chore: format

* chore: enable ts for the clang-format workflow (#6233)

* chore: Restore @fileoverview comment locations (#6237)

* chore: add declareModuleId (#6238)

* fix: Revert comment change to app_controller.js (#6241)

* fix: Add missing import goog statements (#6240)

I've added the import statement immediately before the
goog.declareModuleId calls that depend on it.

There is an argument to be made that we should put the import
statement in their normal place amongst any other imports, and
move the declareModuleId statement to below the double blank
line below the imports, but as these are so tightly coupled,
replace the previous goog.module calls, and will both be deleted
at the same time once the transition to TypeScript is fully complete
I think it's fine (and certainly much easier) to do it this way.

* chore: Fix whitespace (#6243)

* fix: Remove spurious blank lines

  Remove extraneous blank lines introduced by deletion of
  'use strict'; pragmas.

  Also fix the location of the goog.declareModuleId call in
  core/utils/array.ts.

* fix: Add missing double-blank-line before body of modules

  Our convention is to have two blank lines between the imports (or
  module ID, if there are no imports) and the beginning of the body
  of the module.  Enforce this.

* fix: one addition format error for PR #6243

* fix(build): Skip npm prepare when running in CI (#6244)

Have npm prepare do nothing when running in CI.

We don't need to do any building, because npm test will build
everything needed in the workflows in which it is run, and we
don't want to build anything in other workflows because a tsc
error would prevent those workflows from completing.

* fix: re-add `@package` annotations as `@internal` annotations (#6232)

* fix: add ~70% of internal attributes

* fix: work on manually adding more @internal annotations

* fix: add more manual internal annotations

* fix: rename package typos to internal

* fix: final manual fixes for internal annotations

* chore: format

* chore: make unnecessary multiline jsdoc a single line

* fix: fix internal tags in serialization exceptions

* fix: tsc errors picked up from develop (#6224)

* fix: relative path for deprecation utils

* fix: checking if properties exist in svg_math

* fix: set all timeout PIDs to AnyDuringMigration

* fix: make nullability errors explicity in block drag surface

* fix: make null check in events_block_change explicit

* fix: make getEventWorkspace_ internal so we can access it from CommentCreateDeleteHelper

* fix: rename DIV -> containerDiv in tooltip

* fix: ignore backwards compat check in category

* fix: set block styles to AnyDuringMigration

* fix: type typo in KeyboardShortcut

* fix: constants name in row measurables

* fix: typecast in mutator

* fix: populateProcedures type of flattened array

* fix: ignore errors related to workspace comment deserialization

* chore: format files

* fix: renaming imports missing file extensions

* fix: remove check for sound.play

* fix: temporarily remove bad requireType.

All `export type` statements are stripped when tsc is run. This means
that when we attempt to require BlockDefinition from the block files, we
get an error because it does not exist.

We decided to temporarily remove the require, because this will no
longer be a problem when we conver the blocks to typescript, and
everything gets compiled together.

* fix: bad jsdoc in array

* fix: silence missing property errors

Closure was complaining about inexistant properties, but they actually
do exist, they're just not being transpiled by tsc in a way that closure
understands.

I.E. if things are initialized in a function called by the constructor,
rather than in a class field or in the custructor itself, closure would
error.

It would also error on enums, because they are transpiled to a weird
IIFE.

* fix: context menu action handler not knowing the type of this.

this: TypeX information gets stripped when tsc is run, so closure could
not know that this was not global. Fixed this by reorganizing to use the
option object directly instead of passing it to onAction to be bound to
this.

* fix: readd getDeveloperVars checks (should not be part of migration)

This was found because ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE was no
longer being accessed.

* fix: silence closure errors about overriding supertype props

We propertly define the overrides in typescript, but these get removed
from the compiled output, so closure doesn't know they exist.

* fix: silence globalThis errors

this: TypeX annotations get stripped from the compiled output, so
closure can't know that we're accessing the correct things. However,
typescript makes sure that this always has the correct properties, so
silencing this should be fine.

* fix: bad jsdoc name

* chore: attempt compiling with blockly.js

* fix: attempt moving the import statement above the namespace line

* chore: add todo comments to block def files

* chore: remove todo from context menu

* chore: add comments abotu disabled errors

* chore: move comments back to their correct positions (#6249)

* fix: work on fixing comments

* chore: finish moving all comments

* chore: format

* chore: move some other messed up comments

* chore: format

* fix: Correct enum formatting, use merged `namespace`s for types that are class static members (#6246)

* fix: formatting of enum KeyCodes

* fix: Use merged namespace for ContextMenuRegistry static types

  - Create a namespace to be merged with the ContextMenuRegistry
    class containing the types that were formerly declared as static
    properties on that class.

  - Use type aliases to export them individually as well, for
    compatibility with the changes made by MigranTS (and/or
    @gonfunko) to how other modules in core/ now import these
    types.

  - Update renamings.json5 to reflect the availability of the
    direct exports for modules that import this module directly
    (though they are not available to, and will not be used by,
    code that imports only via blockly.js/blockly.ts.)

* fix: Use merged namespace for Input.Align

  - Create a merged namespace for the Input.Align enum.

  - Use type/const aliases to export it as Input too.

  - Update renamings.json5 to reflect the availability of the
    direct export.

* fix: Use merged namespace for Names.NameType

  - Create a merged namespace for the Names.NameType enum.

  - Use type/const aliases to export it as NameType too.

  - Update renamings.json5 to reflect the availability of the
    direct export.  (This ought to have happened in an earlier
    version as it was already available by both routes.)

* chore: Fix minor issues for PR #6246

  - Use `Align` instead of `Input.Align` where possible.

* fix(build): Suppress irrelevant JSC_UNUSED_LOCAL_ASSIGNMENT errors

  tsc generates code for merged namespaces that looks like:

      (function (ClassName) {
          let EnumName;
          (function (EnumName) {
              EnumName[EnumNameAlign["v1"] = 0] = "v1";
              // etc.
          })(EnumName = ClassName.EnumName || (ClassName.EnumName = {}));
      })(ClassName || (ClassName = {}));

  and Closure Compiler complains about the fact that the EnumName let
  binding is initialised but never used.  (It exists so that any other
  code that was in the namespace could see the enum.)

  Suppress this message, since it is not actionable and lint and/or tsc
  should tell us if we have actual unused variables in our .ts files.

* chore(build): Suppress spurious warnings from closure-make-deps (#6253)

A little bit of an ugly hack, but it works: pipe stderr through
grep -v to suppress error output starting with "WARNING in".

* fix: remaining enums that weren't properly exported (#6251)

* fix: remaining enums that weren't properly exported

* chore: format

* fix: add enum value exports

* chore: format

* fix: properly export interfaces that were typedefs (#6250)

* fix: properly export interfaces that were typedefs

* fix: allowCollsion -> allowCollision

* fix: convert unconverted enums

* fix: enums that were/are instance properties

* fix: revert changes to property enums

* fix: renamed protected parameter properties (#6252)

* fix: bad protected parameter properties

* chore:format

* fix: gesture constructor

* fix: overridden properties that were renamed

* refactor: Migrate `blockly.js` to TypeScript (#6261)

* chore: Apply changes to blockly.js to blockly.ts

* fix: Build using core/blockly.ts instead of .js

  Compiles and runs in compressed mode correctly!

* fix(build): Don't depend on execSync running bash (#6262)

For some reason on Github CI servers execSync uses /bin/sh, which
is (on Ubuntu) dash rather than bash, and does not understand
the pipefail option.

So remove the grep pipe on stderr and just discard all error output
at all.

This is not ideal as errors in test deps will go unreported AND
not even cause test failure, but it's not clear that it's worth
investing more time to fix this at the moment.

* chore: use `import type` where possible (#6279)

* chore: automatically change imports to import types

* chore: revert changes that actually need to be imports

* chore: format

* chore: add more import type statements based on importsNotUsedAsValues

* chore: fix tsconfig

* chore: add link to compiler issue

* fix: add type information to blockly options (#6283)

* fix: add type information to blockly options

* chore: format

* chore: remove erroneous comment

* fix: bugs revealed by getting the built output working (#6282)

* fix: types of compose and decompose in block

* fix: workspace naming in toolbox

* chore: add jsdoc

* chore: restore registry comments to better positions

* chore: pr comments'

* fix(variables): Revert inadvertent change to allDeveloperVariables (#6290)

It appears that a function call got modified incorrectly (probably
in an effort to fix a typing issue).  This fix trivially reverts
the line in question to match the original JS version from develop.

This causes the generator tests to pass.

* fix: circular dependencies (#6281)

* chore: fix circular dependencies w/ static workspace funcs

* remove preserved imports that aren't currently necessary (probably)

* fix circular dependency with workspaces and block using stub

* fix dependency between variables and xml by moving function to utils

* add stub for trashcan as well

* fix line endings from rebase

* fix goog/base order

* add trashcan patch

* fix: types of compose and decompose in block

* fix: workspace naming in toolbox

* chore: add jsdoc

* chore: restore registry comments to better positions

* chore: remove implementations in goog.js

* chore: fix types of stubs

* chore: remove added AnyDuringMigration casts

* chore: remove modifications to xml and variables

* chore: format

* chore: remove event requirements in workspace comments

* chore: fix circular dependency with xml and workspace comments

* fixup remove ContextMenu import

* chore: fix dependency between mutator and workspace

* chore: break circular dependency between names and procedures

* chore: get tests to run?

* chore: pr comments'

* chore: fix stubbing field registry fromJson

* chore: fix spying on fire

* chore: fix stubbing parts of connection checker

* chore: fix stubbing dialog

* chore: fix stubbing style

* chore: fix spying on duplicate

* chore: fix stubbing variables

* chore: fix stubbing copy

* chore: fix stubbing in workspace

* chore: remove unnecessary stubs

* chore: fix formatting

* chore: fix other formatting

* chore: add backwards compatible static properties to workspace

* chore: move static type properties

* chore: move and comment stubs

* chore: add newlines at EOF

* chore: improve errors for monkey patched functions

* chore: update comment with a pointer to the doc

* chore: update comment with a pointer to the doc

* chore: format

* chore: revert changes to playground used for testing (#6292)

* chore: get mocha tests to pass. (#6291)

* chore: fix undo and empty code blocks

* chore: skip IE test

* chore: fix gesture test

* chore: fix replace message references test

* chore: fix string table interpolation

* chore: skip getById tests

* chore: fix field tests

* chore: fix console errors by making workspace nullable

* chore: format

* chore: fix definition overwrite warning

* chore: update metadata

* chore: temporarily modify the the advanced compile test

* chore: fix gestures by fixing test instead

Co-authored-by: Neil Fraser <fraser@google.com>
Co-authored-by: Christopher Allen <cpcallen+git@google.com>

core/extensions.ts

@@ -10,7 +10,6 @@
  *      are applied using Block.applyExtension(), or the JSON "extensions"
  *      array attribute.
  */
-'use strict';
 
 /**
  * Extensions are functions that help initialize blocks, usually
@@ -19,35 +18,36 @@
  *      array attribute.
  * @namespace Blockly.Extensions
  */
-goog.module('Blockly.Extensions');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Extensions');
 
-const parsing = goog.require('Blockly.utils.parsing');
-/* eslint-disable-next-line no-unused-vars */
-const {Block} = goog.requireType('Blockly.Block');
-const {FieldDropdown} = goog.require('Blockly.FieldDropdown');
-goog.requireType('Blockly.Mutator');
+// Unused import preserved for side-effects. Remove if unneeded.
+// import './mutator.js';
+
+import type {Block} from './block.js';
+import type {BlockSvg} from './block_svg.js';
+import {FieldDropdown} from './field_dropdown.js';
+import {Mutator} from './mutator.js';
+import * as parsing from './utils/parsing.js';
 
 
-/**
- * The set of all registered extensions, keyed by extension name/id.
- * @private
- */
+/** The set of all registered extensions, keyed by extension name/id. */
 const allExtensions = Object.create(null);
-exports.TEST_ONLY = {allExtensions};
+export const TEST_ONLY = {allExtensions};
 
 /**
  * Registers a new extension function. Extensions are functions that help
  * initialize blocks, usually adding dynamic behavior such as onchange
  * handlers and mutators. These are applied using Block.applyExtension(), or
  * the JSON "extensions" array attribute.
- * @param {string} name The name of this extension.
- * @param {Function} initFn The function to initialize an extended block.
+ * @param name The name of this extension.
+ * @param initFn The function to initialize an extended block.
  * @throws {Error} if the extension name is empty, the extension is already
  *     registered, or extensionFn is not a function.
  * @alias Blockly.Extensions.register
  */
-const register = function(name, initFn) {
-  if ((typeof name !== 'string') || (name.trim() === '')) {
+export function register(name: string, initFn: Function) {
+  if (typeof name !== 'string' || name.trim() === '') {
     throw Error('Error: Invalid extension name "' + name + '"');
   }
   if (allExtensions[name]) {
@@ -57,113 +57,98 @@ const register = function(name, initFn) {
     throw Error('Error: Extension "' + name + '" must be a function');
   }
   allExtensions[name] = initFn;
-};
-exports.register = register;
+}
 
 /**
  * Registers a new extension function that adds all key/value of mixinObj.
- * @param {string} name The name of this extension.
- * @param {!Object} mixinObj The values to mix in.
+ * @param name The name of this extension.
+ * @param mixinObj The values to mix in.
  * @throws {Error} if the extension name is empty or the extension is already
  *     registered.
  * @alias Blockly.Extensions.registerMixin
  */
-const registerMixin = function(name, mixinObj) {
+export function registerMixin(name: string, mixinObj: AnyDuringMigration) {
   if (!mixinObj || typeof mixinObj !== 'object') {
     throw Error('Error: Mixin "' + name + '" must be a object');
   }
-  register(
-      name,
-      /** @this {Block} */
-      function() {
-        this.mixin(mixinObj);
-      });
-};
-exports.registerMixin = registerMixin;
+  register(name, function(this: Block) {
+    this.mixin(mixinObj);
+  });
+}
 
 /**
  * Registers a new extension function that adds a mutator to the block.
  * At register time this performs some basic sanity checks on the mutator.
  * The wrapper may also add a mutator dialog to the block, if both compose and
  * decompose are defined on the mixin.
- * @param {string} name The name of this mutator extension.
- * @param {!Object} mixinObj The values to mix in.
- * @param {(function())=} opt_helperFn An optional function to apply after
- *     mixing in the object.
- * @param {!Array<string>=} opt_blockList A list of blocks to appear in the
- *     flyout of the mutator dialog.
+ * @param name The name of this mutator extension.
+ * @param mixinObj The values to mix in.
+ * @param opt_helperFn An optional function to apply after mixing in the object.
+ * @param opt_blockList A list of blocks to appear in the flyout of the mutator
+ *     dialog.
  * @throws {Error} if the mutation is invalid or can't be applied to the block.
  * @alias Blockly.Extensions.registerMutator
  */
-const registerMutator = function(name, mixinObj, opt_helperFn, opt_blockList) {
+export function registerMutator(
+    name: string, mixinObj: AnyDuringMigration,
+    opt_helperFn?: () => AnyDuringMigration, opt_blockList?: string[]) {
   const errorPrefix = 'Error when registering mutator "' + name + '": ';
 
   checkHasMutatorProperties(errorPrefix, mixinObj);
   const hasMutatorDialog = checkMutatorDialog(mixinObj, errorPrefix);
 
-  if (opt_helperFn && (typeof opt_helperFn !== 'function')) {
+  if (opt_helperFn && typeof opt_helperFn !== 'function') {
     throw Error(errorPrefix + 'Extension "' + name + '" is not a function');
   }
 
   // Sanity checks passed.
-  register(
-      name,
-      /** @this {Block} */
-      function() {
-        if (hasMutatorDialog) {
-          const {Mutator} = goog.module.get('Blockly.Mutator');
-          if (!Mutator) {
-            throw Error(errorPrefix + 'Missing require for Blockly.Mutator');
-          }
-          this.setMutator(new Mutator(opt_blockList || []));
-        }
-        // Mixin the object.
-        this.mixin(mixinObj);
+  register(name, function(this: Block) {
+    if (hasMutatorDialog) {
+      this.setMutator(new Mutator(this as BlockSvg, opt_blockList || []));
+    }
+    // Mixin the object.
+    this.mixin(mixinObj);
 
-        if (opt_helperFn) {
-          opt_helperFn.apply(this);
-        }
-      });
-};
-exports.registerMutator = registerMutator;
+    if (opt_helperFn) {
+      opt_helperFn.apply(this);
+    }
+  });
+}
 
 /**
  * Unregisters the extension registered with the given name.
- * @param {string} name The name of the extension to unregister.
+ * @param name The name of the extension to unregister.
  * @alias Blockly.Extensions.unregister
  */
-const unregister = function(name) {
+export function unregister(name: string) {
   if (isRegistered(name)) {
     delete allExtensions[name];
   } else {
     console.warn(
         'No extension mapping for name "' + name + '" found to unregister');
   }
-};
-exports.unregister = unregister;
+}
 
 /**
  * Returns whether an extension is registered with the given name.
- * @param {string} name The name of the extension to check for.
- * @return {boolean} True if the extension is registered.  False if it is
- *     not registered.
+ * @param name The name of the extension to check for.
+ * @return True if the extension is registered.  False if it is not registered.
  * @alias Blockly.Extensions.isRegistered
  */
-const isRegistered = function(name) {
+export function isRegistered(name: string): boolean {
   return !!allExtensions[name];
-};
-exports.isRegistered = isRegistered;
+}
 
 /**
  * Applies an extension method to a block. This should only be called during
  * block construction.
- * @param {string} name The name of the extension.
- * @param {!Block} block The block to apply the named extension to.
- * @param {boolean} isMutator True if this extension defines a mutator.
+ * @param name The name of the extension.
+ * @param block The block to apply the named extension to.
+ * @param isMutator True if this extension defines a mutator.
  * @throws {Error} if the extension is not found.
  * @alias Blockly.Extensions.apply
  */
-const apply = function(name, block, isMutator) {
+export function apply(name: string, block: Block, isMutator: boolean) {
   const extensionFn = allExtensions[name];
   if (typeof extensionFn !== 'function') {
     throw Error('Error: Extension "' + name + '" not found.');
@@ -184,25 +169,23 @@ const apply = function(name, block, isMutator) {
     checkHasMutatorProperties(errorPrefix, block);
   } else {
     if (!mutatorPropertiesMatch(
-            /** @type {!Array<Object>} */ (mutatorProperties), block)) {
+            mutatorProperties as AnyDuringMigration[], block)) {
       throw Error(
           'Error when applying extension "' + name + '": ' +
           'mutation properties changed when applying a non-mutator extension.');
     }
   }
-};
-exports.apply = apply;
+}
 
 /**
  * Check that the given block does not have any of the four mutator properties
  * defined on it.  This function should be called before applying a mutator
  * extension to a block, to make sure we are not overwriting properties.
- * @param {string} mutationName The name of the mutation to reference in error
- *     messages.
- * @param {!Block} block The block to check.
+ * @param mutationName The name of the mutation to reference in error messages.
+ * @param block The block to check.
  * @throws {Error} if any of the properties already exist on the block.
  */
-const checkNoMutatorProperties = function(mutationName, block) {
+function checkNoMutatorProperties(mutationName: string, block: Block) {
   const properties = getMutatorProperties(block);
   if (properties.length) {
     throw Error(
@@ -210,66 +193,70 @@ const checkNoMutatorProperties = function(mutationName, block) {
         '" to a block that already has mutator functions.' +
         '  Block id: ' + block.id);
   }
-};
+}
 
 /**
  * Checks if the given object has both the 'mutationToDom' and 'domToMutation'
  * functions.
- * @param {?} object The object to check.
- * @param {string} errorPrefix The string to prepend to any error message.
- * @return {boolean} True if the object has both functions.  False if it has
- *     neither function.
- * @throws {Error} if the object has only one of the functions, or either is
- *     not actually a function.
+ * @param object The object to check.
+ * @param errorPrefix The string to prepend to any error message.
+ * @return True if the object has both functions.  False if it has neither
+ *     function.
+ * @throws {Error} if the object has only one of the functions, or either is not
+ *     actually a function.
  */
-const checkXmlHooks = function(object, errorPrefix) {
+function checkXmlHooks(
+    object: AnyDuringMigration, errorPrefix: string): boolean {
   return checkHasFunctionPair(
       object.mutationToDom, object.domToMutation,
       errorPrefix + ' mutationToDom/domToMutation');
-};
-
+}
 /**
  * Checks if the given object has both the 'saveExtraState' and 'loadExtraState'
  * functions.
- * @param {?} object The object to check.
- * @param {string} errorPrefix The string to prepend to any error message.
- * @return {boolean} True if the object has both functions.  False if it has
- *     neither function.
- * @throws {Error} if the object has only one of the functions, or either is
- *     not actually a function.
+ * @param object The object to check.
+ * @param errorPrefix The string to prepend to any error message.
+ * @return True if the object has both functions.  False if it has neither
+ *     function.
+ * @throws {Error} if the object has only one of the functions, or either is not
+ *     actually a function.
  */
-const checkJsonHooks = function(object, errorPrefix) {
+function checkJsonHooks(
+    object: AnyDuringMigration, errorPrefix: string): boolean {
   return checkHasFunctionPair(
       object.saveExtraState, object.loadExtraState,
       errorPrefix + ' saveExtraState/loadExtraState');
-};
+}
 
 /**
  * Checks if the given object has both the 'compose' and 'decompose' functions.
- * @param {?} object The object to check.
- * @param {string} errorPrefix The string to prepend to any error message.
- * @return {boolean} True if the object has both functions.  False if it has
- *     neither function.
- * @throws {Error} if the object has only one of the functions, or either is
- *     not actually a function.
+ * @param object The object to check.
+ * @param errorPrefix The string to prepend to any error message.
+ * @return True if the object has both functions.  False if it has neither
+ *     function.
+ * @throws {Error} if the object has only one of the functions, or either is not
+ *     actually a function.
  */
-const checkMutatorDialog = function(object, errorPrefix) {
+function checkMutatorDialog(
+    object: AnyDuringMigration, errorPrefix: string): boolean {
   return checkHasFunctionPair(
       object.compose, object.decompose, errorPrefix + ' compose/decompose');
-};
+}
 
 /**
  * Checks that both or neither of the given functions exist and that they are
  * indeed functions.
- * @param {*} func1 The first function in the pair.
- * @param {*} func2 The second function in the pair.
- * @param {string} errorPrefix The string to prepend to any error message.
- * @return {boolean} True if the object has both functions.  False if it has
- *     neither function.
- * @throws {Error} If the object has only one of the functions, or either is
- *     not actually a function.
+ * @param func1 The first function in the pair.
+ * @param func2 The second function in the pair.
+ * @param errorPrefix The string to prepend to any error message.
+ * @return True if the object has both functions.  False if it has neither
+ *     function.
+ * @throws {Error} If the object has only one of the functions, or either is not
+ *     actually a function.
  */
-const checkHasFunctionPair = function(func1, func2, errorPrefix) {
+function checkHasFunctionPair(
+    func1: AnyDuringMigration, func2: AnyDuringMigration,
+    errorPrefix: string): boolean {
   if (func1 && func2) {
     if (typeof func1 !== 'function' || typeof func2 !== 'function') {
       throw Error(errorPrefix + ' must be a function');
@@ -279,14 +266,15 @@ const checkHasFunctionPair = function(func1, func2, errorPrefix) {
     return false;
   }
   throw Error(errorPrefix + 'Must have both or neither functions');
-};
+}
 
 /**
  * Checks that the given object required mutator properties.
- * @param {string} errorPrefix The string to prepend to any error message.
- * @param {!Object} object The object to inspect.
+ * @param errorPrefix The string to prepend to any error message.
+ * @param object The object to inspect.
  */
-const checkHasMutatorProperties = function(errorPrefix, object) {
+function checkHasMutatorProperties(
+    errorPrefix: string, object: AnyDuringMigration) {
   const hasXmlHooks = checkXmlHooks(object, errorPrefix);
   const hasJsonHooks = checkJsonHooks(object, errorPrefix);
   if (!hasXmlHooks && !hasJsonHooks) {
@@ -297,15 +285,15 @@ const checkHasMutatorProperties = function(errorPrefix, object) {
   // A block with a mutator isn't required to have a mutation dialog, but
   // it should still have both or neither of compose and decompose.
   checkMutatorDialog(object, errorPrefix);
-};
+}
 
 /**
  * Get a list of values of mutator properties on the given block.
- * @param {!Block} block The block to inspect.
- * @return {!Array<Object>} A list with all of the defined properties, which
- *     should be functions, but may be anything other than undefined.
+ * @param block The block to inspect.
+ * @return A list with all of the defined properties, which should be functions,
+ *     but may be anything other than undefined.
  */
-const getMutatorProperties = function(block) {
+function getMutatorProperties(block: Block): AnyDuringMigration[] {
   const result = [];
   // List each function explicitly by reference to allow for renaming
   // during compilation.
@@ -328,17 +316,18 @@ const getMutatorProperties = function(block) {
     result.push(block.decompose);
   }
   return result;
-};
+}
 
 /**
  * Check that the current mutator properties match a list of old mutator
  * properties.  This should be called after applying a non-mutator extension,
  * to verify that the extension didn't change properties it shouldn't.
- * @param {!Array<Object>} oldProperties The old values to compare to.
- * @param {!Block} block The block to inspect for new values.
- * @return {boolean} True if the property lists match.
+ * @param oldProperties The old values to compare to.
+ * @param block The block to inspect for new values.
+ * @return True if the property lists match.
  */
-const mutatorPropertiesMatch = function(oldProperties, block) {
+function mutatorPropertiesMatch(
+    oldProperties: AnyDuringMigration[], block: Block): boolean {
   const newProperties = getMutatorProperties(block);
   if (newProperties.length !== oldProperties.length) {
     return false;
@@ -349,15 +338,15 @@ const mutatorPropertiesMatch = function(oldProperties, block) {
     }
   }
   return true;
-};
+}
 
 /**
  * Calls a function after the page has loaded, possibly immediately.
- * @param {function()} fn Function to run.
+ * @param fn Function to run.
  * @throws Error Will throw if no global document can be found (e.g., Node.js).
- * @package
+ * @internal
  */
-const runAfterPageLoad = function(fn) {
+export function runAfterPageLoad(fn: () => AnyDuringMigration) {
   if (typeof document !== 'object') {
     throw Error('runAfterPageLoad() requires browser document.');
   }
@@ -372,8 +361,7 @@ const runAfterPageLoad = function(fn) {
       }
     }, 10);
   }
-};
-exports.runAfterPageLoad = runAfterPageLoad;
+}
 
 /**
  * Builds an extension function that will map a dropdown value to a tooltip
@@ -388,16 +376,16 @@ exports.runAfterPageLoad = runAfterPageLoad;
  * loading the first block of any given type, the extension will validate every
  * dropdown option has a matching tooltip in the lookupTable.  Errors are
  * reported as warnings in the console, and are never fatal.
- * @param {string} dropdownName The name of the field whose value is the key
- *     to the lookup table.
- * @param {!Object<string, string>} lookupTable The table of field values to
- *     tooltip text.
- * @return {!Function} The extension function.
+ * @param dropdownName The name of the field whose value is the key to the
+ *     lookup table.
+ * @param lookupTable The table of field values to tooltip text.
+ * @return The extension function.
  * @alias Blockly.Extensions.buildTooltipForDropdown
  */
-const buildTooltipForDropdown = function(dropdownName, lookupTable) {
+export function buildTooltipForDropdown(
+    dropdownName: string, lookupTable: {[key: string]: string}): Function {
   // List of block types already validated, to minimize duplicate warnings.
-  const blockTypesChecked = [];
+  const blockTypesChecked: AnyDuringMigration[] = [];
 
   // Check the tooltip string messages for invalid references.
   // Wait for load, in case Blockly.Msg is not yet populated.
@@ -412,17 +400,14 @@ const buildTooltipForDropdown = function(dropdownName, lookupTable) {
     });
   }
 
-  /**
-   * The actual extension.
-   * @this {Block}
-   */
-  const extensionFn = function() {
+  /** The actual extension. */
+  function extensionFn(this: Block) {
     if (this.type && blockTypesChecked.indexOf(this.type) === -1) {
       checkDropdownOptionsInTable(this, dropdownName, lookupTable);
       blockTypesChecked.push(this.type);
     }
 
-    this.setTooltip(function() {
+    this.setTooltip(function(this: Block) {
       const value = String(this.getFieldValue(dropdownName));
       let tooltip = lookupTable[value];
       if (tooltip === null) {
@@ -431,7 +416,7 @@ const buildTooltipForDropdown = function(dropdownName, lookupTable) {
           let warning = 'No tooltip mapping for value ' + value + ' of field ' +
               dropdownName;
           if (this.type !== null) {
-            warning += (' of block type ' + this.type);
+            warning += ' of block type ' + this.type;
           }
           console.warn(warning + '.');
         }
@@ -440,19 +425,19 @@ const buildTooltipForDropdown = function(dropdownName, lookupTable) {
       }
       return tooltip;
     }.bind(this));
-  };
+  }
   return extensionFn;
-};
-exports.buildTooltipForDropdown = buildTooltipForDropdown;
+}
 
 /**
  * Checks all options keys are present in the provided string lookup table.
  * Emits console warnings when they are not.
- * @param {!Block} block The block containing the dropdown
- * @param {string} dropdownName The name of the dropdown
- * @param {!Object<string, string>} lookupTable The string lookup table
+ * @param block The block containing the dropdown
+ * @param dropdownName The name of the dropdown
+ * @param lookupTable The string lookup table
  */
-const checkDropdownOptionsInTable = function(block, dropdownName, lookupTable) {
+function checkDropdownOptionsInTable(
+    block: Block, dropdownName: string, lookupTable: {[key: string]: string}) {
   // Validate all dropdown options have values.
   const dropdown = block.getField(dropdownName);
   if (dropdown instanceof FieldDropdown && !dropdown.isOptionListDynamic()) {
@@ -466,19 +451,20 @@ const checkDropdownOptionsInTable = function(block, dropdownName, lookupTable) {
       }
     }
   }
-};
+}
 
 /**
  * Builds an extension function that will install a dynamic tooltip. The
  * tooltip message should include the string '%1' and that string will be
  * replaced with the text of the named field.
- * @param {string} msgTemplate The template form to of the message text, with
- *     %1 placeholder.
- * @param {string} fieldName The field with the replacement text.
- * @return {!Function} The extension function.
+ * @param msgTemplate The template form to of the message text, with %1
+ *     placeholder.
+ * @param fieldName The field with the replacement text.
+ * @return The extension function.
  * @alias Blockly.Extensions.buildTooltipWithFieldText
  */
-const buildTooltipWithFieldText = function(msgTemplate, fieldName) {
+export function buildTooltipWithFieldText(
+    msgTemplate: string, fieldName: string): Function {
   // Check the tooltip string messages for invalid references.
   // Wait for load, in case Blockly.Msg is not yet populated.
   // runAfterPageLoad() does not run in a Node.js environment due to lack
@@ -490,34 +476,29 @@ const buildTooltipWithFieldText = function(msgTemplate, fieldName) {
     });
   }
 
-  /**
-   * The actual extension.
-   * @this {Block}
-   */
-  const extensionFn = function() {
-    this.setTooltip(function() {
+  /** The actual extension. */
+  function extensionFn(this: Block) {
+    this.setTooltip(function(this: Block) {
       const field = this.getField(fieldName);
       return parsing.replaceMessageReferences(msgTemplate)
           .replace('%1', field ? field.getText() : '');
     }.bind(this));
-  };
+  }
   return extensionFn;
-};
-exports.buildTooltipWithFieldText = buildTooltipWithFieldText;
+}
 
 /**
  * Configures the tooltip to mimic the parent block when connected. Otherwise,
  * uses the tooltip text at the time this extension is initialized. This takes
  * advantage of the fact that all other values from JSON are initialized before
  * extensions.
- * @this {Block}
  */
-const extensionParentTooltip = function() {
+function extensionParentTooltip(this: Block) {
   const tooltipWhenNotConnected = this.tooltip;
-  this.setTooltip(function() {
+  this.setTooltip(function(this: Block) {
     const parent = this.getParent();
-    return (parent && parent.getInputsInline() && parent.tooltip) ||
+    return parent && parent.getInputsInline() && parent.tooltip ||
         tooltipWhenNotConnected;
   }.bind(this));
-};
+}
 register('parent_tooltip_when_inline', extensionParentTooltip);