diff --git a/core/core.services.yml b/core/core.services.yml
index bf21661..b587ba7 100644
--- a/core/core.services.yml
+++ b/core/core.services.yml
@@ -1159,7 +1159,7 @@ services:
       - { name: service_collector, tag: breadcrumb_builder, call: addBuilder }
   token:
     class: Drupal\Core\Utility\Token
-    arguments: ['@module_handler', '@cache.discovery', '@language_manager', '@cache_tags.invalidator']
+    arguments: ['@module_handler', '@cache.discovery', '@language_manager', '@cache_tags.invalidator', '@renderer']
   batch.storage:
     class: Drupal\Core\Batch\BatchStorage
     arguments: ['@database', '@session', '@csrf_token']
diff --git a/core/lib/Drupal/Core/Cache/CacheableMetadata.php b/core/lib/Drupal/Core/Cache/CacheableMetadata.php
index 8e8a578..33d5afb 100644
--- a/core/lib/Drupal/Core/Cache/CacheableMetadata.php
+++ b/core/lib/Drupal/Core/Cache/CacheableMetadata.php
@@ -133,6 +133,35 @@ public function setCacheMaxAge($max_age) {
   }
 
   /**
+   * Adds a dependency on an object: merges its cacheability metadata.
+   *
+   * @param \Drupal\Core\Cache\CacheableDependencyInterface|mixed $other_object
+   *   The dependency. If the object implements CacheableDependencyInterface,
+   *   then its cacheability metadata will be used. Otherwise, the passed in
+   *   object must be assumed to be uncacheable, so max-age 0 is set.
+   *
+   * @return $this
+   */
+  public function addCacheableDependency($other_object) {
+    if ($other_object instanceof CacheableDependencyInterface) {
+      $this->addCacheTags($other_object->getCacheTags());
+      $this->addCacheContexts($other_object->getCacheContexts());
+      if ($this->maxAge === Cache::PERMANENT) {
+        $this->maxAge = $other_object->getCacheMaxAge();
+      }
+      elseif (($max_age = $other_object->getCacheMaxAge()) && $max_age !== Cache::PERMANENT) {
+        $this->maxAge = Cache::mergeMaxAges($this->maxAge, $max_age);
+      }
+    }
+    else {
+      // Not a cacheable dependency, this can not be cached.
+      $this->maxAge = 0;
+    }
+
+    return $this;
+  }
+
+  /**
    * Merges the values of another CacheableMetadata object with this one.
    *
    * @param \Drupal\Core\Cache\CacheableMetadata $other
diff --git a/core/lib/Drupal/Core/Render/Renderer.php b/core/lib/Drupal/Core/Render/Renderer.php
index 503a26d..09aeb06 100644
--- a/core/lib/Drupal/Core/Render/Renderer.php
+++ b/core/lib/Drupal/Core/Render/Renderer.php
@@ -164,6 +164,12 @@ protected function renderPlaceholder($placeholder, array $elements) {
     return $elements;
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function hasRenderContext() {
+    return isset(static::$context);
+  }
 
   /**
    * {@inheritdoc}
diff --git a/core/lib/Drupal/Core/Render/RendererInterface.php b/core/lib/Drupal/Core/Render/RendererInterface.php
index b55966f..9524c1a 100644
--- a/core/lib/Drupal/Core/Render/RendererInterface.php
+++ b/core/lib/Drupal/Core/Render/RendererInterface.php
@@ -386,4 +386,14 @@ public function mergeBubbleableMetadata(array $a, array $b);
    */
   public function addCacheableDependency(array &$elements, $dependency);
 
+  /**
+   * Checks whether a render context is active.
+   *
+   * @return bool
+   *   TRUE if the renderer has a render context active, FALSE otherwise.
+   *
+   * @see \Drupal\Core\Render\RenderContext
+   */
+  public function hasRenderContext();
+
 }
diff --git a/core/lib/Drupal/Core/Utility/Token.php b/core/lib/Drupal/Core/Utility/Token.php
index 075abb5..09bd16c 100644
--- a/core/lib/Drupal/Core/Utility/Token.php
+++ b/core/lib/Drupal/Core/Utility/Token.php
@@ -8,11 +8,14 @@
 namespace Drupal\Core\Utility;
 
 use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheableDependencyInterface;
+use Drupal\Core\Cache\CacheableMetadata;
 use Drupal\Core\Cache\CacheBackendInterface;
 use Drupal\Core\Cache\CacheTagsInvalidatorInterface;
 use Drupal\Core\Extension\ModuleHandlerInterface;
 use Drupal\Core\Language\LanguageInterface;
 use Drupal\Core\Language\LanguageManagerInterface;
+use Drupal\Core\Render\RendererInterface;
 
 /**
  * Drupal placeholder/token replacement system.
@@ -105,6 +108,13 @@ class Token {
   protected $cacheTagsInvalidator;
 
   /**
+   * The renderer.
+   *
+   * @var \Drupal\Core\Render\RendererInterface
+   */
+  protected $renderer;
+
+  /**
    * Constructs a new class instance.
    *
    * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
@@ -115,17 +125,30 @@ class Token {
    *   The language manager.
    * @param \Drupal\Core\Cache\CacheTagsInvalidatorInterface $cache_tags_invalidator
    *   The cache tags invalidator.
+   * @param \Drupal\Core\Render\RendererInterface $renderer
+   *   The renderer.
    */
-  public function __construct(ModuleHandlerInterface $module_handler, CacheBackendInterface $cache, LanguageManagerInterface $language_manager, CacheTagsInvalidatorInterface $cache_tags_invalidator) {
+  public function __construct(ModuleHandlerInterface $module_handler, CacheBackendInterface $cache, LanguageManagerInterface $language_manager, CacheTagsInvalidatorInterface $cache_tags_invalidator, RendererInterface $renderer) {
     $this->cache = $cache;
     $this->languageManager = $language_manager;
     $this->moduleHandler = $module_handler;
     $this->cacheTagsInvalidator = $cache_tags_invalidator;
+    $this->renderer = $renderer;
   }
 
   /**
    * Replaces all tokens in a given string with appropriate values.
    *
+   * Tokens can also define cacheable metadata related to themselves which can
+   * therefore be applied e.g to a render array.
+   * @code
+   *  $cacheable_metadata = new CacheableMetadata();
+   *  // Token::replace takes $cacheable_metadata as a reference so that it
+   *  // can be applied to the render array.
+   *  $build['#markup'] = $token->replace('Tokens: [node:nid] [current-user:uid]', ['node' => $node], [], $cacheable_metadata);
+   *  $cacheable_metadata->applyTo($build);
+   * @endcode
+   *
    * @param string $text
    *   A string potentially containing replaceable tokens.
    * @param array $data
@@ -152,19 +175,25 @@ public function __construct(ModuleHandlerInterface $module_handler, CacheBackend
    *     \Drupal\Component\Utility\Xss::filter(),
    *     \Drupal\Component\Utility\SafeMarkup::checkPlain() or other appropriate
    *     scrubbing functions before displaying data to users.
+   * @param \Drupal\Core\Cache\CacheableMetadata &$cacheable_metadata|null
+   *   (optional) The cacheablity metadata. In case its not specified it will
+   *   bubble up to the render context, if any.
    *
    * @return string
    *   Text with tokens replaced.
    */
-  public function replace($text, array $data = array(), array $options = array()) {
+  public function replace($text, array $data = array(), array $options = array(), CacheableMetadata $cacheable_metadata = NULL) {
     $text_tokens = $this->scan($text);
     if (empty($text_tokens)) {
       return $text;
     }
 
+    $cacheable_metadata_is_passed_in = (bool) $cacheable_metadata;
+    $cacheable_metadata = $cacheable_metadata ?: new CacheableMetadata();
+
     $replacements = array();
     foreach ($text_tokens as $type => $tokens) {
-      $replacements += $this->generate($type, $tokens, $data, $options);
+      $replacements += $this->generate($type, $tokens, $data, $options, $cacheable_metadata);
       if (!empty($options['clear'])) {
         $replacements += array_fill_keys($tokens, '');
       }
@@ -173,12 +202,19 @@ public function replace($text, array $data = array(), array $options = array())
     // Optionally alter the list of replacement values.
     if (!empty($options['callback'])) {
       $function = $options['callback'];
-      $function($replacements, $data, $options);
+      $function($replacements, $data, $options, $cacheable_metadata);
     }
 
     $tokens = array_keys($replacements);
     $values = array_values($replacements);
 
+    // Ensure that cacheability metadata ends up on the render context.
+    if (!$cacheable_metadata_is_passed_in && $this->renderer->hasRenderContext()) {
+      $build = [];
+      $cacheable_metadata->applyTo($build);
+      $this->renderer->render($build);
+    }
+
     return str_replace($tokens, $values, $text);
   }
 
@@ -226,13 +262,13 @@ public function scan($text) {
    *   An array of tokens to be replaced, keyed by the literal text of the token
    *   as it appeared in the source text.
    * @param array $data
-   *   (optional) An array of keyed objects. For simple replacement scenarios
+   *   An array of keyed objects. For simple replacement scenarios
    *   'node', 'user', and others are common keys, with an accompanying node or
    *   user object being the value. Some token types, like 'site', do not require
    *   any explicit information from $data and can be replaced even if it is
    *   empty.
    * @param array $options
-   *   (optional) A keyed array of settings and flags to control the token
+   *   A keyed array of settings and flags to control the token
    *   replacement process. Supported options are:
    *   - langcode: A language code to be used when generating locale-sensitive
    *     tokens.
@@ -245,6 +281,9 @@ public function scan($text) {
    *     responsibility for running \Drupal\Component\Utility\Xss::filter(),
    *     \Drupal\Component\Utility\SafeMarkup::checkPlain() or other appropriate
    *     scrubbing functions before displaying data to users.
+   * @param \Drupal\Core\Cache\CacheableMetadata &$cacheable_metadata
+   *    The cacheablity metadata. This is passed to lower token implementations
+   *    so they can attach their metadata.
    *
    * @return array
    *   An associative array of replacement values, keyed by the original 'raw'
@@ -254,9 +293,16 @@ public function scan($text) {
    * @see hook_tokens()
    * @see hook_tokens_alter()
    */
-  public function generate($type, array $tokens, array $data = array(), array $options = array()) {
+  public function generate($type, array $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
     $options += array('sanitize' => TRUE);
-    $replacements = $this->moduleHandler->invokeAll('tokens', array($type, $tokens, $data, $options));
+
+    foreach ($data as $object) {
+      if ($object instanceof CacheableDependencyInterface) {
+        $cacheable_metadata->addCacheableDependency($object);
+      }
+    }
+
+    $replacements = $this->moduleHandler->invokeAll('tokens', [$type, $tokens, $data, $options, $cacheable_metadata]);
 
     // Allow other modules to alter the replacements.
     $context = array(
@@ -265,7 +311,7 @@ public function generate($type, array $tokens, array $data = array(), array $opt
       'data' => $data,
       'options' => $options,
     );
-    $this->moduleHandler->alter('tokens', $replacements, $context);
+    $this->moduleHandler->alter('tokens', $replacements, $context, $cacheable_metadata);
 
     return $replacements;
   }
diff --git a/core/lib/Drupal/Core/Utility/token.api.php b/core/lib/Drupal/Core/Utility/token.api.php
index 51133de..1416106 100644
--- a/core/lib/Drupal/Core/Utility/token.api.php
+++ b/core/lib/Drupal/Core/Utility/token.api.php
@@ -34,22 +34,29 @@
  *   An array of tokens to be replaced. The keys are the machine-readable token
  *   names, and the values are the raw [type:token] strings that appeared in the
  *   original text.
- * @param $data
- *   (optional) An associative array of data objects to be used when generating
+ * @param array $data
+ *   An associative array of data objects to be used when generating
  *   replacement values, as supplied in the $data parameter to
  *   \Drupal\Core\Utility\Token::replace().
- * @param $options
- *   (optional) An associative array of options for token replacement; see
+ * @param array $options
+ *   An associative array of options for token replacement; see
  *   \Drupal\Core\Utility\Token::replace() for possible values.
+ * @param \Drupal\Core\Cache\CacheableMetadata $cacheable_metadata
+ *   The cacheability metadata. By default we gather cacheability metadata from
+ *   the passed $data objects. For related objects such as authors of nodes, the
+ *   hook implementation needs to take into account cacheability of those
+ *   related objects as well. And finally, for global tokens, it is necessary to
+ *   take into account cacheability of the underlying object as well, like the
+ *   'system.site' config object for the 'site:name' token.
  *
- * @return
+ * @return array
  *   An associative array of replacement values, keyed by the raw [type:token]
  *   strings from the original text.
  *
  * @see hook_token_info()
  * @see hook_tokens_alter()
  */
-function hook_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function hook_tokens($type, $tokens, array $data, array $options, \Drupal\Core\Cache\CacheableMetadata $cacheable_metadata) {
   $token_service = \Drupal::token();
 
   $url_options = array('absolute' => TRUE);
@@ -87,6 +94,7 @@ function hook_tokens($type, $tokens, array $data = array(), array $options = arr
         case 'author':
           $account = $node->getOwner() ? $node->getOwner() : User::load(0);
           $replacements[$original] = $sanitize ? SafeMarkup::checkPlain($account->label()) : $account->label();
+          $cacheable_metadata->addCacheableDependency($account);
           break;
 
         case 'created':
@@ -96,11 +104,11 @@ function hook_tokens($type, $tokens, array $data = array(), array $options = arr
     }
 
     if ($author_tokens = $token_service->findWithPrefix($tokens, 'author')) {
-      $replacements = $token_service->generate('user', $author_tokens, array('user' => $node->getOwner()), $options);
+      $replacements = $token_service->generate('user', $author_tokens, array('user' => $node->getOwner()), $options, $cacheable_metadata);
     }
 
     if ($created_tokens = $token_service->findWithPrefix($tokens, 'created')) {
-      $replacements = $token_service->generate('date', $created_tokens, array('date' => $node->getCreatedTime()), $options);
+      $replacements = $token_service->generate('date', $created_tokens, array('date' => $node->getCreatedTime()), $options, $cacheable_metadata);
     }
   }
 
@@ -120,10 +128,13 @@ function hook_tokens($type, $tokens, array $data = array(), array $options = arr
  *   - 'tokens'
  *   - 'data'
  *   - 'options'
+ * @param \Drupal\Core\Cache\CacheableMetadata $cacheable_metadata
+ *   The cacheability metadata. In case you alter an existing token based upon
+ *   cacheability metadata, the implementation needs to take that into account.
  *
  * @see hook_tokens()
  */
-function hook_tokens_alter(array &$replacements, array $context) {
+function hook_tokens_alter(array &$replacements, array $context, \Drupal\Core\Cache\CacheableMetadata $cacheable_metadata) {
   $options = $context['options'];
 
   if (isset($options['langcode'])) {
diff --git a/core/modules/comment/comment.tokens.inc b/core/modules/comment/comment.tokens.inc
index 1d20b11..f335cc8 100644
--- a/core/modules/comment/comment.tokens.inc
+++ b/core/modules/comment/comment.tokens.inc
@@ -7,6 +7,8 @@
 
 use Drupal\Component\Utility\SafeMarkup;
 use Drupal\Component\Utility\Xss;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Datetime\Entity\DateFormat;
 
 /**
  * Implements hook_token_info().
@@ -105,7 +107,7 @@ function comment_token_info() {
 /**
  * Implements hook_tokens().
  */
-function comment_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function comment_tokens($type, $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
   $token_service = \Drupal::token();
 
   $url_options = array('absolute' => TRUE);
@@ -176,20 +178,26 @@ function comment_tokens($type, $tokens, array $data = array(), array $options =
         case 'parent':
           if ($comment->hasParentComment()) {
             $parent = $comment->getParentComment();
+            $cacheable_metadata->addCacheableDependency($parent);
             $replacements[$original] = $sanitize ? Xss::filter($parent->getSubject()) : $parent->getSubject();
           }
           break;
 
         case 'created':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($comment->getCreatedTime(), 'medium', '', NULL, $langcode);
           break;
 
         case 'changed':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($comment->getChangedTime(), 'medium', '', NULL, $langcode);
           break;
 
         case 'entity':
           $entity = $comment->getCommentedEntity();
+          $cacheable_metadata->addCacheableDependency($entity);
           $title = $entity->label();
           $replacements[$original] = $sanitize ? Xss::filter($title) : $title;
           break;
@@ -199,23 +207,23 @@ function comment_tokens($type, $tokens, array $data = array(), array $options =
     // Chained token relationships.
     if ($entity_tokens = $token_service->findwithPrefix($tokens, 'entity')) {
       $entity = $comment->getCommentedEntity();
-      $replacements += $token_service->generate($comment->getCommentedEntityTypeId(), $entity_tokens, array($comment->getCommentedEntityTypeId() => $entity), $options);
+      $replacements += $token_service->generate($comment->getCommentedEntityTypeId(), $entity_tokens, array($comment->getCommentedEntityTypeId() => $entity), $options, $cacheable_metadata);
     }
 
     if ($date_tokens = $token_service->findwithPrefix($tokens, 'created')) {
-      $replacements += $token_service->generate('date', $date_tokens, array('date' => $comment->getCreatedTime()), $options);
+      $replacements += $token_service->generate('date', $date_tokens, array('date' => $comment->getCreatedTime()), $options, $cacheable_metadata);
     }
 
     if ($date_tokens = $token_service->findwithPrefix($tokens, 'changed')) {
-      $replacements += $token_service->generate('date', $date_tokens, array('date' => $comment->getChangedTime()), $options);
+      $replacements += $token_service->generate('date', $date_tokens, array('date' => $comment->getChangedTime()), $options, $cacheable_metadata);
     }
 
     if (($parent_tokens = $token_service->findwithPrefix($tokens, 'parent')) && $parent = $comment->getParentComment()) {
-      $replacements += $token_service->generate('comment', $parent_tokens, array('comment' => $parent), $options);
+      $replacements += $token_service->generate('comment', $parent_tokens, array('comment' => $parent), $options, $cacheable_metadata);
     }
 
     if (($author_tokens = $token_service->findwithPrefix($tokens, 'author')) && $account = $comment->getOwner()) {
-      $replacements += $token_service->generate('user', $author_tokens, array('user' => $account), $options);
+      $replacements += $token_service->generate('user', $author_tokens, array('user' => $account), $options, $cacheable_metadata);
     }
   }
   elseif ($type == 'entity' & !empty($data['entity'])) {
diff --git a/core/modules/comment/src/Tests/CommentTokenReplaceTest.php b/core/modules/comment/src/Tests/CommentTokenReplaceTest.php
index 3c6b48a..b5fc024 100644
--- a/core/modules/comment/src/Tests/CommentTokenReplaceTest.php
+++ b/core/modules/comment/src/Tests/CommentTokenReplaceTest.php
@@ -10,6 +10,7 @@
 use Drupal\Component\Utility\SafeMarkup;
 use Drupal\Component\Utility\Xss;
 use Drupal\comment\Entity\Comment;
+use Drupal\Core\Cache\CacheableMetadata;
 use Drupal\node\Entity\Node;
 
 /**
@@ -60,6 +61,7 @@ function testCommentTokenReplacement() {
     $tests['[comment:langcode]'] = SafeMarkup::checkPlain($comment->language()->getId());
     $tests['[comment:url]'] = $comment->url('canonical', $url_options + array('fragment' => 'comment-' . $comment->id()));
     $tests['[comment:edit-url]'] = $comment->url('edit-form', $url_options);
+    $tests['[comment:created]'] = \Drupal::service('date.formatter')->format($comment->getCreatedTime(), 'medium', array('langcode' => $language_interface->getId()));
     $tests['[comment:created:since]'] = \Drupal::service('date.formatter')->formatTimeDiffSince($comment->getCreatedTime(), array('langcode' => $language_interface->getId()));
     $tests['[comment:changed:since]'] = \Drupal::service('date.formatter')->formatTimeDiffSince($comment->getChangedTimeAcrossTranslations(), array('langcode' => $language_interface->getId()));
     $tests['[comment:parent:cid]'] = $comment->hasParentComment() ? $comment->getParentComment()->id() : NULL;
@@ -71,12 +73,44 @@ function testCommentTokenReplacement() {
     $tests['[comment:author:uid]'] = $comment->getOwnerId();
     $tests['[comment:author:name]'] = SafeMarkup::checkPlain($this->adminUser->getUsername());
 
+    $base_cacheable_metadata = CacheableMetadata::createFromObject($comment);
+    $metadata_tests = [];
+    $metadata_tests['[comment:cid]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:hostname]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:author]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:mail]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:homepage]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:title]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:body]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:langcode]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:url]'] = $base_cacheable_metadata;
+    $metadata_tests['[comment:edit-url]'] = $base_cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[comment:created]'] = $cacheable_metadata->addCacheTags(['rendered']);
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[comment:created:since]'] = $cacheable_metadata->setCacheMaxAge(0);
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[comment:changed:since]'] = $cacheable_metadata->setCacheMaxAge(0);
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[comment:parent:cid]'] = $cacheable_metadata->addCacheTags(['comment:1']);
+    $metadata_tests['[comment:parent:title]'] = $cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[comment:entity]'] = $cacheable_metadata->addCacheTags(['node:2']);
+    // Test node specific tokens.
+    $metadata_tests['[comment:entity:nid]'] = $cacheable_metadata;
+    $metadata_tests['[comment:entity:title]'] = $cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[comment:author:uid]'] = $cacheable_metadata->addCacheTags(['user:2']);
+    $metadata_tests['[comment:author:name]'] = $cacheable_metadata;
+
     // Test to make sure that we generated something for each token.
     $this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
 
     foreach ($tests as $input => $expected) {
-      $output = $token_service->replace($input, array('comment' => $comment), array('langcode' => $language_interface->getId()));
+      $cacheable_metadata = new CacheableMetadata();
+      $output = $token_service->replace($input, array('comment' => $comment), array('langcode' => $language_interface->getId()), $cacheable_metadata);
       $this->assertEqual($output, $expected, format_string('Sanitized comment token %token replaced.', array('%token' => $input)));
+      $this->assertEqual($cacheable_metadata, $metadata_tests[$input]);
     }
 
     // Generate and test unsanitized tokens.
diff --git a/core/modules/file/file.module b/core/modules/file/file.module
index 2458582..4c03673 100644
--- a/core/modules/file/file.module
+++ b/core/modules/file/file.module
@@ -6,6 +6,8 @@
  */
 
 use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Datetime\Entity\DateFormat;
 use Drupal\Core\Field\FieldDefinitionInterface;
 use Drupal\Core\Form\FormStateInterface;
 use Drupal\Core\Render\Element;
@@ -938,7 +940,7 @@ function file_file_predelete(File $file) {
 /**
  * Implements hook_tokens().
  */
-function file_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function file_tokens($type, $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
   $token_service = \Drupal::token();
 
   $url_options = array('absolute' => TRUE);
@@ -987,30 +989,36 @@ function file_tokens($type, $tokens, array $data = array(), array $options = arr
 
         // These tokens are default variations on the chained tokens handled below.
         case 'created':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($file->getCreatedTime(), 'medium', '', NULL, $langcode);
           break;
 
         case 'changed':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata = $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($file->getChangedTime(), 'medium', '', NULL, $langcode);
           break;
 
         case 'owner':
-          $name = $file->getOwner()->label();
+          $owner = $file->getOwner();
+          $cacheable_metadata->addCacheableDependency($owner);
+          $name = $owner->label();
           $replacements[$original] = $sanitize ? SafeMarkup::checkPlain($name) : $name;
           break;
       }
     }
 
     if ($date_tokens = $token_service->findWithPrefix($tokens, 'created')) {
-      $replacements += $token_service->generate('date', $date_tokens, array('date' => $file->getCreatedTime()), $options);
+      $replacements += $token_service->generate('date', $date_tokens, array('date' => $file->getCreatedTime()), $options, $cacheable_metadata);
     }
 
     if ($date_tokens = $token_service->findWithPrefix($tokens, 'changed')) {
-      $replacements += $token_service->generate('date', $date_tokens, array('date' => $file->getChangedTime()), $options);
+      $replacements += $token_service->generate('date', $date_tokens, array('date' => $file->getChangedTime()), $options, $cacheable_metadata);
     }
 
     if (($owner_tokens = $token_service->findWithPrefix($tokens, 'owner')) && $file->getOwner()) {
-      $replacements += $token_service->generate('user', $owner_tokens, array('user' => $file->getOwner()), $options);
+      $replacements += $token_service->generate('user', $owner_tokens, array('user' => $file->getOwner()), $options, $cacheable_metadata);
     }
   }
 
diff --git a/core/modules/file/src/Tests/FileTokenReplaceTest.php b/core/modules/file/src/Tests/FileTokenReplaceTest.php
index f5f478a..67f6cf0 100644
--- a/core/modules/file/src/Tests/FileTokenReplaceTest.php
+++ b/core/modules/file/src/Tests/FileTokenReplaceTest.php
@@ -9,6 +9,7 @@
 
 use Drupal\Component\Utility\SafeMarkup;
 use Drupal\file\Entity\File;
+use Drupal\Core\Cache\CacheableMetadata;
 
 /**
  * Generates text using placeholders for dummy content to check file token
@@ -58,12 +59,31 @@ function testFileTokenReplacement() {
     $tests['[file:owner]'] = SafeMarkup::checkPlain(user_format_name($this->adminUser));
     $tests['[file:owner:uid]'] = $file->getOwnerId();
 
+    $base_cacheable_metadata = CacheableMetadata::createFromObject($file);
+    $metadata_tests = [];
+    $metadata_tests['[file:fid]'] = $base_cacheable_metadata;
+    $metadata_tests['[file:name]'] = $base_cacheable_metadata;
+    $metadata_tests['[file:path]'] = $base_cacheable_metadata;
+    $metadata_tests['[file:mime]'] = $base_cacheable_metadata;
+    $metadata_tests['[file:size]'] = $base_cacheable_metadata;
+    $metadata_tests['[file:url]'] = $base_cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[file:created]'] = $cacheable_metadata->addCacheTags(['rendered']);
+    $metadata_tests['[file:created:short]'] = $cacheable_metadata;
+    $metadata_tests['[file:changed]'] = $cacheable_metadata;
+    $metadata_tests['[file:changed:short]'] = $cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[file:owner]'] = $cacheable_metadata->addCacheTags(['user:2']);
+    $metadata_tests['[file:owner:uid]'] = $cacheable_metadata;
+
     // Test to make sure that we generated something for each token.
     $this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
 
     foreach ($tests as $input => $expected) {
-      $output = $token_service->replace($input, array('file' => $file), array('langcode' => $language_interface->getId()));
+      $cacheable_metadata = new CacheableMetadata();
+      $output = $token_service->replace($input, array('file' => $file), array('langcode' => $language_interface->getId()), $cacheable_metadata);
       $this->assertEqual($output, $expected, format_string('Sanitized file token %token replaced.', array('%token' => $input)));
+      $this->assertEqual($cacheable_metadata, $metadata_tests[$input]);
     }
 
     // Generate and test unsanitized tokens.
diff --git a/core/modules/node/node.tokens.inc b/core/modules/node/node.tokens.inc
index 7f8d50a..240e2ce 100644
--- a/core/modules/node/node.tokens.inc
+++ b/core/modules/node/node.tokens.inc
@@ -6,6 +6,8 @@
  */
 
 use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Datetime\Entity\DateFormat;
 use Drupal\Core\Language\LanguageInterface;
 use Drupal\user\Entity\User;
 
@@ -83,7 +85,7 @@ function node_token_info() {
 /**
  * Implements hook_tokens().
  */
-function node_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function node_tokens($type, $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
   $token_service = \Drupal::token();
 
   $url_options = array('absolute' => TRUE);
@@ -176,29 +178,34 @@ function node_tokens($type, $tokens, array $data = array(), array $options = arr
         // Default values for the chained tokens handled below.
         case 'author':
           $account = $node->getOwner() ? $node->getOwner() : User::load(0);
+          $cacheable_metadata->addCacheableDependency($account);
           $replacements[$original] = $sanitize ? SafeMarkup::checkPlain($account->label()) : $account->label();
           break;
 
         case 'created':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($node->getCreatedTime(), 'medium', '', NULL, $langcode);
           break;
 
         case 'changed':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($node->getChangedTime(), 'medium', '', NULL, $langcode);
           break;
       }
     }
 
     if ($author_tokens = $token_service->findWithPrefix($tokens, 'author')) {
-      $replacements += $token_service->generate('user', $author_tokens, array('user' => $node->getOwner()), $options);
+      $replacements += $token_service->generate('user', $author_tokens, array('user' => $node->getOwner()), $options, $cacheable_metadata);
     }
 
     if ($created_tokens = $token_service->findWithPrefix($tokens, 'created')) {
-      $replacements += $token_service->generate('date', $created_tokens, array('date' => $node->getCreatedTime()), $options);
+      $replacements += $token_service->generate('date', $created_tokens, array('date' => $node->getCreatedTime()), $options, $cacheable_metadata);
     }
 
     if ($changed_tokens = $token_service->findWithPrefix($tokens, 'changed')) {
-      $replacements += $token_service->generate('date', $changed_tokens, array('date' => $node->getChangedTime()), $options);
+      $replacements += $token_service->generate('date', $changed_tokens, array('date' => $node->getChangedTime()), $options, $cacheable_metadata);
     }
   }
 
diff --git a/core/modules/node/src/Tests/NodeTokenReplaceTest.php b/core/modules/node/src/Tests/NodeTokenReplaceTest.php
index f4f7d26..8b28159 100644
--- a/core/modules/node/src/Tests/NodeTokenReplaceTest.php
+++ b/core/modules/node/src/Tests/NodeTokenReplaceTest.php
@@ -7,6 +7,7 @@
 
 namespace Drupal\node\Tests;
 
+use Drupal\Core\Cache\CacheableMetadata;
 use Drupal\system\Tests\System\TokenReplaceUnitTestBase;
 use Drupal\Component\Utility\SafeMarkup;
 
@@ -76,12 +77,35 @@ function testNodeTokenReplacement() {
     $tests['[node:created:since]'] = \Drupal::service('date.formatter')->formatTimeDiffSince($node->getCreatedTime(), array('langcode' => $this->interfaceLanguage->getId()));
     $tests['[node:changed:since]'] = \Drupal::service('date.formatter')->formatTimeDiffSince($node->getChangedTime(), array('langcode' => $this->interfaceLanguage->getId()));
 
+    $base_cacheable_metadata = CacheableMetadata::createFromObject($node);
+
+    $metadata_tests = [];
+    $metadata_tests['[node:nid]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:vid]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:type]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:type-name]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:title]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:body]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:summary]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:langcode]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:url]'] = $base_cacheable_metadata;
+    $metadata_tests['[node:edit-url]'] = $base_cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[node:author]'] = $cacheable_metadata->addCacheTags(['user:1']);
+    $metadata_tests['[node:author:uid]'] = $cacheable_metadata;
+    $metadata_tests['[node:author:name]'] = $cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[node:created:since]'] = $cacheable_metadata->setCacheMaxAge(0);
+    $metadata_tests['[node:changed:since]'] = $cacheable_metadata;
+
     // Test to make sure that we generated something for each token.
     $this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
 
     foreach ($tests as $input => $expected) {
-      $output = $this->tokenService->replace($input, array('node' => $node), array('langcode' => $this->interfaceLanguage->getId()));
+      $cacheable_metadata = new CacheableMetadata();
+      $output = $this->tokenService->replace($input, array('node' => $node), array('langcode' => $this->interfaceLanguage->getId()), $cacheable_metadata);
       $this->assertEqual($output, $expected, format_string('Sanitized node token %token replaced.', array('%token' => $input)));
+      $this->assertEqual($cacheable_metadata, $metadata_tests[$input]);
     }
 
     // Generate and test unsanitized tokens.
diff --git a/core/modules/node/src/Tests/Views/FrontPageTest.php b/core/modules/node/src/Tests/Views/FrontPageTest.php
index 9a68a06..e733969 100644
--- a/core/modules/node/src/Tests/Views/FrontPageTest.php
+++ b/core/modules/node/src/Tests/Views/FrontPageTest.php
@@ -262,12 +262,12 @@ protected function assertFrontPageViewCacheTags($do_assert_views_caches) {
       $view,
       $empty_node_listing_cache_tags,
       $do_assert_views_caches,
-      Cache::mergeTags($empty_node_listing_cache_tags, $cache_context_tags)
+      Cache::mergeTags($empty_node_listing_cache_tags, $cache_context_tags, ['config:system.site'])
     );
     $this->assertPageCacheContextsAndTags(
       Url::fromRoute('view.frontpage.page_1'),
       $cache_contexts,
-      Cache::mergeTags($empty_node_listing_cache_tags, $cache_context_tags, ['rendered', 'config:user.role.anonymous'])
+      Cache::mergeTags($empty_node_listing_cache_tags, $cache_context_tags, ['rendered', 'config:user.role.anonymous', 'config:system.site'])
     );
 
     // Create some nodes on the frontpage view. Add more than 10 nodes in order
diff --git a/core/modules/statistics/statistics.tokens.inc b/core/modules/statistics/statistics.tokens.inc
index d2be86c..88f41fb 100644
--- a/core/modules/statistics/statistics.tokens.inc
+++ b/core/modules/statistics/statistics.tokens.inc
@@ -5,6 +5,8 @@
  * Builds placeholder replacement tokens for node visitor statistics.
  */
 
+use Drupal\Core\Cache\CacheableMetadata;
+
 /**
  * Implements hook_token_info().
  */
@@ -31,7 +33,7 @@ function statistics_token_info() {
 /**
  * Implements hook_tokens().
  */
-function statistics_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function statistics_tokens($type, $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
   $token_service = \Drupal::token();
 
   $replacements = array();
@@ -56,7 +58,7 @@ function statistics_tokens($type, $tokens, array $data = array(), array $options
 
     if ($created_tokens = $token_service->findWithPrefix($tokens, 'last-view')) {
       $statistics = statistics_get($node->id());
-      $replacements += $token_service->generate('date', $created_tokens, array('date' => $statistics['timestamp']), $options);
+      $replacements += $token_service->generate('date', $created_tokens, array('date' => $statistics['timestamp']), $options, $cacheable_metadata);
     }
   }
 
diff --git a/core/modules/system/src/Tests/System/TokenReplaceUnitTest.php b/core/modules/system/src/Tests/System/TokenReplaceUnitTest.php
index f98c373..c0505e1 100644
--- a/core/modules/system/src/Tests/System/TokenReplaceUnitTest.php
+++ b/core/modules/system/src/Tests/System/TokenReplaceUnitTest.php
@@ -9,6 +9,7 @@
 
 use Drupal\Component\Utility\SafeMarkup;
 use Drupal\Component\Utility\Xss;
+use Drupal\Core\Cache\CacheableMetadata;
 
 /**
  * Generates text using placeholders for dummy content to check token
@@ -111,12 +112,25 @@ public function testSystemSiteTokenReplacement() {
     $tests['[site:url-brief]'] = preg_replace(array('!^https?://!', '!/$!'), '', \Drupal::url('<front>', [], $url_options));
     $tests['[site:login-url]'] = \Drupal::url('user.page', [], $url_options);
 
+    $base_cacheable_metadata = new CacheableMetadata();
+
+    $metadata_tests = [];
+    $metadata_tests['[site:name]'] = CacheableMetadata::createFromObject(\Drupal::config('system.site'));
+    $metadata_tests['[site:slogan]'] = CacheableMetadata::createFromObject(\Drupal::config('system.site'));
+    $metadata_tests['[site:mail]'] = CacheableMetadata::createFromObject(\Drupal::config('system.site'));
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[site:url]'] = $cacheable_metadata->addCacheContexts(['url.site']);
+    $metadata_tests['[site:url-brief]'] = $cacheable_metadata;
+    $metadata_tests['[site:login-url]'] = $cacheable_metadata;
+
     // Test to make sure that we generated something for each token.
     $this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
 
     foreach ($tests as $input => $expected) {
-      $output = $this->tokenService->replace($input, array(), array('langcode' => $this->interfaceLanguage->getId()));
+      $cacheable_metadata = new CacheableMetadata();
+      $output = $this->tokenService->replace($input, array(), array('langcode' => $this->interfaceLanguage->getId()), $cacheable_metadata);
       $this->assertEqual($output, $expected, format_string('Sanitized system site information token %token replaced.', array('%token' => $input)));
+      $this->assertEqual($cacheable_metadata, $metadata_tests[$input]);
     }
 
     // Generate and test unsanitized tokens.
@@ -124,7 +138,7 @@ public function testSystemSiteTokenReplacement() {
     $tests['[site:slogan]'] = $config->get('slogan');
 
     foreach ($tests as $input => $expected) {
-      $output = $this->tokenService->replace($input, array(), array('langcode' => $this->interfaceLanguage->getId(), 'sanitize' => FALSE));
+      $output = $this->tokenService->replace($input, array(), array('langcode' => $this->interfaceLanguage->getId(), 'sanitize' => FALSE), $cacheable_metadata);
       $this->assertEqual($output, $expected, format_string('Unsanitized system site information token %token replaced.', array('%token' => $input)));
     }
 
@@ -133,10 +147,10 @@ public function testSystemSiteTokenReplacement() {
     // flag is being passed properly through the call stack and being handled
     // correctly by a 'known' token, [site:slogan].
     $raw_tokens = array('slogan' => '[site:slogan]');
-    $generated = $this->tokenService->generate('site', $raw_tokens);
+    $generated = $this->tokenService->generate('site', $raw_tokens, [], [], $cacheable_metadata);
     $this->assertEqual($generated['[site:slogan]'], $safe_slogan, 'Token sanitized.');
 
-    $generated = $this->tokenService->generate('site', $raw_tokens, array(), array('sanitize' => FALSE));
+    $generated = $this->tokenService->generate('site', $raw_tokens, array(), array('sanitize' => FALSE), $cacheable_metadata);
     $this->assertEqual($generated['[site:slogan]'], $slogan, 'Unsanitized token generated properly.');
   }
 
diff --git a/core/modules/system/src/Tests/System/TokenReplaceWebTest.php b/core/modules/system/src/Tests/System/TokenReplaceWebTest.php
new file mode 100644
index 0000000..0528498
--- /dev/null
+++ b/core/modules/system/src/Tests/System/TokenReplaceWebTest.php
@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\system\Tests\System\TokenReplaceWebTest.
+ */
+
+namespace Drupal\system\Tests\System;
+
+use Drupal\simpletest\WebTestBase;
+use Drupal\system\Tests\Cache\AssertPageCacheContextsAndTagsTrait;
+
+/**
+ * Tests the token system integration.
+ *
+ * @group system
+ */
+class TokenReplaceWebTest extends WebTestBase {
+
+  use AssertPageCacheContextsAndTagsTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['token_test', 'filter', 'node'];
+
+  /**
+   * Tests a token replacement on an actual website.
+   */
+  public function testTokens() {
+    $node = $this->drupalCreateNode();
+    $account = $this->drupalCreateUser();
+    $this->drupalLogin($account);
+
+    $this->drupalGet('token-test/' . $node->id());
+    $this->assertText("Tokens: {$node->id()} {$account->id()}");
+    $this->assertCacheTags(['node:1', 'rendered', 'user:2']);
+    $this->assertCacheContexts(['languages:language_interface', 'theme', 'user']);
+
+    $this->drupalGet('token-test-without-cacheable-metadata/' . $node->id());
+    $this->assertText("Tokens: {$node->id()} {$account->id()}");
+    $this->assertCacheTags(['node:1', 'rendered', 'user:2']);
+    $this->assertCacheContexts(['languages:language_interface', 'theme', 'user']);
+  }
+
+}
diff --git a/core/modules/system/system.tokens.inc b/core/modules/system/system.tokens.inc
index 20d5ec1..252ef18 100644
--- a/core/modules/system/system.tokens.inc
+++ b/core/modules/system/system.tokens.inc
@@ -9,6 +9,8 @@
 
 use Drupal\Component\Utility\SafeMarkup;
 use Drupal\Component\Utility\Xss;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Datetime\Entity\DateFormat;
 
 /**
  * Implements hook_token_info().
@@ -87,7 +89,7 @@ function system_token_info() {
 /**
  * Implements hook_tokens().
  */
-function system_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function system_tokens($type, $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
   $token_service = \Drupal::token();
 
   $url_options = array('absolute' => TRUE);
@@ -106,29 +108,44 @@ function system_tokens($type, $tokens, array $data = array(), array $options = a
     foreach ($tokens as $name => $original) {
       switch ($name) {
         case 'name':
-          $site_name = \Drupal::config('system.site')->get('name');
+          $config = \Drupal::config('system.site');
+          $cacheable_metadata->addCacheableDependency($config);
+          $site_name = $config->get('name');
           $replacements[$original] = $sanitize ? SafeMarkup::checkPlain($site_name) : $site_name;
           break;
 
         case 'slogan':
-          $slogan = \Drupal::config('system.site')->get('slogan');
+          $config = \Drupal::config('system.site');
+          $cacheable_metadata->addCacheableDependency($config);
+          $slogan = $config->get('slogan');
           $replacements[$original] = $sanitize ? Xss::filterAdmin($slogan) : $slogan;
           break;
 
         case 'mail':
-          $replacements[$original] = \Drupal::config('system.site')->get('mail');
+          $config = \Drupal::config('system.site');
+          $cacheable_metadata->addCacheableDependency($config);
+          $replacements[$original] = $config->get('mail');
           break;
 
         case 'url':
-          $replacements[$original] = \Drupal::url('<front>', array(), $url_options);
+          /** @var \Drupal\Core\GeneratedUrl $result */
+          $result = \Drupal::url('<front>', array(), $url_options, TRUE);
+          $cacheable_metadata->addCacheableDependency($result);
+          $replacements[$original] = $result->getGeneratedUrl();
           break;
 
         case 'url-brief':
-          $replacements[$original] = preg_replace(array('!^https?://!', '!/$!'), '', \Drupal::url('<front>', array(), $url_options));
+          /** @var \Drupal\Core\GeneratedUrl $result */
+          $result = \Drupal::url('<front>', array(), $url_options, TRUE);
+          $cacheable_metadata->addCacheableDependency($result);
+          $replacements[$original] = preg_replace(array('!^https?://!', '!/$!'), '', $result->getGeneratedUrl());
           break;
 
         case 'login-url':
-          $replacements[$original] = \Drupal::url('user.page', [], $url_options);
+          /** @var \Drupal\Core\GeneratedUrl $result */
+          $result = \Drupal::url('user.page', [], $url_options, TRUE);
+          $cacheable_metadata->addCacheableDependency($result);
+          $replacements[$original] = $result->getGeneratedUrl();
           break;
       }
     }
@@ -137,6 +154,9 @@ function system_tokens($type, $tokens, array $data = array(), array $options = a
   elseif ($type == 'date') {
     if (empty($data['date'])) {
       $date = REQUEST_TIME;
+      // We depend on the current request time, so the tokens are not cacheable
+      // at all.
+      $cacheable_metadata->setCacheMaxAge(0);
     }
     else {
       $date = $data['date'];
@@ -145,19 +165,26 @@ function system_tokens($type, $tokens, array $data = array(), array $options = a
     foreach ($tokens as $name => $original) {
       switch ($name) {
         case 'short':
+          $date_format = DateFormat::load('short');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($date, 'short', '', NULL, $langcode);
           break;
 
         case 'medium':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($date, 'medium', '', NULL, $langcode);
           break;
 
         case 'long':
+          $date_format = DateFormat::load('long');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = format_date($date, 'long', '', NULL, $langcode);
           break;
 
         case 'since':
           $replacements[$original] = \Drupal::service('date.formatter')->formatTimeDiffSince($date, array('langcode' => $langcode));
+          $cacheable_metadata->setCacheMaxAge(0);
           break;
 
         case 'raw':
diff --git a/core/modules/system/tests/modules/token_test/src/Controller/TestController.php b/core/modules/system/tests/modules/token_test/src/Controller/TestController.php
new file mode 100644
index 0000000..372575e
--- /dev/null
+++ b/core/modules/system/tests/modules/token_test/src/Controller/TestController.php
@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\token_test\Controller\TestController.
+ */
+
+namespace Drupal\token_test\Controller;
+
+
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Controller\ControllerBase;
+use Drupal\Core\Utility\Token;
+use Drupal\node\NodeInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Provides a test controller for token replacement.
+ */
+class TestController extends ControllerBase {
+
+  /**
+   * The token replacement system.
+   *
+   * @var \Drupal\Core\Utility\Token
+   */
+  protected $token;
+
+  /**
+   * Constructs a new TestController instance.
+   *
+   * @param \Drupal\Core\Utility\Token $token
+   *   The token replacement system.
+   */
+  public function __construct(Token $token) {
+    $this->token = $token;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container) {
+    return new static($container->get('token'));
+  }
+
+  /**
+   * Provides a token replacement with a node as well as the current user.
+   *
+   * @param \Drupal\node\NodeInterface $node
+   *   The node.
+   *
+   * @return array
+   *   The render array.
+   */
+  public function tokenReplace(NodeInterface $node) {
+    $cacheable_metadata = new CacheableMetadata();
+    $build['#markup'] = $this->token->replace('Tokens: [node:nid] [current-user:uid]', ['node' => $node], [], $cacheable_metadata);
+
+    $cacheable_metadata->applyTo($build);
+
+    return $build;
+  }
+
+  /**
+   * Provides a token replacement with a node as well as the current user.
+   *
+   * @param \Drupal\node\NodeInterface $node
+   *   The node.
+   *
+   * @return array
+   *   The render array.
+   */
+  public function tokenReplaceWithoutPassedCacheabilityMetadata(NodeInterface $node) {
+    // Note: We explicitly don't pass the cacheability metadata in order to
+    // ensure that bubbling works.
+    $build['#markup'] = $this->token->replace('Tokens: [node:nid] [current-user:uid]', ['node' => $node], []);
+
+    return $build;
+  }
+
+}
diff --git a/core/modules/system/tests/modules/token_test/token_test.info.yml b/core/modules/system/tests/modules/token_test/token_test.info.yml
new file mode 100644
index 0000000..0f52f63
--- /dev/null
+++ b/core/modules/system/tests/modules/token_test/token_test.info.yml
@@ -0,0 +1,6 @@
+name: Token test
+type: module
+core: 8.x
+dependencies:
+ - user
+ - node
diff --git a/core/modules/system/tests/modules/token_test/token_test.routing.yml b/core/modules/system/tests/modules/token_test/token_test.routing.yml
new file mode 100644
index 0000000..65e3e24
--- /dev/null
+++ b/core/modules/system/tests/modules/token_test/token_test.routing.yml
@@ -0,0 +1,12 @@
+token_test.test:
+  path: token-test/{node}
+  defaults:
+    _controller: Drupal\token_test\Controller\TestController::tokenReplace
+  requirements:
+    _access: 'TRUE'
+token_test.test_without_cacheable_metadata:
+  path: token-test-without-cacheable-metadata/{node}
+  defaults:
+    _controller: Drupal\token_test\Controller\TestController::tokenReplaceWithoutPassedCacheabilityMetadata
+  requirements:
+    _access: 'TRUE'
diff --git a/core/modules/taxonomy/src/Tests/TokenReplaceTest.php b/core/modules/taxonomy/src/Tests/TokenReplaceTest.php
index 1051201..2893aa8 100644
--- a/core/modules/taxonomy/src/Tests/TokenReplaceTest.php
+++ b/core/modules/taxonomy/src/Tests/TokenReplaceTest.php
@@ -9,6 +9,7 @@
 
 use Drupal\Component\Utility\SafeMarkup;
 use Drupal\Component\Utility\Xss;
+use Drupal\Core\Cache\CacheableMetadata;
 use Drupal\Core\Field\FieldStorageDefinitionInterface;
 
 /**
@@ -92,9 +93,23 @@ function testTaxonomyTokenReplacement() {
     $tests['[term:parent:name]'] = '[term:parent:name]';
     $tests['[term:vocabulary:name]'] = SafeMarkup::checkPlain($this->vocabulary->label());
 
+    $base_cacheable_metadata = CacheableMetadata::createFromObject($term1);
+
+    $metadata_tests = array();
+    $metadata_tests['[term:tid]'] = $base_cacheable_metadata;
+    $metadata_tests['[term:name]'] = $base_cacheable_metadata;
+    $metadata_tests['[term:description]'] = $base_cacheable_metadata;
+    $metadata_tests['[term:url]'] = $base_cacheable_metadata;
+    $metadata_tests['[term:node-count]'] = $base_cacheable_metadata;
+    $metadata_tests['[term:parent:name]'] = $base_cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[term:vocabulary:name]'] = $cacheable_metadata->addCacheTags($this->vocabulary->getCacheTags());
+
     foreach ($tests as $input => $expected) {
-      $output = $token_service->replace($input, array('term' => $term1), array('langcode' => $language_interface->getId()));
+      $cacheable_metadata = new CacheableMetadata();
+      $output = $token_service->replace($input, array('term' => $term1), array('langcode' => $language_interface->getId()), $cacheable_metadata);
       $this->assertEqual($output, $expected, format_string('Sanitized taxonomy term token %token replaced.', array('%token' => $input)));
+      $this->assertEqual($cacheable_metadata, $metadata_tests[$input]);
     }
 
     // Generate and test sanitized tokens for term2.
diff --git a/core/modules/taxonomy/taxonomy.tokens.inc b/core/modules/taxonomy/taxonomy.tokens.inc
index f5ba24e..3e66ca2 100644
--- a/core/modules/taxonomy/taxonomy.tokens.inc
+++ b/core/modules/taxonomy/taxonomy.tokens.inc
@@ -7,6 +7,7 @@
 
 use Drupal\Component\Utility\SafeMarkup;
 use Drupal\Component\Utility\Xss;
+use Drupal\Core\Cache\CacheableMetadata;
 use Drupal\taxonomy\Entity\Vocabulary;
 
 /**
@@ -92,7 +93,7 @@ function taxonomy_token_info() {
 /**
  * Implements hook_tokens().
  */
-function taxonomy_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function taxonomy_tokens($type, $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
   $token_service = \Drupal::token();
 
   $replacements = array();
@@ -135,6 +136,7 @@ function taxonomy_tokens($type, $tokens, array $data = array(), array $options =
         case 'parent':
           if ($parents = $taxonomy_storage->loadParents($term->id())) {
             $parent = array_pop($parents);
+            $cacheable_metadata->addCacheableDependency($parent);
             $replacements[$original] = SafeMarkup::checkPlain($parent->getName());
           }
           break;
@@ -143,12 +145,12 @@ function taxonomy_tokens($type, $tokens, array $data = array(), array $options =
 
     if ($vocabulary_tokens = $token_service->findWithPrefix($tokens, 'vocabulary')) {
       $vocabulary = Vocabulary::load($term->bundle());
-      $replacements += $token_service->generate('vocabulary', $vocabulary_tokens, array('vocabulary' => $vocabulary), $options);
+      $replacements += $token_service->generate('vocabulary', $vocabulary_tokens, array('vocabulary' => $vocabulary), $options, $cacheable_metadata);
     }
 
     if (($vocabulary_tokens = $token_service->findWithPrefix($tokens, 'parent')) && $parents = $taxonomy_storage->loadParents($term->id())) {
       $parent = array_pop($parents);
-      $replacements += $token_service->generate('term', $vocabulary_tokens, array('term' => $parent), $options);
+      $replacements += $token_service->generate('term', $vocabulary_tokens, array('term' => $parent), $options, $cacheable_metadata);
     }
   }
 
diff --git a/core/modules/user/src/Tests/UserTokenReplaceTest.php b/core/modules/user/src/Tests/UserTokenReplaceTest.php
index b2dfe6d..8d4b2f1 100644
--- a/core/modules/user/src/Tests/UserTokenReplaceTest.php
+++ b/core/modules/user/src/Tests/UserTokenReplaceTest.php
@@ -8,6 +8,7 @@
 namespace Drupal\user\Tests;
 
 use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Core\Cache\CacheableMetadata;
 use Drupal\language\Entity\ConfigurableLanguage;
 use Drupal\simpletest\WebTestBase;
 use Drupal\user\Entity\User;
@@ -66,12 +67,28 @@ function testUserTokenReplacement() {
     $tests['[user:created:short]'] = format_date($account->getCreatedTime(), 'short', '', NULL, $language_interface->getId());
     $tests['[current-user:name]'] = SafeMarkup::checkPlain(user_format_name($global_account));
 
+    $base_cacheable_metadata = CacheableMetadata::createFromObject($account);
+    $metadata_tests = [];
+    $metadata_tests['[user:uid]'] = $base_cacheable_metadata;
+    $metadata_tests['[user:name]'] = $base_cacheable_metadata;
+    $metadata_tests['[user:mail]'] = $base_cacheable_metadata;
+    $metadata_tests['[user:url]'] = $base_cacheable_metadata;
+    $metadata_tests['[user:edit-url]'] = $base_cacheable_metadata;
+    $cacheable_metadata = clone $base_cacheable_metadata;
+    $metadata_tests['[user:last-login]'] = $cacheable_metadata->addCacheTags(['rendered']);
+    $metadata_tests['[user:last-login:short]'] = $cacheable_metadata;
+    $metadata_tests['[user:created]'] = $cacheable_metadata;
+    $metadata_tests['[user:created:short]'] = $cacheable_metadata;
+    $metadata_tests['[current-user:name]'] = $base_cacheable_metadata->merge(CacheableMetadata::createFromObject($global_account)->addCacheContexts(['user']));
+
     // Test to make sure that we generated something for each token.
     $this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
 
     foreach ($tests as $input => $expected) {
-      $output = $token_service->replace($input, array('user' => $account), array('langcode' => $language_interface->getId()));
+      $cacheable_metadata = new CacheableMetadata();
+      $output = $token_service->replace($input, array('user' => $account), array('langcode' => $language_interface->getId()), $cacheable_metadata);
       $this->assertEqual($output, $expected, format_string('Sanitized user token %token replaced.', array('%token' => $input)));
+      $this->assertEqual($cacheable_metadata, $metadata_tests[$input]);
     }
 
     // Generate and test unsanitized tokens.
diff --git a/core/modules/user/user.tokens.inc b/core/modules/user/user.tokens.inc
index 0439015..7f8f97a 100644
--- a/core/modules/user/user.tokens.inc
+++ b/core/modules/user/user.tokens.inc
@@ -6,6 +6,8 @@
  */
 
 use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Datetime\Entity\DateFormat;
 use Drupal\user\Entity\User;
 
 /**
@@ -64,7 +66,7 @@ function user_token_info() {
 /**
  * Implements hook_tokens().
  */
-function user_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function user_tokens($type, $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
 
   $token_service = \Drupal::token();
   $url_options = array('absolute' => TRUE);
@@ -108,10 +110,14 @@ function user_tokens($type, $tokens, array $data = array(), array $options = arr
 
         // These tokens are default variations on the chained tokens handled below.
         case 'last-login':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata->addCacheableDependency($date_format);
           $replacements[$original] = $account->getLastLoginTime() ? format_date($account->getLastLoginTime(), 'medium', '', NULL, $langcode) : t('never');
           break;
 
         case 'created':
+          $date_format = DateFormat::load('medium');
+          $cacheable_metadata->addCacheableDependency($date_format);
           // In the case of user_presave the created date may not yet be set.
           $replacements[$original] = $account->getCreatedTime() ? format_date($account->getCreatedTime(), 'medium', '', NULL, $langcode) : t('not yet created');
           break;
@@ -119,17 +125,18 @@ function user_tokens($type, $tokens, array $data = array(), array $options = arr
     }
 
     if ($login_tokens = $token_service->findWithPrefix($tokens, 'last-login')) {
-      $replacements += $token_service->generate('date', $login_tokens, array('date' => $account->getLastLoginTime()), $options);
+      $replacements += $token_service->generate('date', $login_tokens, array('date' => $account->getLastLoginTime()), $options, $cacheable_metadata);
     }
 
     if ($registered_tokens = $token_service->findWithPrefix($tokens, 'created')) {
-      $replacements += $token_service->generate('date', $registered_tokens, array('date' => $account->getCreatedTime()), $options);
+      $replacements += $token_service->generate('date', $registered_tokens, array('date' => $account->getCreatedTime()), $options, $cacheable_metadata);
     }
   }
 
   if ($type == 'current-user') {
     $account = User::load(\Drupal::currentUser()->id());
-    $replacements += $token_service->generate('user', $tokens, array('user' => $account), $options);
+    $cacheable_metadata->addCacheContexts(['user']);
+    $replacements += $token_service->generate('user', $tokens, array('user' => $account), $options, $cacheable_metadata);
   }
 
   return $replacements;
diff --git a/core/modules/views/src/Tests/TokenReplaceTest.php b/core/modules/views/src/Tests/TokenReplaceTest.php
index ad00b7e..73bc1d5 100644
--- a/core/modules/views/src/Tests/TokenReplaceTest.php
+++ b/core/modules/views/src/Tests/TokenReplaceTest.php
@@ -7,6 +7,7 @@
 
 namespace Drupal\views\Tests;
 
+use Drupal\Core\Cache\CacheableMetadata;
 use Drupal\views\Views;
 
 /**
@@ -54,9 +55,25 @@ function testTokenReplacement() {
       '[view:page-count]' => '1',
     );
 
+    $base_cacheable_metadata = CacheableMetadata::createFromObject($view->storage);
+    $metadata_tests = [];
+    $metadata_tests['[view:label]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:description]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:id]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:title]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:url]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:total-rows]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:base-table]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:base-field]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:items-per-page]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:current-page]'] = $base_cacheable_metadata;
+    $metadata_tests['[view:page-count]'] = $base_cacheable_metadata;
+
     foreach ($expected as $token => $expected_output) {
-      $output = $token_handler->replace($token, array('view' => $view));
+      $cacheable_metadata = new CacheableMetadata();
+      $output = $token_handler->replace($token, array('view' => $view), [], $cacheable_metadata);
       $this->assertIdentical($output, $expected_output, format_string('Token %token replaced correctly.', array('%token' => $token)));
+      $this->assertEqual($cacheable_metadata, $metadata_tests[$token]);
     }
   }
 
diff --git a/core/modules/views/views.tokens.inc b/core/modules/views/views.tokens.inc
index 1e0540b..a379084 100644
--- a/core/modules/views/views.tokens.inc
+++ b/core/modules/views/views.tokens.inc
@@ -6,6 +6,7 @@
  */
 
 use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Core\Cache\CacheableMetadata;
 
 /**
  * Implements hook_token_info().
@@ -68,7 +69,7 @@ function views_token_info() {
 /**
  * Implements hook_tokens().
  */
-function views_tokens($type, $tokens, array $data = array(), array $options = array()) {
+function views_tokens($type, $tokens, array $data, array $options, CacheableMetadata $cacheable_metadata) {
   $token_service = \Drupal::token();
 
   $url_options = array('absolute' => TRUE);
@@ -83,6 +84,8 @@ function views_tokens($type, $tokens, array $data = array(), array $options = ar
     /** @var \Drupal\views\ViewExecutable $view */
     $view = $data['view'];
 
+    $cacheable_metadata->addCacheableDependency($view->storage);
+
     foreach ($tokens as $name => $original) {
       switch ($name) {
         case 'label':
diff --git a/core/tests/Drupal/Tests/Core/Cache/CacheableMetadataTest.php b/core/tests/Drupal/Tests/Core/Cache/CacheableMetadataTest.php
index f2dbd3e..5b26203 100644
--- a/core/tests/Drupal/Tests/Core/Cache/CacheableMetadataTest.php
+++ b/core/tests/Drupal/Tests/Core/Cache/CacheableMetadataTest.php
@@ -43,6 +43,28 @@ public function testMerge(CacheableMetadata $a, CacheableMetadata $b, CacheableM
   }
 
   /**
+   * @covers ::addCacheableDependency
+   * @dataProvider providerTestMerge
+   *
+   * This only tests at a high level, because it reuses existing logic. Detailed
+   * tests exist for the existing logic:
+   *
+   * @see \Drupal\Tests\Core\Cache\CacheTest::testMergeTags()
+   * @see \Drupal\Tests\Core\Cache\CacheTest::testMergeMaxAges()
+   * @see \Drupal\Tests\Core\Cache\CacheContextsTest
+   */
+  public function testAddCacheableDependency(CacheableMetadata $a, CacheableMetadata $b, CacheableMetadata $expected) {
+    $cache_contexts_manager = $this->getMockBuilder('Drupal\Core\Cache\Context\CacheContextsManager')
+      ->disableOriginalConstructor()
+      ->getMock();
+    $container = new ContainerBuilder();
+    $container->set('cache_contexts_manager', $cache_contexts_manager);
+    \Drupal::setContainer($container);
+
+    $this->assertEquals($expected, $a->merge($b));
+  }
+
+  /**
    * Provides test data for testMerge().
    *
    * @return array
diff --git a/core/tests/Drupal/Tests/Core/Utility/TokenTest.php b/core/tests/Drupal/Tests/Core/Utility/TokenTest.php
index 0a9a570..4a179cc 100644
--- a/core/tests/Drupal/Tests/Core/Utility/TokenTest.php
+++ b/core/tests/Drupal/Tests/Core/Utility/TokenTest.php
@@ -7,6 +7,9 @@
 
 namespace Drupal\Tests\Core\Utility;
 
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Cache\Context\CacheContextsManager;
+use Drupal\Core\DependencyInjection\ContainerBuilder;
 use Drupal\Core\Language\LanguageInterface;
 use Drupal\Core\Utility\Token;
 use Drupal\Tests\UnitTestCase;
@@ -60,6 +63,20 @@ class TokenTest extends UnitTestCase {
   protected $cacheTagsInvalidator;
 
   /**
+   * The cache contexts manager.
+   *
+   * @var \Drupal\Core\Cache\Context\CacheContextsManager
+   */
+  protected $cacheContextManager;
+
+  /**
+   * The renderer.
+   *
+   * @var \Drupal\Core\Render\RendererInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $renderer;
+
+  /**
    * {@inheritdoc}
    */
   protected function setUp() {
@@ -73,7 +90,17 @@ protected function setUp() {
 
     $this->cacheTagsInvalidator = $this->getMock('\Drupal\Core\Cache\CacheTagsInvalidatorInterface');
 
-    $this->token = new Token($this->moduleHandler, $this->cache, $this->languageManager, $this->cacheTagsInvalidator);
+    $this->renderer = $this->getMock('Drupal\Core\Render\RendererInterface');
+
+    $this->token = new Token($this->moduleHandler, $this->cache, $this->languageManager, $this->cacheTagsInvalidator, $this->renderer);
+
+    $container = new ContainerBuilder();
+    $this->cacheContextManager = new CacheContextsManager($container, [
+      'current_user',
+      'custom_context'
+    ]);
+    $container->set('cache_contexts_manager', $this->cacheContextManager);
+    \Drupal::setContainer($container);
   }
 
   /**
@@ -123,6 +150,108 @@ public function testGetInfo() {
   }
 
   /**
+   * @covers ::replace
+   */
+  public function testReplaceWithCacheableMetadataObject() {
+    $this->moduleHandler->expects($this->any())
+      ->method('invokeAll')
+      ->willReturn(['[node:title]' => 'hello world']);
+
+    $cacheable_metadata = new CacheableMetadata();
+    $cacheable_metadata->setCacheContexts(['current_user']);
+    $cacheable_metadata->setCacheMaxAge(12);
+
+    $node = $this->prophesize('Drupal\node\NodeInterface');
+    $node->getCacheTags()->willReturn(['node:1']);
+    $node->getCacheContexts()->willReturn(['custom_context']);
+    $node->getCacheMaxAge()->willReturn(10);
+    $node = $node->reveal();
+
+    $result = $this->token->replace('[node:title]', ['node' => $node], [], $cacheable_metadata);
+    $this->assertEquals('hello world', $result);
+
+    $this->assertEquals(['node:1'], $cacheable_metadata->getCacheTags());
+    $this->assertEquals([
+      'current_user',
+      'custom_context'
+    ], $cacheable_metadata->getCacheContexts());
+    $this->assertEquals(10, $cacheable_metadata->getCacheMaxAge());
+  }
+
+  /**
+   * @covers ::replace
+   */
+  public function testReplaceWithHookTokensWithCacheableMetadata() {
+    $this->moduleHandler->expects($this->any())
+      ->method('invokeAll')
+      ->willReturnCallback(function ($hook_name, $args) {
+        $cacheable_metadata = $args[4];
+        $cacheable_metadata->addCacheContexts(['custom_context']);
+        $cacheable_metadata->addCacheTags(['node:1']);
+        $cacheable_metadata->setCacheMaxAge(10);
+
+        return ['[node:title]' => 'hello world'];
+      });
+
+    $node = $this->prophesize('Drupal\node\NodeInterface');
+    $node->getCacheContexts()->willReturn([]);
+    $node->getCacheTags()->willReturn([]);
+    $node->getCacheMaxAge()->willReturn(14);
+    $node = $node->reveal();
+
+    $cacheable_metadata = new CacheableMetadata();
+    $cacheable_metadata->setCacheContexts(['current_user']);
+    $cacheable_metadata->setCacheMaxAge(12);
+
+    $result = $this->token->replace('[node:title]', ['node' => $node], [], $cacheable_metadata);
+    $this->assertEquals('hello world', $result);
+    $this->assertEquals(['node:1'], $cacheable_metadata->getCacheTags());
+    $this->assertEquals([
+      'current_user',
+      'custom_context'
+    ], $cacheable_metadata->getCacheContexts());
+    $this->assertEquals(10, $cacheable_metadata->getCacheMaxAge());
+  }
+
+  /**
+   * @covers ::replace
+   * @covers ::replace
+   */
+  public function testReplaceWithHookTokensAlterWithCacheableMetadata() {
+    $this->moduleHandler->expects($this->any())
+      ->method('invokeAll')
+      ->willReturn([]);
+
+    $this->moduleHandler->expects($this->any())
+      ->method('alter')
+      ->willReturnCallback(function ($hook_name, array &$replacements, array $context, CacheableMetadata $cacheable_metadata) {
+        $replacements['[node:title]'] = 'hello world';
+        $cacheable_metadata->addCacheContexts(['custom_context']);
+        $cacheable_metadata->addCacheTags(['node:1']);
+        $cacheable_metadata->setCacheMaxAge(10);
+      });
+
+    $node = $this->prophesize('Drupal\node\NodeInterface');
+    $node->getCacheContexts()->willReturn([]);
+    $node->getCacheTags()->willReturn([]);
+    $node->getCacheMaxAge()->willReturn(14);
+    $node = $node->reveal();
+
+    $cacheable_metadata = new CacheableMetadata();
+    $cacheable_metadata->setCacheContexts(['current_user']);
+    $cacheable_metadata->setCacheMaxAge(12);
+
+    $result = $this->token->replace('[node:title]', ['node' => $node], [], $cacheable_metadata);
+    $this->assertEquals('hello world', $result);
+    $this->assertEquals(['node:1'], $cacheable_metadata->getCacheTags());
+    $this->assertEquals([
+      'current_user',
+      'custom_context'
+    ], $cacheable_metadata->getCacheContexts());
+    $this->assertEquals(10, $cacheable_metadata->getCacheMaxAge());
+  }
+
+  /**
    * @covers ::resetInfo
    */
   public function testResetInfo() {