use similar code for all callback-applying methods

avoid building nested chain iterables
avoid triggering defaultdict when looking up registries
apply functions as they are looked up

src/flask/app.py

@@ -58,17 +58,12 @@ from .signals import request_started
 from .signals import request_tearing_down
 from .templating import DispatchingJinjaLoader
 from .templating import Environment
-from .typing import AfterRequestCallable
 from .typing import BeforeFirstRequestCallable
-from .typing import BeforeRequestCallable
 from .typing import ResponseReturnValue
 from .typing import TeardownCallable
-from .typing import TemplateContextProcessorCallable
 from .typing import TemplateFilterCallable
 from .typing import TemplateGlobalCallable
 from .typing import TemplateTestCallable
-from .typing import URLDefaultCallable
-from .typing import URLValuePreprocessorCallable
 from .wrappers import Request
 from .wrappers import Response
 
@@ -745,20 +740,21 @@ class Flask(Scaffold):
         :param context: the context as a dictionary that is updated in place
                         to add extra variables.
         """
-        funcs: t.Iterable[TemplateContextProcessorCallable] = []
+        names: t.Iterable[t.Optional[str]] = (None,)
-        if None in self.template_context_processors:
+
-            funcs = chain(funcs, self.template_context_processors[None])
+        # A template may be rendered outside a request context.
-        reqctx = _request_ctx_stack.top
+        if request:
-        if reqctx is not None:
+            names = chain(names, reversed(request.blueprints))
-            for bp in reversed(request.blueprints):
+
-                if bp in self.template_context_processors:
+        # The values passed to render_template take precedence. Keep a
-                    funcs = chain(funcs, self.template_context_processors[bp])
+        # copy to re-apply after all context functions.
         orig_ctx = context.copy()
-        for func in funcs:
+
-            context.update(func())
+        for name in names:
-        # make sure the original values win.  This makes it possible to
+            if name in self.template_context_processors:
-        # easier add new variables in context processors without breaking
+                for func in self.template_context_processors[name]:
-        # existing views.
+                    context.update(func())
+
         context.update(orig_ctx)
 
     def make_shell_context(self) -> dict:
@@ -1278,9 +1274,10 @@ class Flask(Scaffold):
         class, or ``None`` if a suitable handler is not found.
         """
         exc_class, code = self._get_exc_class_and_code(type(e))
+        names = (*request.blueprints, None)
 
-        for c in [code, None] if code is not None else [None]:
+        for c in (code, None) if code is not None else (None,):
-            for name in chain(request.blueprints, [None]):
+            for name in names:
                 handler_map = self.error_handler_spec[name][c]
 
                 if not handler_map:
@@ -1800,19 +1797,19 @@ class Flask(Scaffold):
 
         .. versionadded:: 0.7
         """
-        funcs: t.Iterable[URLDefaultCallable] = self.url_default_functions[None]
+        names: t.Iterable[t.Optional[str]] = (None,)
 
+        # url_for may be called outside a request context, parse the
+        # passed endpoint instead of using request.blueprints.
         if "." in endpoint:
-            # This is called by url_for, which can be called outside a
+            names = chain(
-            # request, can't use request.blueprints.
+                names, reversed(_split_blueprint_path(endpoint.rpartition(".")[0]))
-            bps = _split_blueprint_path(endpoint.rpartition(".")[0])
-            bp_funcs = chain.from_iterable(
-                self.url_default_functions[bp] for bp in reversed(bps)
             )
-            funcs = chain(funcs, bp_funcs)
 
-        for func in funcs:
+        for name in names:
-            func(endpoint, values)
+            if name in self.url_default_functions:
+                for func in self.url_default_functions[name]:
+                    func(endpoint, values)
 
     def handle_url_build_error(
         self, error: Exception, endpoint: str, values: dict
@@ -1847,22 +1844,20 @@ class Flask(Scaffold):
         value is handled as if it was the return value from the view, and
         further request handling is stopped.
         """
+        names = (None, *reversed(request.blueprints))
 
-        funcs: t.Iterable[URLValuePreprocessorCallable] = []
+        for name in names:
-        for name in chain([None], reversed(request.blueprints)):
             if name in self.url_value_preprocessors:
-                funcs = chain(funcs, self.url_value_preprocessors[name])
+                for url_func in self.url_value_preprocessors[name]:
-        for func in funcs:
+                    url_func(request.endpoint, request.view_args)
-            func(request.endpoint, request.view_args)
 
-        funcs: t.Iterable[BeforeRequestCallable] = []
+        for name in names:
-        for name in chain([None], reversed(request.blueprints)):
             if name in self.before_request_funcs:
-                funcs = chain(funcs, self.before_request_funcs[name])
+                for before_func in self.before_request_funcs[name]:
-        for func in funcs:
+                    rv = self.ensure_sync(before_func)()
-            rv = self.ensure_sync(func)()
+
-            if rv is not None:
+                    if rv is not None:
-                return rv
+                        return rv
 
         return None
 
@@ -1880,14 +1875,18 @@ class Flask(Scaffold):
                  instance of :attr:`response_class`.
         """
         ctx = _request_ctx_stack.top
-        funcs: t.Iterable[AfterRequestCallable] = ctx._after_request_functions
+
-        for name in chain(request.blueprints, [None]):
+        for func in ctx._after_request_functions:
+            response = self.ensure_sync(func)(response)
+
+        for name in chain(request.blueprints, (None,)):
             if name in self.after_request_funcs:
-                funcs = chain(funcs, reversed(self.after_request_funcs[name]))
+                for func in reversed(self.after_request_funcs[name]):
-        for handler in funcs:
+                    response = self.ensure_sync(func)(response)
-            response = self.ensure_sync(handler)(response)
+
         if not self.session_interface.is_null_session(ctx.session):
             self.session_interface.save_session(self, ctx.session, response)
+
         return response
 
     def do_teardown_request(
@@ -1915,12 +1914,12 @@ class Flask(Scaffold):
         """
         if exc is _sentinel:
             exc = sys.exc_info()[1]
-        funcs: t.Iterable[TeardownCallable] = []
+
-        for name in chain(request.blueprints, [None]):
+        for name in chain(request.blueprints, (None,)):
             if name in self.teardown_request_funcs:
-                funcs = chain(funcs, reversed(self.teardown_request_funcs[name]))
+                for func in reversed(self.teardown_request_funcs[name]):
-        for func in funcs:
+                    self.ensure_sync(func)(exc)
-            self.ensure_sync(func)(exc)
+
         request_tearing_down.send(self, exc=exc)
 
     def do_teardown_appcontext(
@@ -1942,8 +1941,10 @@ class Flask(Scaffold):
         """
         if exc is _sentinel:
             exc = sys.exc_info()[1]
+
         for func in reversed(self.teardown_appcontext_funcs):
             self.ensure_sync(func)(exc)
+
         appcontext_tearing_down.send(self, exc=exc)
 
     def app_context(self) -> AppContext: