# 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 web_idl

from . import name_style
from .code_node import Likeliness
from .code_node import SymbolDefinitionNode
from .code_node import SymbolNode
from .code_node import TextNode
from .code_node_cxx import CxxIfElseNode
from .code_node_cxx import CxxLikelyIfNode
from .code_node_cxx import CxxUnlikelyIfNode
from .codegen_format import format_template as _format


def blink_class_name(idl_definition):
    """
    Returns the class name of Blink implementation.
    """
    class_name = idl_definition.code_generator_info.receiver_implemented_as
    if class_name:
        return class_name

    assert idl_definition.identifier[0].isupper()
    # Do not apply |name_style.class_| in order to respect the original name
    # (Web spec'ed name) as much as possible.  For example, |interface EXTsRGB|
    # is implemented as |class EXTsRGB|, not as |ExtSRgb| nor |ExtsRgb|.
    if isinstance(idl_definition,
                  (web_idl.CallbackFunction, web_idl.CallbackInterface,
                   web_idl.Enumeration)):
        return "V8{}".format(idl_definition.identifier)
    elif isinstance(idl_definition, web_idl.NewUnion):
        # Technically this name is not guaranteed to be unique because
        # (X or sequence<Y or Z>) and (X or Y or sequence<Z>) have the same
        # name, but it's highly unlikely to cause a conflict in the actual use
        # cases.  Plus, we prefer a simple naming rule conformant to the
        # Chromium coding style.  So, we go with this way.
        return "V8Union{}".format("Or".join(idl_definition.member_tokens))
    else:
        return idl_definition.identifier


def v8_bridge_class_name(idl_definition):
    """
    Returns the name of V8-from/to-Blink bridge class.
    """
    assert isinstance(
        idl_definition,
        (web_idl.CallbackInterface, web_idl.Interface, web_idl.Namespace))

    assert idl_definition.identifier[0].isupper()
    # Do not apply |name_style.class_| due to the same reason as
    # |blink_class_name|.
    return "V8{}".format(idl_definition.identifier)


