diff --git a/core/lib/Drupal/Core/Extension/ModuleHandler.php b/core/lib/Drupal/Core/Extension/ModuleHandler.php
index cfbaa61a8e..98ad3fcc20 100644
--- a/core/lib/Drupal/Core/Extension/ModuleHandler.php
+++ b/core/lib/Drupal/Core/Extension/ModuleHandler.php
@@ -414,6 +414,43 @@ public function invokeAll($hook, array $args = []) {
   /**
    * {@inheritdoc}
    */
+  public function invokeDeprecated($module, $hook, array $args = []) {
+    $result = $this->invoke($module, $hook, $args);
+    $this->triggerDeprecationError($hook);
+    return $result;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invokeAllDeprecated($hook, array $args = []) {
+    $result = $this->invokeAll($hook, $args);
+    $this->triggerDeprecationError($hook);
+    return $result;
+  }
+
+
+  /**
+   * Triggers an E_USER_DEPRECATED error if any module implements the hook.
+   *
+   * @param string $hook
+   *   The name of the hook.
+   */
+  private function triggerDeprecationError($hook) {
+    $modules = array_keys($this->getImplementationInfo($hook));
+    if (!empty($modules)) {
+      $message = 'The deprecated hook hook_' . $hook . '() is implemented in these functions: ';
+      $hooks = [];
+      foreach ($modules as $module) {
+        $hooks[] = $module . '_' . $hook . '()';
+      }
+      @trigger_error($message . implode(', ', $hooks), E_USER_DEPRECATED);
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
   public function alter($type, &$data, &$context1 = NULL, &$context2 = NULL) {
     // Most of the time, $type is passed as a string, so for performance,
     // normalize it to that. When passed as an array, usually the first item in
@@ -503,6 +540,28 @@ public function alter($type, &$data, &$context1 = NULL, &$context2 = NULL) {
   }
 
   /**
+   * {@inheritdoc}
+   */
+  public function alterDeprecated($type, &$data, &$context1 = NULL, &$context2 = NULL) {
+    // Invoke the alter hook. This has the side effect of populating
+    // $this->alterFunctions.
+    $this->alter($type, $data, $context1, $context2);
+    // The $type parameter can be an array. alter() will deal with this
+    // internally, but we have to extract the proper $cid in order to discover
+    // implementations.
+    $cid = $type;
+    if (is_array($type)) {
+      $cid = implode(',', $type);
+      $extra_types = $type;
+      $type = array_shift($extra_types);
+    }
+    if (!empty($this->alterFunctions[$cid])) {
+      $message = 'The deprecated alter hook hook_' . $type . '_alter() is implemented in these functions: ' . implode(', ', $this->alterFunctions[$cid]);
+      @trigger_error($message, E_USER_DEPRECATED);
+    }
+  }
+
+  /**
    * Provides information about modules' implementations of a hook.
    *
    * @param string $hook
diff --git a/core/lib/Drupal/Core/Extension/ModuleHandlerInterface.php b/core/lib/Drupal/Core/Extension/ModuleHandlerInterface.php
index 03d3f66c7b..4f36d94609 100644
--- a/core/lib/Drupal/Core/Extension/ModuleHandlerInterface.php
+++ b/core/lib/Drupal/Core/Extension/ModuleHandlerInterface.php
@@ -239,6 +239,53 @@ public function invoke($module, $hook, array $args = []);
   public function invokeAll($hook, array $args = []);
 
   /**
+   * Invokes a deprecated hook in a particular module.
+   *
+   * Invoking a deprecated hook adds the behavior of triggering an
+   * E_USER_DEPRECATED error if any implementations are found.
+   *
+   * API maintainers should use this method instead of invoke() when their hook
+   * is deprecated. This method does not detect when a hook is deprecated.
+   *
+   * @param string $module
+   *   The name of the module (without the .module extension).
+   * @param string $hook
+   *   The name of the hook to invoke.
+   * @param array $args
+   *   Arguments to pass to the hook implementation.
+   *
+   * @return mixed
+   *   The return value of the hook implementation.
+   *
+   * @see \Drupal\Core\Extension\ModuleHandlerInterface::invoke()
+   */
+  public function invokeDeprecated($module, $hook, array $args = []);
+
+  /**
+   * Invokes a deprecated hook in all enabled modules that implement it.
+   *
+   * Invoking a deprecated hook adds the behavior of triggering an
+   * E_USER_DEPRECATED error if any implementations are found.
+   *
+   * API maintainers should use this method instead of invokeAll() when their
+   * hook is deprecated. This method does not detect when a hook is deprecated.
+   *
+   * @param string $hook
+   *   The name of the hook to invoke.
+   * @param array $args
+   *   Arguments to pass to the hook.
+   *
+   * @return array
+   *   An array of return values of the hook implementations. If modules return
+   *   arrays from their implementations, those are merged into one array
+   *   recursively. Note: integer keys in arrays will be lost, as the merge is
+   *   done using array_merge_recursive().
+   *
+   * @see \Drupal\Core\Extension\ModuleHandlerInterface::invokeAll()
+   */
+  public function invokeAllDeprecated($hook, array $args = []);
+
+  /**
    * Passes alterable variables to specific hook_TYPE_alter() implementations.
    *
    * This dispatch function hands off the passed-in variables to type-specific
@@ -290,6 +337,38 @@ public function invokeAll($hook, array $args = []);
   public function alter($type, &$data, &$context1 = NULL, &$context2 = NULL);
 
   /**
+   * Passes alterable variables to deprecated hook_TYPE_alter() implementations.
+   *
+   * This method triggers an E_USER_DEPRECATED error if any implementations of
+   * the alter hook are found. It is otherwise identical to alter().
+   *
+   * See the documentation for alter() for more details.
+   *
+   * @param string|array $type
+   *   A string describing the type of the alterable $data. 'form', 'links',
+   *   'node_content', and so on are several examples. Alternatively can be an
+   *   array, in which case hook_TYPE_alter() is invoked for each value in the
+   *   array, ordered first by module, and then for each module, in the order of
+   *   values in $type. For example, when Form API is using $this->alter() to
+   *   execute both hook_form_alter() and hook_form_FORM_ID_alter()
+   *   implementations, it passes array('form', 'form_' . $form_id) for $type.
+   * @param mixed $data
+   *   The variable that will be passed to hook_TYPE_alter() implementations to be
+   *   altered. The type of this variable depends on the value of the $type
+   *   argument. For example, when altering a 'form', $data will be a structured
+   *   array. When altering a 'profile', $data will be an object.
+   * @param mixed $context1
+   *   (optional) An additional variable that is passed by reference.
+   * @param mixed $context2
+   *   (optional) An additional variable that is passed by reference. If more
+   *   context needs to be provided to implementations, then this should be an
+   *   associative array as described above.
+   *
+   * @see \Drupal\Core\Extension\ModuleHandlerInterface::alter()
+   */
+  public function alterDeprecated($type, &$data, &$context1 = NULL, &$context2 = NULL);
+
+  /**
    * Returns an array of directories for all enabled modules. Useful for
    * tasks such as finding a file that exists in all module directories.
    *
diff --git a/core/tests/Drupal/Tests/Core/Extension/ModuleHandlerDeprecatedTest.php b/core/tests/Drupal/Tests/Core/Extension/ModuleHandlerDeprecatedTest.php
new file mode 100644
index 0000000000..398b46a1e2
--- /dev/null
+++ b/core/tests/Drupal/Tests/Core/Extension/ModuleHandlerDeprecatedTest.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace Drupal\Tests\Core\Extension;
+
+use Drupal\Core\Extension\ModuleHandler;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * Tests special cases for hook deprecation methods.
+ *
+ * This is a separate class from Drupal\Tests\Core\Extension\ModuleHandlerTest
+ * so that we can mark it as belonging to the legacy group.
+ *
+ * We have to build elaborate mocks for these tests because
+ * symfony/phpunit-bridge doesn't deal well with kernel tests or
+ * process-isolated tests.
+ * @see https://www.drupal.org/node/2884530
+ *
+ * @coversDefaultClass \Drupal\Core\Extension\ModuleHandler
+ *
+ * @group Extension
+ * @group legacy
+ *
+ * @see Drupal\Tests\Core\Extension\ModuleHandlerTest
+ */
+class ModuleHandlerDeprecatedTest extends UnitTestCase {
+
+  /**
+   * @covers ::alterDeprecated
+   * @expectedDeprecation The deprecated alter hook hook_alter_me_alter() is implemented in these functions: foo_alter_me_alter, bar_alter_me_alter
+   */
+  public function testAlterDeprecated() {
+    $handler = $this->getMockBuilder(ModuleHandler::class)
+      ->disableOriginalConstructor()
+      ->setMethods(['alter'])
+      ->getMock();
+
+    $handler->expects($this->once())
+      ->method('alter');
+
+    $type = 'alter_me';
+    $functions = [
+      $type => ['foo_' . $type . '_alter', 'bar_' . $type . '_alter'],
+    ];
+
+    $ref_alter_functions = new \ReflectionProperty($handler, 'alterFunctions');
+    $ref_alter_functions->setAccessible(TRUE);
+    $ref_alter_functions->setValue($handler, $functions);
+
+    $data = ['data'];
+
+    $this->assertNull($handler->alterDeprecated($type, $data));
+  }
+
+  /**
+   * @covers ::invokeDeprecated
+   * @expectedDeprecation The deprecated hook hook_some_hook() is implemented in these functions: implementing_module_some_hook()
+   */
+  public function testInvokeDeprecated() {
+    $handler = $this->getMockBuilder(ModuleHandler::class)
+      ->disableOriginalConstructor()
+      ->setMethods(['invoke', 'getImplementationInfo'])
+      ->getMock();
+
+    $handler->expects($this->once())
+      ->method('getImplementationInfo')
+      ->willReturn(['implementing_module' => FALSE]);
+
+    $handler->expects($this->once())
+      ->method('invoke')
+      ->willReturn('invoked');
+
+    $this->assertEquals('invoked', $handler->invokeDeprecated('module', 'some_hook'));
+  }
+
+  /**
+   * @covers ::invokeAllDeprecated
+   * @expectedDeprecation The deprecated hook hook_some_hook() is implemented in these functions: implementing_module_some_hook()
+   */
+  public function testInvokeAllDeprecated() {
+    $handler = $this->getMockBuilder(ModuleHandler::class)
+      ->disableOriginalConstructor()
+      ->setMethods(['invokeAll', 'getImplementationInfo'])
+      ->getMock();
+
+    $handler->expects($this->once())
+      ->method('getImplementationInfo')
+      ->willReturn(['implementing_module' => FALSE]);
+
+    $handler->expects($this->once())
+      ->method('invokeAll')
+      ->willReturn('invokedAll');
+
+    $this->assertEquals('invokedAll', $handler->invokeAllDeprecated('some_hook'));
+  }
+
+}