Revert "bind-gen: Support generation of function definitions."

This reverts commit b3a546fe.

Reason for revert: 
On Win and Linux rel builder and others:

ninja explain: output gen/third_party/blink/renderer/bindings/core/v8/v8_example.cc doesn't exist

https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket.appspot.com/8898644624214693520/+/steps/compile_confirm_no-op/0/stdout

Original change's description:
> bind-gen: Support generation of function definitions.
> 
> This is just a first step to support the code generation
> of bindings callback functions.
> 
> Introduces CodeGenerationContext for convenience, and
> also demonstrates make_common_local_vars().
> 
> Bug: 839389
> Change-Id: I9ff49b4bfc6bd98e6b29687cc01f986c2baa01fa
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1855325
> Reviewed-by: Hitoshi Yoshida <peria@chromium.org>
> Commit-Queue: Yuki Shiino <yukishiino@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#709389}

TBR=peria@chromium.org,yukishiino@chromium.org

Change-Id: I99f572736c546f5f7078c6653d963264e6622512
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 839389
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1879933Reviewed-by: Markus Heintz <markusheintz@chromium.org>
Commit-Queue: Markus Heintz <markusheintz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709402}

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

-# Copyright 2019 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-import copy
-
-
-class CodeGenerationContext(object):
-    """
-    Represents a context of code generation.
-
-    Note that this is not relevant to Mako template context or any contexts.
-    Also note that CodeGenerationContext's attributes will be global template
-    variables.  |CodeGenerationContext.interface| will be available in templates
-    as "${interface}".
-    """
-
-    # "world" attribute values
-    MAIN_WORLD = "main"
-    ALL_WORLDS = "all"
-
-    @classmethod
-    def init(cls):
-        """Initialize the class.  Must be called exactly once."""
-        assert not hasattr(cls, "_was_initialized"), "Do not call twice."
-        cls._was_initialized = True
-
-        # List of
-        #   attribute name: default value
-        cls._context_attrs = {
-            # Top-level definition
-            "callback_interface": None,
-            "dictionary": None,
-            "interface": None,
-            "namespace": None,
-
-            # Class-member-ish definition
-            "attribute": None,
-            "attribute_get": False,
-            "attribute_set": False,
-            "constant": None,
-            "constructor": None,
-            "constructor_group": None,
-            "dict_member": None,
-            "operation": None,
-            "operation_group": None,
-
-            # Main world or all worlds
-            "world": cls.ALL_WORLDS,
-        }
-
-        # List of computational attribute names
-        cls._computational_attrs = (
-            "class_like",
-            "member_like",
-            "property",
-        )
-
-        # Define public readonly properties of this class.
-        for attr in cls._context_attrs.iterkeys():
-
-            def make_get():
-                _attr = cls._internal_attr(attr)
-
-                def get(self):
-                    return getattr(self, _attr)
-
-                return get
-
-            setattr(cls, attr, property(make_get()))
-
-    @staticmethod
-    def _internal_attr(attr):
-        return "_{}".format(attr)
-
-    def __init__(self, **kwargs):
-        assert CodeGenerationContext._was_initialized
-
-        for arg in kwargs.iterkeys():
-            assert arg in self._context_attrs, "Unknown argument: {}".format(
-                arg)
-
-        for attr, default_value in self._context_attrs.iteritems():
-            value = kwargs[attr] if attr in kwargs else default_value
-            assert (default_value is None
-                    or type(value) is type(default_value)), (
-                        "Type mismatch at argument: {}".format(attr))
-            setattr(self, self._internal_attr(attr), value)
-
-    def make_copy(self, **kwargs):
-        """
-        Returns a copy of this context applying the updates given as the
-        arguments.
-        """
-        for arg in kwargs.iterkeys():
-            assert arg in self._context_attrs, "Unknown argument: {}".format(
-                arg)
-
-        new_object = copy.copy(self)
-
-        for attr, new_value in kwargs.iteritems():
-            old_value = getattr(self, attr)
-            assert old_value is None or type(new_value) is type(old_value), (
-                "Type mismatch at argument: {}".format(attr))
-            setattr(new_object, self._internal_attr(attr), new_value)
-
-        return new_object
-
-    def template_bindings(self):
-        """
-        Returns a bindings object to be passed into
-        |CodeNode.add_template_vars|.  Only properties with a non-None value are
-        bound so that it's easy to detect invalid use cases (use of an unbound
-        template variable raises a NameError).
-        """
-        bindings = {}
-
-        for attr in self._context_attrs.iterkeys():
-            value = getattr(self, attr)
-            if value is not None:
-                bindings[attr] = value
-
-        for attr in self._computational_attrs:
-            value = getattr(self, attr)
-            if value is not None:
-                bindings[attr] = value
-
-        return bindings
-
-    @property
-    def class_like(self):
-        return (self.callback_interface or self.dictionary or self.interface
-                or self.namespace)
-
-    @property
-    def member_like(self):
-        return (self.attribute or self.constant or self.constructor
-                or self.dict_member or self.operation)
-
-    @property
-    def property(self):
-        return (self.attribute or self.constant or self.constructor_group
-                or self.dict_member or self.operation_group)
-
-
-CodeGenerationContext.init()

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