def blink_type_info(idl_type, use_new_union=False):
    """
    Returns the types of Blink implementation corresponding to the given IDL
    type.  The returned object has the following attributes.

      ref_t: The type of a local variable that references to an already-existing
          value.  E.g. String => String&
      const_ref_t: A const-qualified reference type.
      value_t: The type of a variable that behaves as a value.  E.g. String =>
          String
      member_t: The type of a member variable.  E.g. T => Member<T>
      member_ref_t: The type used for input to and output from a member
          variable.  E.g. T* for Member<T> and const String& for String.
      has_null_value: True if the Blink implementation type can represent IDL
          null value by itself without use of base::Optional<T>.
    """
    assert isinstance(idl_type, web_idl.IdlType)

    class TypeInfo(object):
        def __init__(self,
                     typename,
                     member_fmt="{}",
                     ref_fmt="{}",
                     const_ref_fmt="const {}",
                     value_fmt="{}",
                     has_null_value=False,
                     clear_member_var_fmt="{}.Clear()"):
            self.typename = typename
            self.is_gc_type = is_gc_type(idl_type)
            self.ref_t = ref_fmt.format(typename)
            self.const_ref_t = const_ref_fmt.format(typename)
            self.value_t = value_fmt.format(typename)
            self.member_t = member_fmt.format(typename)
            self.member_ref_t = (self.ref_t
                                 if self.is_gc_type else self.const_ref_t)
            self.has_null_value = has_null_value
            self._clear_member_var_fmt = clear_member_var_fmt

        def clear_member_var_expr(self, var_name):
            """Returns an expression to reset the given member variable."""
            return self._clear_member_var_fmt.format(var_name)

    def is_gc_type(idl_type):
        idl_type = idl_type.unwrap()
        return bool(
            idl_type.is_buffer_source_type or
            (idl_type.type_definition_object and not idl_type.is_enumeration)
            or (idl_type.new_union_definition_object and use_new_union))

    def vector_element_type(idl_type):
        # Use |Member<T>| explicitly so that the complete type definition of
        # |T| will not be required.
        type_info = blink_type_info(idl_type)
        if type_info.is_gc_type:
            return type_info.member_t
        else:
            return type_info.typename

    real_type = idl_type.unwrap(typedef=True)

    if real_type.is_boolean or real_type.is_numeric:
        cxx_type = {
            "boolean": "bool",
            "byte": "int8_t",
            "octet": "uint8_t",
            "short": "int16_t",
            "unsigned short": "uint16_t",
            "long": "int32_t",
            "unsigned long": "uint32_t",
            "long long": "int64_t",
            "unsigned long long": "uint64_t",
            "float": "float",
            "unrestricted float": "float",
            "double": "double",
            "unrestricted double": "double",
        }
        return TypeInfo(cxx_type[real_type.keyword_typename],
                        const_ref_fmt="{}",
                        clear_member_var_fmt="{} = 0")

    if real_type.is_string:
        return TypeInfo("String",
                        ref_fmt="{}&",
                        const_ref_fmt="const {}&",
                        has_null_value=True,
                        clear_member_var_fmt="{} = String()")

    if real_type.is_array_buffer:
        assert "AllowShared" not in real_type.extended_attributes
        return TypeInfo(
            'DOM{}'.format(real_type.keyword_typename),
            member_fmt="Member<{}>",
            ref_fmt="{}*",
            const_ref_fmt="const {}*",
            value_fmt="{}*",
            has_null_value=True)

    if real_type.is_buffer_source_type:
        if "FlexibleArrayBufferView" in real_type.extended_attributes:
            assert "AllowShared" in real_type.extended_attributes
            return TypeInfo(
                "Flexible{}".format(real_type.keyword_typename),
                member_fmt="void",
                ref_fmt="{}",
                const_ref_fmt="const {}",
                value_fmt="{}",
                has_null_value=True)
        elif "AllowShared" in real_type.extended_attributes:
            return TypeInfo(
                "MaybeShared<DOM{}>".format(real_type.keyword_typename),
                has_null_value=True)
        else:
            return TypeInfo(
                "NotShared<DOM{}>".format(real_type.keyword_typename),
                has_null_value=True)

    if real_type.is_symbol:
        assert False, "Blink does not support/accept IDL symbol type."

    if real_type.is_any or real_type.is_object:
        return TypeInfo(
            "ScriptValue",
            ref_fmt="{}&",
            const_ref_fmt="const {}&",
            has_null_value=True)

    if real_type.is_void:
        assert False, "Blink does not support/accept IDL void type."

    if real_type.type_definition_object:
        blink_impl_type = blink_class_name(real_type.type_definition_object)
        if real_type.is_enumeration:
            return TypeInfo(blink_impl_type, clear_member_var_fmt="")
        return TypeInfo(
            blink_impl_type,
            member_fmt="Member<{}>",
            ref_fmt="{}*",
            const_ref_fmt="const {}*",
            value_fmt="{}*",
            has_null_value=True)

    if (real_type.is_sequence or real_type.is_frozen_array
            or real_type.is_variadic):
        typename = "VectorOf<{}>".format(
            vector_element_type(real_type.element_type))
        return TypeInfo(typename,
                        ref_fmt="{}&",
                        const_ref_fmt="const {}&",
                        clear_member_var_fmt="{}.clear()")

    if real_type.is_record:
        typename = "VectorOfPairs<{}, {}>".format(
            vector_element_type(real_type.key_type),
            vector_element_type(real_type.value_type))
        return TypeInfo(typename,
                        ref_fmt="{}&",
                        const_ref_fmt="const {}&",
                        clear_member_var_fmt="{}.clear()")

    if real_type.is_promise:
        return TypeInfo(
            "ScriptPromise", ref_fmt="{}&", const_ref_fmt="const {}&")

    if real_type.is_union and use_new_union:
        blink_impl_type = blink_class_name(
            real_type.new_union_definition_object)
        return TypeInfo(blink_impl_type,
                        member_fmt="Member<{}>",
                        ref_fmt="{}*",
                        const_ref_fmt="const {}*",
                        value_fmt="{}*",
                        has_null_value=False)

    if real_type.is_union:
        blink_impl_type = blink_class_name(real_type.union_definition_object)
        return TypeInfo(
            blink_impl_type,
            ref_fmt="{}&",
            const_ref_fmt="const {}&",
            has_null_value=True)

    if real_type.is_nullable:
        inner_type = blink_type_info(real_type.inner_type)
        if inner_type.has_null_value:
            return inner_type
        return TypeInfo("base::Optional<{}>".format(inner_type.value_t),
                        ref_fmt="{}&",
                        const_ref_fmt="const {}&",
                        clear_member_var_fmt="{}.reset()")

    assert False, "Unknown type: {}".format(idl_type.syntactic_form)


def native_value_tag(idl_type, argument=None, apply_optional_to_last_arg=True):
    """Returns the tag type of NativeValueTraits."""
    assert isinstance(idl_type, web_idl.IdlType)
    assert argument is None or isinstance(argument, web_idl.Argument)

    if (idl_type.is_optional and argument
            and not (idl_type.is_nullable or argument.default_value)
            and (apply_optional_to_last_arg
                 or argument != argument.owner.arguments[-1])):
        return "IDLOptional<{}>".format(_native_value_tag_impl(idl_type))

    return _native_value_tag_impl(idl_type)


def _native_value_tag_impl(idl_type):
    """Returns the tag type of NativeValueTraits."""
    assert isinstance(idl_type, web_idl.IdlType)

    if idl_type.is_typedef:
        if idl_type.identifier in ("EventHandler",
                                   "OnBeforeUnloadEventHandler",
                                   "OnErrorEventHandler"):
            return "IDL{}".format(idl_type.identifier)

    real_type = idl_type.unwrap(typedef=True)

    if (real_type.is_boolean or real_type.is_numeric or real_type.is_any
            or real_type.is_object):
        return "IDL{}".format(
            idl_type.type_name_with_extended_attribute_key_values)

    if real_type.is_string:
        return "IDL{}V2".format(
            idl_type.type_name_with_extended_attribute_key_values)

    if real_type.is_array_buffer:
        return blink_type_info(real_type).typename

    if real_type.is_buffer_source_type:
        return blink_type_info(real_type).value_t

    if real_type.is_symbol:
        assert False, "Blink does not support/accept IDL symbol type."

    if real_type.is_void:
        assert False, "Blink does not support/accept IDL void type."

    if real_type.type_definition_object:
        return blink_class_name(real_type.type_definition_object)

    if real_type.is_sequence:
        return "IDLSequence<{}>".format(
            _native_value_tag_impl(real_type.element_type))

    if real_type.is_frozen_array:
        return "IDLArray<{}>".format(
            _native_value_tag_impl(real_type.element_type))

    if real_type.is_record:
        return "IDLRecord<{}, {}>".format(
            _native_value_tag_impl(real_type.key_type),
            _native_value_tag_impl(real_type.value_type))

    if real_type.is_promise:
        return "IDLPromise"

    if real_type.is_union:
        class_name = blink_class_name(real_type.union_definition_object)
        if real_type.does_include_nullable_type:
            return "IDLUnionINT<{}>".format(class_name)
        return "IDLUnionNotINT<{}>".format(class_name)

    if real_type.is_nullable:
        return "IDLNullable<{}>".format(
            _native_value_tag_impl(real_type.inner_type))

    assert False, "Unknown type: {}".format(idl_type.syntactic_form)


def make_blink_to_v8_value(
        v8_var_name,
        blink_value_expr,
        idl_type,
        argument=None,
        error_exit_return_statement="return v8::MaybeLocal<v8::Value>();",
        creation_context_script_state="${script_state}"):
    """
    Returns a SymbolNode whose definition converts a Blink value to a v8::Value.
    """
    assert isinstance(v8_var_name, str)
    assert isinstance(blink_value_expr, str)
    assert isinstance(idl_type, web_idl.IdlType)
    assert argument is None or isinstance(argument, web_idl.Argument)
    assert isinstance(error_exit_return_statement, str)
    assert isinstance(creation_context_script_state, str)

    T = TextNode
    F = lambda *args, **kwargs: T(_format(*args, **kwargs))

    def create_definition(symbol_node):
        binds = {
            "blink_value_expr": blink_value_expr,
            "creation_context_script_state": creation_context_script_state,
            "native_value_tag": native_value_tag(idl_type, argument=argument),
            "v8_var_name": v8_var_name,
        }
        pattern = ("!ToV8Traits<{native_value_tag}>::ToV8("
                   "{creation_context_script_state}, {blink_value_expr})"
                   ".ToLocal(&{v8_var_name})")
        nodes = [
            F("v8::Local<v8::Value> {v8_var_name};", **binds),
            CxxUnlikelyIfNode(cond=F(pattern, **binds),
                              body=T(error_exit_return_statement)),
        ]
        return SymbolDefinitionNode(symbol_node, nodes)

    return SymbolNode(v8_var_name, definition_constructor=create_definition)


