Convert resolver to a pre-evaluated tree

Author: Pike

fluent.runtime/fluent/runtime/__init__.py

@@ -8,7 +8,8 @@
 from fluent.syntax.ast import Message, Term
 
 from .builtins import BUILTINS
-from .resolver import resolve
+from .prepare import Compiler
+from .resolver import ResolverEnvironment, CurrentEnvironment
 from .utils import ATTRIBUTE_SEPARATOR, TERM_SIGIL, add_message_and_attrs_to_store, ast_to_id
 
 
@@ -33,6 +34,8 @@ def __init__(self, locales, functions=None, use_isolating=True):
         self._functions = _functions
         self._use_isolating = use_isolating
         self._messages_and_terms = {}
+        self._compiled = {}
+        self._compiler = Compiler()
         self._babel_locale = self._get_babel_locale()
         self._plural_form = babel.plural.to_python(self._babel_locale.plural_form)
 
@@ -56,10 +59,17 @@ def has_message(self, message_id):
     def format(self, message_id, args=None):
         if message_id.startswith(TERM_SIGIL):
             raise LookupError(message_id)
-        message = self._messages_and_terms[message_id]
         if args is None:
             args = {}
-        return resolve(self, message, args)
+        if message_id not in self._compiled:
+            message = self._messages_and_terms[message_id]
+            self._compiled[message_id] = self._compiler(message.value)
+        resolve = self._compiled[message_id]
+        errors = []
+        env = ResolverEnvironment(context=self,
+                                  current=CurrentEnvironment(args=args),
+                                  errors=errors)
+        return [resolve(env), errors]
 
     def _get_babel_locale(self):
         for l in self.locales:

fluent.runtime/fluent/runtime/prepare.py

@@ -0,0 +1,45 @@
+from __future__ import absolute_import, unicode_literals
+from fluent.syntax import ast as FTL
+from . import resolver
+
+
+class Compiler(object):
+    def __init__(self, bundle=None):
+        self.bundle = None
+
+    def __call__(self, item):
+        if isinstance(item, FTL.BaseNode):
+            return self.compile(item)
+        if isinstance(item, (tuple, list)):
+            return [self(elem) for elem in item]
+        return item
+
+    def compile(self, node):
+        nodename = type(node).__name__
+        if not hasattr(resolver, nodename):
+            return node
+        kwargs = vars(node).copy()
+        for propname, propvalue in kwargs.items():
+            kwargs[propname] = self(propvalue)
+        handler = getattr(self, 'compile_' + nodename, self.compile_generic)
+        return handler(nodename, **kwargs)
+
+    def compile_generic(self, nodename, **kwargs):
+        return getattr(resolver, nodename)(**kwargs)
+
+    def compile_Placeable(self, _, expression, **kwargs):
+        if isinstance(expression, resolver.Literal):
+            return expression
+        return resolver.Placeable(expression=expression, **kwargs)
+
+    def compile_Pattern(self, _, elements, **kwargs):
+        if any(
+            not isinstance(child, resolver.Literal)
+            for child in elements
+        ):
+            return resolver.Pattern(elements=elements, **kwargs)
+        if len(elements) == 1:
+            return elements[0]
+        return resolver.TextElement(
+            ''.join(child(None) for child in elements)
+        )