@@ -479,11 +479,10 @@ class SymbolNode(CodeNode):
             self._definition_node_constructor = definition_node_constructor
 
     def _render(self, renderer, last_render_state):
-        for caller in renderer.callers:
-            assert isinstance(caller, CodeNode)
-            if caller.is_code_symbol_defined(self):
-                break
-            caller.on_undefined_code_symbol_found(self)
+        if not renderer.last_caller.is_code_symbol_defined(self):
+            for caller in renderer.callers:
+                assert isinstance(caller, CodeNode)
+                caller.on_undefined_code_symbol_found(self)
 
         return self.name
 

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

@@ -4,129 +4,28 @@
 
 import os.path
 
+from . import code_node
 from .clang_format import clang_format
-from .code_generation_context import CodeGenerationContext
-from .code_node import CodeNode
-from .code_node import FunctionDefinitionNode
-from .code_node import LiteralNode
-from .code_node import SymbolNode
-from .code_node import SymbolScopeNode
-from .code_node import TextNode
 from .mako_renderer import MakoRenderer
 
 
-def make_common_local_vars(cg_context):
-    S = SymbolNode
-    T = TextNode
-
-    local_vars = []
-    supplemental_bindings = {}
-
-    local_vars.extend([
-        S("class_like_name", ("const char* const ${class_like_name} = "
-                              "\"${class_like.identifier}\";")),
-        S("current_context", ("v8::Local<v8::Context> ${current_context} = "
-                              "${isolate}->GetCurrentContext();")),
-        S("current_script_state", ("ScriptState* ${current_script_state} = "
-                                   "ScriptState::ForCurrentRealm(${info});")),
-        S("exception_state",
-          ("ExceptionState ${exception_state}("
-           "${isolate}, ${exception_state_context_type}, ${class_like_name}, "
-           "${property_name});${reject_promise_scope_definition}")),
-        S("isolate", "v8::Isolate* ${isolate} = ${info}.GetIsolate();"),
-        S("per_context_data", ("V8PerContextData* ${per_context_data} = "
-                               "${script_state}->PerContextData();")),
-        S("per_isolate_data", ("V8PerIsolateData* ${per_isolate_data} = "
-                               "V8PerIsolateData::From(${isolate});")),
-        S("property_name",
-          "const char* const ${property_name} = \"${property.identifier}\";"),
-        S("receiver", "v8::Local<v8::Object> ${receiver} = ${info}.This();"),
-        S("receiver_context", ("v8::Local<v8::Context> ${receiver_context} = "
-                               "${receiver_script_state}->GetContext();")),
-        S("receiver_script_state",
-          ("ScriptState* ${receiver_script_state} = "
-           "ScriptState::ForRelevantRealm(${info});")),
-    ])
-
-    # script_state
-    def_text = "ScriptState* ${script_state} = {_1};"
-    if cg_context.member_like and not cg_context.member_like.is_static:
-        _1 = "${receiver_script_state}"
-    else:
-        _1 = "${current_script_state}"
-    local_vars.append(
-        S("script_state", CodeNode.format_template(def_text, _1=_1)))
-
-    # exception_state_context_type
-    def_text = (
-        "const ExceptionState::ContextType ${exception_state_context_type} = "
-        "{_1};")
-    if cg_context.attribute_get:
-        _1 = "ExceptionState::kGetterContext"
-    elif cg_context.attribute_set:
-        _1 = "ExceptionState::kSetterContext"
-    elif cg_context.constructor:
-        _1 = "ExceptionState::kConstructionContext"
-    else:
-        _1 = "ExceptionState::kExecutionContext"
-    local_vars.append(
-        S("exception_state_context_type",
-          CodeNode.format_template(def_text, _1=_1)))
-
-    # reject_promise_scope_definition
-    if ((cg_context.attribute_get and cg_context.attribute.idl_type.is_promise)
-            or (cg_context.operation
-                and cg_context.operation.return_type.is_promise)):
-        template_text = ("\n"
-                         "ExceptionToRejectPromiseScope reject_promise_scope"
-                         "(${info}, ${exception_state});")
-    else:
-        template_text = ""
-    supplemental_bindings["reject_promise_scope_definition"] = T(template_text)
-
-    return local_vars, supplemental_bindings
-
-
-def make_attribute_get_def(cg_context):
-    L = LiteralNode
-    T = TextNode
-
-    cg_context = cg_context.make_copy(attribute_get=True)
-
-    local_vars, local_vars_bindings = make_common_local_vars(cg_context)
-
-    func_def = FunctionDefinitionNode(
-        name=L("AttributeGetCallback"),
-        arg_decls=[L("const v8::FunctionCallbackInfo<v8::Value>& info")],
-        return_type=L("void"),
-        local_vars=local_vars)
-
-    body = func_def.body
-    body.add_template_var("info", "info")
-    body.add_template_vars(local_vars_bindings)
-    body.add_template_vars(cg_context.template_bindings())
-
-    body.extend([
-        T("(void)(${per_context_data}, ${exception_state});"),
-    ])
-
-    return func_def
-
-
 def run_example(web_idl_database, output_dirs):
     renderer = MakoRenderer()
 
     filename = 'v8_example.cc'