def make_default_value_expr(idl_type, default_value):
    """
    Returns a set of C++ expressions to be used for initialization with default
    values.  The returned object has the following attributes.

      initializer_expr: Used as "Type var{|initializer_expr|};".  This is None
          if "Type var;" sets an appropriate default value.
      initializer_deps: A list of symbol names that |initializer_expr| depends
          on.
      is_initialization_lightweight: True if a possibly-redundant initialization
          will not be more expensive than assignment.  See bellow for an
          example.
      assignment_value: Used as "var = |assignment_value|;".
      assignment_deps: A list of symbol names that |assignment_value| depends
          on.


    |is_initialization_lightweight| is True if

      Type var{${initializer_expr}};
      if (value_is_given)
        var = value;

    is not more expensive than

      Type var;
      if (value_is_given)
        var = value;
      else
        var = ${assignment_value};
    """
    assert isinstance(idl_type, web_idl.IdlType)
    assert (default_value is None
            or isinstance(default_value, web_idl.LiteralConstant))
    assert default_value.is_type_compatible_with(idl_type)

    class DefaultValueExpr(object):
        _ALLOWED_SYMBOLS_IN_DEPS = ("isolate")

        def __init__(self, initializer_expr, initializer_deps,
                     is_initialization_lightweight, assignment_value,
                     assignment_deps):
            assert initializer_expr is None or isinstance(
                initializer_expr, str)
            assert (isinstance(initializer_deps, (list, tuple)) and all(
                dependency in DefaultValueExpr._ALLOWED_SYMBOLS_IN_DEPS
                for dependency in initializer_deps))
            assert isinstance(is_initialization_lightweight, bool)
            assert isinstance(assignment_value, str)
            assert (isinstance(assignment_deps, (list, tuple)) and all(
                dependency in DefaultValueExpr._ALLOWED_SYMBOLS_IN_DEPS
                for dependency in assignment_deps))

            self.initializer_expr = initializer_expr
            self.initializer_deps = initializer_deps
            self.is_initialization_lightweight = is_initialization_lightweight
            self.assignment_value = assignment_value
            self.assignment_deps = assignment_deps

    if idl_type.unwrap(typedef=True).is_union:
        union_type = idl_type.unwrap(typedef=True)
        member_type = None
        for member_type in union_type.flattened_member_types:
            if default_value.is_type_compatible_with(member_type):
                member_type = member_type
                break
        assert member_type is not None

        union_class_name = blink_class_name(union_type.union_definition_object)
        member_default_expr = make_default_value_expr(member_type,
                                                      default_value)
        if default_value.idl_type.is_nullable:
            initializer_expr = None
            assignment_value = _format("{}()", union_class_name)
        else:
            func_name = name_style.func("From", member_type.type_name)
            argument = member_default_expr.assignment_value
            # TODO(peria): Remove this workaround when we support V8Enum types
            # in Union.
            if (member_type.is_sequence
                    and member_type.element_type.unwrap().is_enumeration):
                argument = "{}"
            initializer_expr = _format("{}::{}({})", union_class_name,
                                       func_name, argument)
            assignment_value = initializer_expr
        return DefaultValueExpr(
            initializer_expr=initializer_expr,
            initializer_deps=member_default_expr.initializer_deps,
            is_initialization_lightweight=False,
            assignment_value=assignment_value,
            assignment_deps=member_default_expr.assignment_deps)

    type_info = blink_type_info(idl_type)

    is_initialization_lightweight = False
    initializer_deps = []
    assignment_deps = []
    if default_value.idl_type.is_nullable:
        if not type_info.has_null_value:
            initializer_expr = None  # !base::Optional::has_value() by default
            assignment_value = "base::nullopt"
        elif idl_type.unwrap().type_definition_object is not None:
            initializer_expr = "nullptr"
            is_initialization_lightweight = True
            assignment_value = "nullptr"
        elif idl_type.unwrap().is_string:
            initializer_expr = None  # String::IsNull() by default
            assignment_value = "String()"
        elif idl_type.unwrap().is_buffer_source_type:
            initializer_expr = "nullptr"
            is_initialization_lightweight = True
            assignment_value = "nullptr"
        elif type_info.value_t == "ScriptValue":
            initializer_expr = "${isolate}, v8::Null(${isolate})"
            initializer_deps = ["isolate"]
            assignment_value = "ScriptValue::CreateNull(${isolate})"
            assignment_deps = ["isolate"]
        elif idl_type.unwrap().is_union:
            initializer_expr = None  # <union_type>::IsNull() by default
            assignment_value = "{}()".format(type_info.value_t)
        else:
            assert False
    elif default_value.idl_type.is_sequence:
        initializer_expr = None  # VectorOf<T>::size() == 0 by default
        assignment_value = "{}()".format(type_info.value_t)
    elif default_value.idl_type.is_object:
        dict_name = blink_class_name(idl_type.unwrap().type_definition_object)
        value = _format("{}::Create(${isolate})", dict_name)
        initializer_expr = value
        initializer_deps = ["isolate"]
        assignment_value = value
        assignment_deps = ["isolate"]
    elif default_value.idl_type.is_boolean:
        value = "true" if default_value.value else "false"
        initializer_expr = value
        is_initialization_lightweight = True
        assignment_value = value
    elif default_value.idl_type.is_integer:
        initializer_expr = default_value.literal
        is_initialization_lightweight = True
        assignment_value = default_value.literal
    elif default_value.idl_type.is_floating_point_numeric:
        if default_value.value == float("NaN"):
            value_fmt = "std::numeric_limits<{type}>::quiet_NaN()"
        elif default_value.value == float("Infinity"):
            value_fmt = "std::numeric_limits<{type}>::infinity()"
        elif default_value.value == float("-Infinity"):
            value_fmt = "-std::numeric_limits<{type}>::infinity()"
        else:
            value_fmt = "{value}"
        value = value_fmt.format(
            type=type_info.value_t, value=default_value.literal)
        initializer_expr = value
        is_initialization_lightweight = True
        assignment_value = value
    elif default_value.idl_type.is_string:
        if idl_type.unwrap().is_string:
            value = "\"{}\"".format(default_value.value)
            initializer_expr = value
            assignment_value = value
        elif idl_type.unwrap().is_enumeration:
            enum_class_name = blink_class_name(
                idl_type.unwrap().type_definition_object)
            enum_value_name = name_style.constant(default_value.value)
            initializer_expr = "{}::Enum::{}".format(enum_class_name,
                                                     enum_value_name)
            is_initialization_lightweight = True
            assignment_value = "{}({})".format(enum_class_name,
                                               initializer_expr)
        else:
            assert False
    else:
        assert False

    return DefaultValueExpr(
        initializer_expr=initializer_expr,
        initializer_deps=initializer_deps,
        is_initialization_lightweight=is_initialization_lightweight,
        assignment_value=assignment_value,
        assignment_deps=assignment_deps)


