diff --git a/core/includes/theme.inc b/core/includes/theme.inc
index 228065a..04261d4 100644
--- a/core/includes/theme.inc
+++ b/core/includes/theme.inc
@@ -424,7 +424,6 @@ function drupal_theme_rebuild() {
  *     'render element' is not specified in a later one, then the previous
  *     definition is kept.
  *   - 'preprocess functions': See theme() for detailed documentation.
- *   - 'process functions': See theme() for detailed documentation.
  * @param $name
  *   The name of the module, theme engine, base theme engine, theme or base
  *   theme implementing hook_theme().
@@ -448,11 +447,8 @@ function drupal_theme_rebuild() {
 function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
   $result = array();
 
-  // Processor functions work in two distinct phases with the process
-  // functions always being executed after the preprocess functions.
   $variable_process_phases = array(
     'preprocess functions' => 'preprocess',
-    'process functions'    => 'process',
   );
 
   $hook_defaults = array(
@@ -464,7 +460,7 @@ function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
 
   $module_list = array_keys(Drupal::moduleHandler()->getModuleList());
 
-  // Invoke the hook_theme() implementation, process what is returned, and
+  // Invoke the hook_theme() implementation, preprocess what is returned, and
   // merge it into $cache.
   $function = $name . '_theme';
   if (function_exists($function)) {
@@ -515,10 +511,10 @@ function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
         }
       }
 
-      // Allow variable processors for all theming hooks, whether the hook is
+      // Allow variable preprocessors for all theming hooks, whether the hook is
       // implemented as a template or as a function.
       foreach ($variable_process_phases as $phase_key => $phase) {
-        // Check for existing variable processors. Ensure arrayness.
+        // Check for existing variable preprocessors. Ensure arrayness.
         if (!isset($info[$phase_key]) || !is_array($info[$phase_key])) {
           $info[$phase_key] = array();
           $prefixes = array();
@@ -526,8 +522,8 @@ function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
             // Default variable processor prefix.
             $prefixes[] = 'template';
             // Add all modules so they can intervene with their own variable
-            // processors. This allows them to provide variable processors even
-            // if they are not the owner of the current hook.
+            // preprocessors. This allows them to provide variable preprocessors
+            // even if they are not the owner of the current hook.
             $prefixes = array_merge($prefixes, $module_list);
           }
           elseif ($type == 'theme_engine' || $type == 'base_theme_engine') {
@@ -540,12 +536,12 @@ function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
           }
           else {
             // This applies when the theme manually registers their own variable
-            // processors.
+            // preprocessors.
             $prefixes[] = $name;
           }
           foreach ($prefixes as $prefix) {
-            // Only use non-hook-specific variable processors for theming hooks
-            // implemented as templates. See theme().
+            // Only use non-hook-specific variable preprocessors for theming
+            // hooks implemented as templates. See theme().
             if (isset($info['template']) && function_exists($prefix . '_' . $phase)) {
               $info[$phase_key][] = $prefix . '_' . $phase;
             }
@@ -555,8 +551,8 @@ function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
           }
         }
         // Check for the override flag and prevent the cached variable
-        // processors from being used. This allows themes or theme engines to
-        // remove variable processors set earlier in the registry build.
+        // preprocessors from being used. This allows themes or theme engines
+        // to remove variable preprocessors set earlier in the registry build.
         if (!empty($info['override ' . $phase_key])) {
           // Flag not needed inside the registry.
           unset($result[$hook]['override ' . $phase_key]);
@@ -572,7 +568,7 @@ function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
     $cache = $result + $cache;
   }
 
-  // Let themes have variable processors even if they didn't register a
+  // Let themes have variable preprocessors even if they didn't register a
   // template.
   if ($type == 'theme' || $type == 'base_theme') {
     foreach ($cache as $hook => $info) {
@@ -582,7 +578,7 @@ function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
           if (!isset($info[$phase_key])) {
             $cache[$hook][$phase_key] = array();
           }
-          // Only use non-hook-specific variable processors for theming hooks
+          // Only use non-hook-specific variable preprocessors for theme hooks
           // implemented as templates. See theme().
           if (isset($info['template']) && function_exists($name . '_' . $phase)) {
             $cache[$hook][$phase_key][] = $name . '_' . $phase;
@@ -612,7 +608,7 @@ function _theme_process_registry(&$cache, $name, $type, $theme, $path) {
  */
 function _theme_build_registry($theme, $base_theme, $theme_engine) {
   $cache = array();
-  // First, process the theme hooks advertised by modules. This will
+  // First, preprocess the theme hooks advertised by modules. This will
   // serve as the basic registry. Since the list of enabled modules is the same
   // regardless of the theme used, this is cached in its own entry to save
   // building it for every theme.
@@ -652,7 +648,7 @@ function _theme_build_registry($theme, $base_theme, $theme_engine) {
 
   // Optimize the registry to not have empty arrays for functions.
   foreach ($cache as $hook => $info) {
-    foreach (array('preprocess functions', 'process functions') as $phase) {
+    foreach (array('preprocess functions') as $phase) {
       if (empty($info[$phase])) {
         unset($cache[$hook][$phase]);
       }
@@ -837,21 +833,21 @@ function drupal_find_base_themes($themes, $key, $used_keys = array()) {
  * containing a 'page.html.twig' file within its folder structure).
  *
  * @subsection sub_preprocess_templates Preprocessing for Template Files
- * If the implementation is a template file, several functions are called
- * before the template file is invoked, to modify the $variables array. These
- * fall into the "preprocessing" phase and the "processing" phase, and are
- * executed (if they exist), in the following order (note that in the following
- * list, HOOK indicates the theme hook name, MODULE indicates a module name,
- * THEME indicates a theme name, and ENGINE indicates a theme engine name):
- * - template_preprocess(&$variables, $hook): Creates a default set of
- *   variables for all theme hooks with template implementations.
+ * If the implementation is a template file, several functions are called before
+ * the template file is invoked to modify the $variables array. These make up
+ * the "preprocessing" phase, and are executed (if they exist), in the following
+ * order (note that in the following list, HOOK indicates the theme hook name,
+ * MODULE indicates a module name, THEME indicates a theme name, and ENGINE
+ * indicates a theme engine name):
+ * - template_preprocess(&$variables, $hook): Creates a default set of variables
+ *   for all theme hooks with template implementations.
  * - template_preprocess_HOOK(&$variables): Should be implemented by the module
  *   that registers the theme hook, to set up default variables.
  * - MODULE_preprocess(&$variables, $hook): hook_preprocess() is invoked on all
  *   implementing modules.
  * - MODULE_preprocess_HOOK(&$variables): hook_preprocess_HOOK() is invoked on
- *   all implementing modules, so that modules that didn't define the theme
- *   hook can alter the variables.
+ *   all implementing modules, so that modules that didn't define the theme hook
+ *   can alter the variables.
  * - ENGINE_engine_preprocess(&$variables, $hook): Allows the theme engine to
  *   set necessary variables for all theme hooks with template implementations.
  * - ENGINE_engine_preprocess_HOOK(&$variables): Allows the theme engine to set
@@ -860,57 +856,33 @@ function drupal_find_base_themes($themes, $key, $used_keys = array()) {
  *   variables for all theme hooks with template implementations.
  * - THEME_preprocess_HOOK(&$variables): Allows the theme to set necessary
  *   variables specific to the particular theme hook.
- * - template_process(&$variables, $hook): Creates an additional set of default
- *   variables for all theme hooks with template implementations. The variables
- *   created in this function are derived from ones created by
- *   template_preprocess(), but potentially altered by the other preprocess
- *   functions listed above. For example, any preprocess function can add to or
- *   modify the $variables['attributes'] variable, and after all of them
- *   have finished executing, template_process() flattens it into a
- *   $variables['attributes'] string for convenient use by templates.
- * - template_process_HOOK(&$variables): Should be implemented by the module
- *   that registers the theme hook, if it needs to perform additional variable
- *   processing after all preprocess functions have finished.
- * - MODULE_process(&$variables, $hook): hook_process() is invoked on all
- *   implementing modules.
- * - MODULE_process_HOOK(&$variables): hook_process_HOOK() is invoked on
- *   on all implementing modules, so that modules that didn't define the theme
- *   hook can alter the variables.
- * - ENGINE_engine_process(&$variables, $hook): Allows the theme engine to
- *   process variables for all theme hooks with template implementations.
- * - ENGINE_engine_process_HOOK(&$variables): Allows the theme engine to process
- *   the variables specific to the theme hook.
- * - THEME_process(&$variables, $hook):  Allows the theme to process the
- *   variables for all theme hooks with template implementations.
- * - THEME_process_HOOK(&$variables):  Allows the theme to process the
- *   variables specific to the theme hook.
  *
  * @subsection sub_preprocess_theme_funcs Preprocessing for Theme Functions
  * If the implementation is a function, only the theme-hook-specific preprocess
- * and process functions (the ones ending in _HOOK) are called from the
- * list above. This is because theme hooks with function implementations
- * need to be fast, and calling the non-theme-hook-specific preprocess and
- * process functions for them would incur a noticeable performance penalty.
+ * functions (the ones ending in _HOOK) are called from the list above. This is
+ * because theme hooks with function implementations need to be fast, and
+ * calling the non-theme-hook-specific preprocess functions for them would incur
+ * a noticeable performance penalty.
  *
  * @subsection sub_alternate_suggestions Suggesting Alternate Hooks
- * There are two special variables that these preprocess and process functions
- * can set: 'theme_hook_suggestion' and 'theme_hook_suggestions'. These will be
- * merged together to form a list of 'suggested' alternate theme hooks to use,
- * in reverse order of priority. theme_hook_suggestion will always be a higher
- * priority than items in theme_hook_suggestions. theme() will use the
- * highest priority implementation that exists. If none exists, theme() will
- * use the implementation for the theme hook it was called with. These
- * suggestions are similar to and are used for similar reasons as calling
- * theme() with an array as the $hook parameter (see below). The difference
- * is whether the suggestions are determined by the code that calls theme() or
- * by a preprocess or process function.
+ * There are two special variables that these preprocess functions can set:
+ * 'theme_hook_suggestion' and 'theme_hook_suggestions'. These will be merged
+ * together to form a list of 'suggested' alternate theme hooks to use, in
+ * reverse order of priority. theme_hook_suggestion will always be a higher
+ * priority than items in theme_hook_suggestions. theme() will use the highest
+ * priority implementation that exists. If none exists, theme() will use the
+ * implementation for the theme hook it was called with. These suggestions are
+ * similar to, and are used for similar reasons as, calling theme() with an
+ * array as the $hook parameter (see below). The difference is whether the
+ * suggestions are determined by the code that calls theme() or by a preprocess
+ * function.
  *
  * @param $hook
  *   The name of the theme hook to call. If the name contains a
  *   double-underscore ('__') and there isn't an implementation for the full
  *   name, the part before the '__' is checked. This allows a fallback to a
  *   more generic implementation. For example, if theme('links__node', ...) is
- *   called, but there is no implementation of that theme hook, then the
+ *   called but there is no implementation of that theme hook, then the
  *   'links' implementation is used. This process is iterative, so if
  *   theme('links__contextual__node', ...) is called, theme() checks for the
  *   following implementations, and uses the first one that exists:
@@ -925,11 +897,10 @@ function drupal_find_base_themes($themes, $key, $used_keys = array()) {
  *   convention is not desired or is insufficient.
  * @param $variables
  *   An associative array of variables to merge with defaults from the theme
- *   registry, pass to preprocess and process functions for modification, and
- *   finally, pass to the function or template implementing the theme hook.
- *   Alternatively, this can be a renderable array, in which case, its
- *   properties are mapped to variables expected by the theme hook
- *   implementations.
+ *   registry, pass to preprocess functions for modification, and finally, pass
+ *   to the function or template implementing the theme hook. Alternatively,
+ *   this can be a renderable array, in which case, its properties are mapped to
+ *   variables expected by the theme hook implementations.
  *
  * @return
  *   An HTML string representing the themed output.
@@ -937,7 +908,6 @@ function drupal_find_base_themes($themes, $key, $used_keys = array()) {
  * @see themeable
  * @see hook_theme()
  * @see template_preprocess()
- * @see template_process()
  */
 function theme($hook, $variables = array()) {
   static $default_attributes;
@@ -991,7 +961,7 @@ function theme($hook, $variables = array()) {
   // point path_to_theme() to the currently used theme path:
   $theme_path = $info['theme path'];
 
-  // Include a file if the theme function or variable processor is held
+  // Include a file if the theme function or variable preprocessor is held
   // elsewhere.
   if (!empty($info['includes'])) {
     foreach ($info['includes'] as $include_file) {
@@ -1030,30 +1000,30 @@ function theme($hook, $variables = array()) {
     'theme_hook_original' => $original_hook,
   );
 
-  // Invoke the variable processors, if any. The processors may specify
+  // Invoke the variable preprocessors, if any. The preprocessors may specify
   // alternate suggestions for which hook's template/function to use. If the
-  // hook is a suggestion of a base hook, invoke the variable processors of
+  // hook is a suggestion of a base hook, invoke the variable preprocessors of
   // the base hook, but retain the suggestion as a high priority suggestion to
-  // be used unless overridden by a variable processor function.
+  // be used unless overridden by a variable preprocessor function.
   if (isset($info['base hook'])) {
     $base_hook = $info['base hook'];
     $base_hook_info = $hooks[$base_hook];
-    // Include files required by the base hook, since its variable processors
+    // Include files required by the base hook, since its variable preprocessors
     // might reside there.
     if (!empty($base_hook_info['includes'])) {
       foreach ($base_hook_info['includes'] as $include_file) {
         include_once DRUPAL_ROOT . '/' . $include_file;
       }
     }
-    if (isset($base_hook_info['preprocess functions']) || isset($base_hook_info['process functions'])) {
+    if (isset($base_hook_info['preprocess functions'])) {
       $variables['theme_hook_suggestion'] = $hook;
       $hook = $base_hook;
       $info = $base_hook_info;
     }
   }
-  if (isset($info['preprocess functions']) || isset($info['process functions'])) {
+  if (isset($info['preprocess functions'])) {
     $variables['theme_hook_suggestions'] = array();
-    foreach (array('preprocess functions', 'process functions') as $phase) {
+    foreach (array('preprocess functions') as $phase) {
       if (!empty($info[$phase])) {
         foreach ($info[$phase] as $processor_function) {
           if (function_exists($processor_function)) {
@@ -1062,10 +1032,10 @@ function theme($hook, $variables = array()) {
         }
       }
     }
-    // If the preprocess/process functions specified hook suggestions, and the
+    // If the preprocess functions specified hook suggestions, and the
     // suggestion exists in the theme registry, use it instead of the hook that
-    // theme() was called with. This allows the preprocess/process step to
-    // route to a more specific theme hook. For example, a function may call
+    // theme() was called with. This allows the preprocess step to route to a
+    // more specific theme hook. For example, a function may call
     // theme('node', ...), but a preprocess function can add 'node__article' as
     // a suggestion, enabling a theme to have an alternate template file for
     // article nodes. Suggestions are checked in the following order:
@@ -2269,7 +2239,7 @@ function theme_mark($variables) {
  *
  * @param array $variables
  *   An associative array containing theme variables for theme_item_list().
- *   'items' in variables will be processed to automatically inherit the
+ *   'items' in variables will be preprocessed to automatically inherit the
  *   variables of this list to any possibly contained nested lists that do not
  *   specify custom render properties. This allows callers to specify larger
  *   nested lists, without having to explicitly specify and repeat the render
@@ -2533,16 +2503,15 @@ function _theme_table_cell($cell, $header = FALSE) {
 }
 
 /**
- * Adds a default set of helper variables for variable processors and templates.
+ * Adds a default set of helper variables for preprocessors and templates.
  *
  * This function is called for theme hooks implemented as templates only, not
  * for theme hooks implemented as functions. This preprocess function is the
- * first in the sequence of preprocessing and processing functions that is
- * called when preparing variables for a template. See theme() for more details
- * about the full sequence.
+ * first in the sequence of preprocessing functions that is called when
+ * preparing variables for a template. See theme() for more details about the
+ * full sequence.
  *
  * @see theme()
- * @see template_process()
  */
 function template_preprocess(&$variables, $hook, $info) {
   // Tell all templates where they are located.