-    filepath = os.path.join(os.path.dirname(__file__), filename)
-
-    namespace = list(web_idl_database.namespaces)[0]
-    attribute = namespace.attributes[0]
+    filepath = os.path.join(output_dirs['core'], filename)
 
-    cg_context = CodeGenerationContext(
-        namespace=namespace, attribute=attribute)
+    root_node = code_node.SymbolScopeNode(renderer=renderer)
+    root_node.extend([
+        code_node.TextNode("${z} = ${x} + ${y};"),
+        code_node.TextNode("print ${z};"),
+    ])
 
-    root_node = SymbolScopeNode(renderer=renderer)
-    root_node.append(make_attribute_get_def(cg_context))
+    root_node.register_code_symbols([
+        code_node.SymbolNode('x', "int ${x} = 1;"),
+        code_node.SymbolNode('y', "int ${y} = 2;"),
+        code_node.SymbolNode('z', "int ${z};"),
+    ])
 
     prev = ''
     current = str(root_node)

third_party/blink/renderer/bindings/scripts/bind_gen/v8_example.cc

-void AttributeGetCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
-  ScriptState* current_script_state = ScriptState::ForCurrentRealm(info);
-  ScriptState* script_state = current_script_state;
-  V8PerContextData* per_context_data = script_state->PerContextData();
-  v8::Isolate* isolate = info.GetIsolate();
-  const ExceptionState::ContextType exception_state_context_type =
-      ExceptionState::kGetterContext;
-  const char* const class_like_name = "TestNamespace";
-  const char* const property_name = "attr1";
-  ExceptionState exception_state(isolate, exception_state_context_type,
-                                 class_like_name, property_name);
-  ExceptionToRejectPromiseScope reject_promise_scope(info, exception_state);
-  (void)(per_context_data, exception_state);
-}

third_party/blink/renderer/bindings/scripts/generate_bindings.pydeps

@@ -21,7 +21,6 @@
 ../../build/scripts/blinkbuild/name_style_converter.py
 bind_gen/__init__.py
 bind_gen/clang_format.py
-bind_gen/code_generation_context.py
 bind_gen/code_node.py
 bind_gen/example.py
 bind_gen/mako_renderer.py

third_party/blink/renderer/bindings/scripts/web_idl/idl_compiler_test.idl

@@ -12,7 +12,7 @@
 };
 
 namespace TestNamespace {
-  readonly attribute Promise<boolean> attr1;
+  readonly attribute boolean attr1;
   readonly attribute DOMString attr2;
   void op1();
 };