bind-gen: Introduce TextNode and abandon SimpleNode

Introduce TextNode, which is just like LiteralNode, and abandon
SimpleNode.  This patch could be interpreted as replacement of
SimpleNode with TextNode.

SimpleNode was introduced in constrast with SequenceNode, but
it doesn't make a good sense now IMHO.  LiteralNode and TextNode
make better sense.

Bug: 839389
Change-Id: I9cd4b3f66658443eb1ae88a8e183e559fa36ef20
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1863049
Commit-Queue: Yuki Shiino <yukishiino@chromium.org>
Reviewed-by: Hitoshi Yoshida <peria@chromium.org>
Cr-Commit-Position: refs/heads/master@{#706805}

third_party/blink/renderer/bindings/scripts/bind_gen/code_node.py

@@ -158,7 +158,7 @@ class CodeNode(object):
 
         Only limited subclasses may override this method.
         """
-        assert self._template_text
+        assert self._template_text is not None
         return renderer.render(
             caller=self,
             template_text=self._template_text,
@@ -283,20 +283,17 @@ class LiteralNode(CodeNode):
             renderer=renderer)
 
 
-class SimpleNode(CodeNode):
+class TextNode(CodeNode):
     """
-    Represents a simple node that never contains a branch nor sequence.
+    Represents a template text node.
 
-    Technically, you can make this node contain branches and sequences with
-    using template text and variable bindings, however, it's not supported.
+    TextNode is designed to be a leaf node of a code node tree.  TextNode
+    represents a template text while LiteralNode represents a literal text.
+    All template magics will be applied to |template_text|.
     """
 
-    def __init__(self, template_text, template_vars=None, renderer=None):
-        CodeNode.__init__(
-            self,
-            template_text=template_text,
-            template_vars=template_vars,
-            renderer=renderer)
+    def __init__(self, template_text, renderer=None):
+        CodeNode.__init__(self, template_text=template_text, renderer=renderer)
 
 
 class SequenceNode(CodeNode):

third_party/blink/renderer/bindings/scripts/bind_gen/code_node_test.py

@@ -6,9 +6,9 @@ import unittest
 
 from .code_node import LiteralNode
 from .code_node import SequenceNode
-from .code_node import SimpleNode
 from .code_node import SymbolNode
 from .code_node import SymbolScopeNode
+from .code_node import TextNode
 from .mako_renderer import MakoRenderer
 
 
@@ -36,9 +36,24 @@ class CodeNodeTest(unittest.TestCase):
         etc) are not processed.
         """
         renderer = MakoRenderer()
-        text = "% for ${x}"
-        root = LiteralNode(text, renderer=renderer)
-        self.assertRenderResult(root, text)
+        root = LiteralNode("<% x = 42 %>${x}", renderer=renderer)
+        self.assertRenderResult(root, "<% x = 42 %>${x}")
+
+    def test_empty_literal_node(self):
+        renderer = MakoRenderer()
+        root = LiteralNode("", renderer=renderer)
+        self.assertRenderResult(root, "")
+
+    def test_text_node(self):
+        """Tests that the template language works in TextNode."""
+        renderer = MakoRenderer()
+        root = TextNode("<% x = 42 %>${x}", renderer=renderer)
+        self.assertRenderResult(root, "42")
+
+    def test_empty_text_node(self):
+        renderer = MakoRenderer()
+        root = TextNode("", renderer=renderer)
+        self.assertRenderResult(root, "")
 
     def test_list_operations_of_sequence_node(self):
         """
@@ -83,14 +98,14 @@ class CodeNodeTest(unittest.TestCase):
         root = SymbolScopeNode(renderer=renderer)
 
         root.register_code_symbols([
-            SymbolNode("var1", "int var1 = ${var2} + ${var3};"),
-            SymbolNode("var2", "int var2 = ${var5};"),
-            SymbolNode("var3", "int var3 = ${var4};"),
-            SymbolNode("var4", "int var4 = 1;"),
-            SymbolNode("var5", "int var5 = 2;"),
+            SymbolNode("var1", "int ${var1} = ${var2} + ${var3};"),
+            SymbolNode("var2", "int ${var2} = ${var5};"),
+            SymbolNode("var3", "int ${var3} = ${var4};"),
+            SymbolNode("var4", "int ${var4} = 1;"),
+            SymbolNode("var5", "int ${var5} = 2;"),
         ])
 
-        root.append(SimpleNode(template_text="(void)${var1};"))
+        root.append(TextNode("(void)${var1};"))
 
         self.assertRenderResult(
             root, """

third_party/blink/renderer/bindings/scripts/bind_gen/example.py

@@ -17,8 +17,8 @@ def run_example(web_idl_database, output_dirs):
 
     root_node = code_node.SymbolScopeNode(renderer=renderer)
     root_node.extend([
-        code_node.SimpleNode(template_text="${z} = ${x} + ${y};"),
-        code_node.SimpleNode(template_text="print ${z};"),
+        code_node.TextNode("${z} = ${x} + ${y};"),
+        code_node.TextNode("print ${z};"),
     ])
 
     root_node.register_code_symbols([

third_party/blink/renderer/bindings/scripts/bind_gen/mako_renderer.py

@@ -36,17 +36,17 @@ class MakoRenderer(object):
             caller: An object to be pushed onto the call stack.
         """
 
-        assert not (template_path is None and template_text is None)
-        assert not (template_path and template_text)
+        assert template_path is not None or template_text is not None
+        assert template_path is None or template_text is None
         assert isinstance(template_vars, dict)
         assert caller is not None
 
         self._caller_stack.append(caller)
 
         try:
-            if template_path:
+            if template_path is not None:
                 template = self._template_lookup.get_template(template_path)
-            elif template_text:
+            elif template_text is not None:
                 template = mako.template.Template(text=template_text)
             text = template.render(**template_vars)
         finally: