bind-gen: Improve CodeNode family to be newline-sensitive

clang-format takes care of formatting, but it's still newline-
sensitive.  So, make CodeNode family generate/remove appropriate
newlines.

Also renames |cond_node| and |body_node| simplifying to
|cond| and |body|.

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

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

@@ -340,22 +340,29 @@ class SequenceNode(CodeNode):
     Represents a sequence of nodes.
     """
 
-    def __init__(self, code_nodes=None, separator="\n", renderer=None):
+    def __init__(self,
+                 code_nodes=None,
+                 separator=" ",
+                 separator_last="",
+                 renderer=None):
         assert isinstance(separator, str)
+        assert isinstance(separator_last, str)
 
         element_nodes_gensym = CodeNode.gensym()
         element_nodes = []
         template_text = CodeNode.format_template(
             """\
 % for node in {element_nodes}:
-${node}\\
+${node | trim}\\
 % if not loop.last:
 {separator}\\
 % endif
 % endfor
+{separator_last}\\
 """,
             element_nodes=element_nodes_gensym,
-            separator=separator)
+            separator=separator,
+            separator_last=separator_last)
         template_vars = {element_nodes_gensym: element_nodes}
 
         CodeNode.__init__(
@@ -453,7 +460,7 @@ class SymbolNode(CodeNode):
 
             def constructor(symbol_node):
                 return SymbolDefinitionNode(
-                    symbol_node, template_text=template_text)
+                    symbol_node=symbol_node, template_text=template_text)
 
             self._definition_node_constructor = constructor
         else:
@@ -517,6 +524,14 @@ class SymbolScopeNode(SequenceNode):
     insert corresponding SymbolDefinitionNodes appropriately.
     """
 
+    def __init__(self, code_nodes=None, renderer=None):
+        SequenceNode.__init__(
+            self,
+            code_nodes=code_nodes,
+            separator="\n",
+            separator_last="\n",
+            renderer=renderer)
+
     def _render(self, renderer, last_render_state):
         # Sort nodes in order to render reproducible results.
         symbol_nodes = sorted(
@@ -635,9 +650,9 @@ class ConditionalExitNode(ConditionalNode):
     where BODY ends with a return statement.
     """
 
-    def __init__(self, cond_node, body_node, body_likeliness, renderer=None):
-        assert isinstance(cond_node, CodeNode)
-        assert isinstance(body_node, SymbolScopeNode)
+    def __init__(self, cond, body, body_likeliness, renderer=None):
+        assert isinstance(cond, CodeNode)
+        assert isinstance(body, SymbolScopeNode)
         assert isinstance(body_likeliness, Likeliness.Level)
 
         gensyms = {
@@ -647,12 +662,12 @@ class ConditionalExitNode(ConditionalNode):
         template_text = CodeNode.format_template(
             """\
 if (${{{conditional}}}) {{
-  ${{{body}}}
+  ${{{body} | trim}}
 }}
 """, **gensyms)
         template_vars = {
-            gensyms["conditional"]: cond_node,
-            gensyms["body"]: body_node,
+            gensyms["conditional"]: cond,
+            gensyms["body"]: body,
         }
 
         ConditionalNode.__init__(
@@ -661,8 +676,8 @@ if (${{{conditional}}}) {{
             template_vars=template_vars,
             renderer=renderer)
 
-        self._cond_node = cond_node
-        self._body_node = body_node
+        self._cond_node = cond
+        self._body_node = body
         self._body_likeliness = body_likeliness
 
     def likeliness_of_undefined_code_symbol_usage(self, symbol_node):
@@ -683,12 +698,9 @@ class LikelyExitNode(ConditionalExitNode):
     meets.
     """
 
-    def __init__(self, cond_node, body_node):
+    def __init__(self, cond, body):
         ConditionalExitNode.__init__(
-            self,
-            cond_node=cond_node,
-            body_node=body_node,
-            body_likeliness=Likeliness.LIKELY)
+            self, cond=cond, body=body, body_likeliness=Likeliness.LIKELY)
 
 
 class UnlikelyExitNode(ConditionalExitNode):
@@ -697,9 +709,6 @@ class UnlikelyExitNode(ConditionalExitNode):
     meets.
     """
 
-    def __init__(self, cond_node, body_node):
+    def __init__(self, cond, body):
         ConditionalExitNode.__init__(
-            self,
-            cond_node=cond_node,
-            body_node=body_node,
-            body_likeliness=Likeliness.UNLIKELY)
+            self, cond=cond, body=body, body_likeliness=Likeliness.UNLIKELY)

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

@@ -24,8 +24,9 @@ class CodeNodeTest(unittest.TestCase):
         return current
 
     def assertRenderResult(self, node, expected):
-        def simplify(s):
-            return " ".join(s.split())
+        def simplify(text):
+            return "\n".join(
+                [" ".join(line.split()) for line in text.split("\n")])
 
         actual = simplify(self.render(node))
         expected = simplify(expected)
@@ -63,7 +64,7 @@ class CodeNodeTest(unittest.TestCase):
         work just same as Python built-in list.
         """
         renderer = MakoRenderer()
-        root = SequenceNode(renderer=renderer)
+        root = SequenceNode(separator=",", renderer=renderer)
         root.extend([
             LiteralNode("2"),
             LiteralNode("4"),
@@ -72,13 +73,13 @@ class CodeNodeTest(unittest.TestCase):
         root.insert(0, LiteralNode("1"))
         root.insert(100, LiteralNode("5"))
         root.append(LiteralNode("6"))
-        self.assertRenderResult(root, "1 2 3 4 5 6")
+        self.assertRenderResult(root, "1,2,3,4,5,6")
 
     def test_nested_sequence(self):
         """Tests nested SequenceNodes."""
         renderer = MakoRenderer()
-        root = SequenceNode(renderer=renderer)
-        nested = SequenceNode()
+        root = SequenceNode(separator=",", renderer=renderer)
+        nested = SequenceNode(separator=",")
         nested.extend([
             LiteralNode("2"),
             LiteralNode("3"),
@@ -89,7 +90,7 @@ class CodeNodeTest(unittest.TestCase):
             nested,
             LiteralNode("5"),
         ])
-        self.assertRenderResult(root, "1 2 3 4 5")
+        self.assertRenderResult(root, "1,2,3,4,5")
 
     def test_symbol_definition_chains(self):
         """
@@ -110,14 +111,14 @@ class CodeNodeTest(unittest.TestCase):
         root.append(TextNode("(void)${var1};"))
 
         self.assertRenderResult(
-            root, """
+            root, """\
 int var5 = 2;
 int var2 = var5;
 int var4 = 1;
 int var3 = var4;
 int var1 = var2 + var3;
 (void)var1;
-        """)
+""")
 
     def test_symbol_definition_with_exit_branches(self):
         renderer = MakoRenderer()
@@ -135,21 +136,21 @@ int var1 = var2 + var3;
         root.extend([
             TextNode("${var1};"),
             UnlikelyExitNode(
-                cond_node=TextNode("${var2}"),
-                body_node=SymbolScopeNode([
+                cond=TextNode("${var2}"),
+                body=SymbolScopeNode([
                     TextNode("${var3};"),
                     TextNode("return ${var4};"),
                 ])),
             LikelyExitNode(
-                cond_node=TextNode("${var5}"),
-                body_node=SymbolScopeNode([
+                cond=TextNode("${var5}"),
+                body=SymbolScopeNode([
                     TextNode("return ${var6};"),
                 ])),
             TextNode("${var3};"),
         ])
 
         self.assertRenderResult(
-            root, """
+            root, """\
 int var1 = 1;
 var1;
 int var2 = 2;
@@ -182,21 +183,21 @@ var3;
 
         root.extend([
             UnlikelyExitNode(
-                cond_node=LiteralNode("false"),
-                body_node=SymbolScopeNode([
+                cond=LiteralNode("false"),
+                body=SymbolScopeNode([
                     UnlikelyExitNode(
-                        cond_node=LiteralNode("false"),
-                        body_node=SymbolScopeNode([
+                        cond=LiteralNode("false"),
+                        body=SymbolScopeNode([
                             TextNode("return ${var1};"),
                         ])),
                     LiteralNode("return;"),
                 ])),
             LikelyExitNode(
-                cond_node=LiteralNode("true"),
-                body_node=SymbolScopeNode([
+                cond=LiteralNode("true"),
+                body=SymbolScopeNode([
                     LikelyExitNode(
-                        cond_node=LiteralNode("true"),
-                        body_node=SymbolScopeNode([
+                        cond=LiteralNode("true"),
+                        body=SymbolScopeNode([
                             TextNode("return ${var2};"),
                         ])),
                     LiteralNode("return;"),
@@ -204,7 +205,7 @@ var3;
         ])
 
         self.assertRenderResult(
-            root, """
+            root, """\
 if (false) {
   if (false) {
     int var1 = 1;