def make_v8_to_blink_value(blink_var_name,
                           v8_value_expr,
                           idl_type,
                           argument=None,
                           error_exit_return_statement="return;",
                           cg_context=None):
    """
    Returns a SymbolNode whose definition converts a v8::Value to a Blink value.
    """
    assert isinstance(blink_var_name, str)
    assert isinstance(v8_value_expr, str)
    assert isinstance(idl_type, web_idl.IdlType)
    assert argument is None or isinstance(argument, web_idl.Argument)
    assert isinstance(error_exit_return_statement, str)

    T = TextNode
    F = lambda *args, **kwargs: T(_format(*args, **kwargs))

    # Use of fast path is a trade-off between speed and binary size, so apply
    # it only when it's effective.  This hack is most significant on Android.
    use_fast_path = (
        cg_context and cg_context.operation
        and not (cg_context.is_return_type_promise_type or
                 "RaisesException" in cg_context.operation.extended_attributes)
        and all((arg.idl_type.type_name == "String" or arg.idl_type.unwrap(
            typedef=True).is_callback_function)
                for arg in cg_context.operation.arguments))
    fast_path_cond = None
    fast_path_body_text = None
    if not use_fast_path:
        pass
    elif idl_type.type_name == "String":
        # A key point of this fast path is that it doesn't require an
        # ExceptionState.
        fast_path_cond = "LIKELY({}->IsString())".format(v8_value_expr)
        fast_path_body_text = "{}.Init({}.As<v8::String>());".format(
            blink_var_name, v8_value_expr)
    elif idl_type.unwrap(typedef=True).is_callback_function:
        # A key point of this fast path is that it doesn't require an
        # ExceptionState.
        fast_path_cond = "LIKELY({}->IsFunction())".format(v8_value_expr)
        fast_path_body_text = "{} = {}::Create({}.As<v8::Function>());".format(
            blink_var_name,
            blink_class_name(idl_type.unwrap().type_definition_object),
            v8_value_expr)

    def create_definition(symbol_node):
        if argument is None:
            func_name = "NativeValue"
            arguments = ["${isolate}", v8_value_expr, "${exception_state}"]
        else:
            func_name = "ArgumentValue"
            arguments = [
                "${isolate}",
                str(argument.index),
                v8_value_expr,
                "${exception_state}",
            ]
        if "StringContext" in idl_type.effective_annotations:
            arguments.append("${execution_context_of_document_tree}")
        blink_value_expr = _format("NativeValueTraits<{_1}>::{_2}({_3})",
                                   _1=native_value_tag(
                                       idl_type,
                                       argument=argument,
                                       apply_optional_to_last_arg=False),
                                   _2=func_name,
                                   _3=", ".join(arguments))
        if argument and argument.default_value:
            default_expr = make_default_value_expr(idl_type,
                                                   argument.default_value)
        else:
            default_expr = None
        exception_exit_node = CxxUnlikelyIfNode(
            cond="${exception_state}.HadException()",
            body=T(error_exit_return_statement))

        if not (default_expr or fast_path_cond):
            return SymbolDefinitionNode(symbol_node, [
                F("auto&& ${{{}}} = {};", blink_var_name, blink_value_expr),
                exception_exit_node,
            ])

        blink_var_type = _format(
            "decltype(NativeValueTraits<{}>::NativeValue("
            "std::declval<v8::Isolate*>(), "
            "std::declval<v8::Local<v8::Value>>(), "
            "std::declval<ExceptionState&>()))",
            native_value_tag(idl_type,
                             argument=argument,
                             apply_optional_to_last_arg=False))
        if default_expr and default_expr.is_initialization_lightweight:
            pattern = "{} ${{{}}}{{{}}};"
            args = [
                blink_var_type, blink_var_name, default_expr.initializer_expr
            ]
        else:
            pattern = "{} ${{{}}};"
            args = [blink_var_type, blink_var_name]
        blink_var_def_node = F(pattern, *args)
        assignment = [
            F("${{{}}} = {};", blink_var_name, blink_value_expr),
            exception_exit_node,
        ]
        if not default_expr:
            pass
        elif (default_expr.initializer_expr is None
              or default_expr.is_initialization_lightweight):
            assignment = CxxLikelyIfNode(
                cond="!{}->IsUndefined()".format(v8_value_expr),
                body=assignment)
        else:
            assignment = CxxIfElseNode(
                cond="{}->IsUndefined()".format(v8_value_expr),
                then=F("${{{}}} = {};", blink_var_name,
                       default_expr.assignment_value),
                then_likeliness=Likeliness.LIKELY,
                else_=assignment,
                else_likeliness=Likeliness.LIKELY)
        if fast_path_cond:
            assignment = CxxIfElseNode(cond=fast_path_cond,
                                       then=T(fast_path_body_text),
                                       then_likeliness=Likeliness.LIKELY,
                                       else_=assignment,
                                       else_likeliness=Likeliness.UNLIKELY)
        return SymbolDefinitionNode(symbol_node, [
            blink_var_def_node,
            assignment,
        ])

    return SymbolNode(blink_var_name, definition_constructor=create_definition)


def make_v8_to_blink_value_variadic(blink_var_name, v8_array,
                                    v8_array_start_index, idl_type):
    """
    Returns a SymbolNode whose definition converts an array of v8::Value
    (variadic arguments) to a Blink value.
    """
    assert isinstance(blink_var_name, str)
    assert isinstance(v8_array, str)
    assert isinstance(v8_array_start_index, int)
    assert isinstance(idl_type, web_idl.IdlType)

    pattern = ("auto&& ${{{_1}}} = "
               "bindings::VariadicArgumentsToNativeValues<{_2}>({_3});")
    arguments = [
        "${isolate}", v8_array,
        str(v8_array_start_index), "${exception_state}"
    ]
    if "StringContext" in idl_type.element_type.effective_annotations:
        arguments.append("${execution_context_of_document_tree}")
    text = _format(
        pattern,
        _1=blink_var_name,
        _2=native_value_tag(idl_type.element_type),
        _3=", ".join(arguments))

    def create_definition(symbol_node):
        return SymbolDefinitionNode(symbol_node, [
            TextNode(text),
            CxxUnlikelyIfNode(
                cond="${exception_state}.HadException()",
                body=TextNode("return;")),
        ])

    return SymbolNode(blink_var_name, definition_constructor=create_definition)