zircon/public/gn/fidl.gni - fuchsia - Git at Google

 # Copyright 2019 The Fuchsia 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("$zx/public/gn/fidl/fidlc.gni")

 # List of FIDL support modules.  Each of these defines its own version of
 # $fidl_support_fidlc and $fidl_support_templates.
 #
 # $fidl_support_templates:
 # Type: list of scopes
 #
 #   import
 #     Required: Source-absolute path to the .gni file that defines $target.
 #     Type: file
 #
 #   target
 #     Required: Name of a template to invoke, defined in the $import file.
 #     Type: string
 #
 #   fidlc
 #     Optional: Name of an entry in $fidl_support_fidlc describing fidlc
 #     outputs that this template requires.
 #
 # The $target template is invoked with the $target_name from fidl_library()
 # and these parameters:
 #
 #   fidl_deps
 #     Required: $public_deps list from fidl_library() after canonicalization.
 #     Type: list(label_no_toolchain)
 #
 #   fidl_name
 #     Required: The FIDL library name (with dots).
 #     Type: string
 #
 #   fidl_path
 #     Required: $fidl_name with each `.` replaced by a `/`.
 #     Type: string
 #
 #   fidl_gen_dir
 #     Optional: If $fidlc was set, this is the directory in which those
 #     fidlc outputs went.  e.g. "$fidl_gen_dir/include" might be useful.
 #     Type: file
 #
 #   fidlc_outputs
 #     Optional: If $fidlc was set, this is the list of output files generated
 #     by fidlc for that entry in $fidl_support_fidlc.
 #
 #   fidlc_deps
 #     Optional: If $fidlc was set, this is the label to include in $deps
 #     of something using $fidlc_outputs.
 #
 #   visibility, testonly
 #     Optional: Forwarded from fidl_library().
 #
 # $fidl_support_fidlc:
 # Type: list of scopes
 #
 #   name
 #     Required: Name for this collection of fidlc output
 #     Type: string
 #
 #   files
 #     Required: A list of scopes describing outputs from fidlc.
 #     Type: list of scopes
 #       switch
 #         Required: fidlc command-line switch preceding output file name.
 #         Type: string
 #       path
 #         Optional: Required unless $path_prefix and $path_suffix are given.
 #         The fidlc output file is "$fidl_gen_dir/$path".
 #         Type: string
 #       path_prefix, path_suffix
 #         Optional: If one is specified, both must be and $path must not be.
 #         The output file is "$fidl_gen_dir/$path_prefix$fidl_path$path_suffix".
 #         Type: string
 #
 # All these kinds of output will be generated in one run of fidlc.  Modules
 # should use the $fidl_support_fidlc list only for generation work that is
 # more or less free once you're running fidlc anyway.  These output files
 # will be generated if *any* $fidl_support_fidlc output file from *any*
 # support module is needed in the build.  For more costly generation steps
 # (or ones requiring more than a simple fidlc command-line switch), support
 # modules should use $fidl_support_templates.
 #
 # TODO(mcgrathr): Add more language generators.  For language support from
 # a different petal, add a build argument to contribute to this list via
 # default_overrides.
 fidl_support = [
   "$zx/public/gn/fidl/c.gni",
   "$zx/public/gn/fidl/json.gni",
   "$zx/public/gn/fidl/llcpp.gni",
   "$zx/public/gn/fidl/tables.gni",
 ]

 # Each support module defines $fidl_support_fidlc and
 # $fidl_support_templates lists in its .gni file.
 _fidl_generators = []
 foreach(module, fidl_support) {
   _fidl_generators += [
     {
       import(module)
     },
   ]
 }

 # Collect all fidlc outputs from the support modules, and deduplicate.
 # Collect all the generation templates to invoke, and deduplicate.  All
 # these templates will be invoked by fidl_library() to define their targets.
 _fidl_gen_fidlc = []
 _fidl_gen_templates = []
 foreach(gen, _fidl_generators) {
   if (defined(gen.fidl_support_fidlc)) {
     _fidl_gen_fidlc += gen.fidl_support_fidlc
     _fidl_gen_fidlc -= gen.fidl_support_fidlc
     _fidl_gen_fidlc += gen.fidl_support_fidlc
   }
   if (defined(gen.fidl_support_templates)) {
     _fidl_gen_templates += gen.fidl_support_templates
     _fidl_gen_templates -= gen.fidl_support_templates
     _fidl_gen_templates += gen.fidl_support_templates
   }
 }

 # Define a FIDL library and implicitly generate bindings targets.
 #
 # The $fidl_support global determines what targets this actually produces.
 #
 # Parameters
 #
 #   sources
 #     Required: List of `.fidl` source files.  Note that if any file names
 #     ending in `.test.fidl` are present, $testonly is automatically set
 #     to true and cannot be explicitly set to false.
 #     Type: list(file)
 #
 #   deps
 #     Optional: This is *not* the way to express dependencies on other FIDL
 #     libraries.  Use $public_deps for that.  The only use for $deps is if
 #     some of $sources are generated, to depend on the targets generating them.
 #     Type: list(label)
 #
 #   public_deps
 #     Optional: Other fidl_library() targets this library depends on.
 #     If `using foo;` appears in a $sources file, then the label of the
 #     fidl_library() target should be listed here.  This must list only
 #     other fidl_library() targets and may not use a "(toolchain)" suffix.
 #     Type: list(label_no_toolchain)
 #
 #   sdk
 #     Optional: This library is exported to the SDK.
 #     Type: bool
 #     Default: false
 #
 #   testonly
 #     Optional: Usual GN meaning: dependent targets must also set $testonly.
 #     Type: bool
 #     Default: true iff $sources includes "*.test.fidl" files
 #
 #   fuzzers
 #     Optional: Protocol/methods for which to generate LibFuzzer fuzz targets.
 #       Example:
 #       [
 #         {
 #           # Required:
 #           protocol = "fully.qualified.FIDLProtocolName"
 #           # Optional. Default: All methods in protocol.
 #           methods = [ "MethodName1", "MethodName2", ... ]
 #         },
 #         ...
 #       ]
 #     Type: list({protocol, methods})
 #
 #   targets
 #     Optional: Subset of bindings types to generate for this library.
 #     Each element is the name of a template from $fidl_support_templates.
 #     If this is set, then $visibility must be very restricted, since any
 #     public fidl_library() might be used via any and all language bindings.
 #     Type: list(string)
 #     Default: All $fidl_support_templates defined by $fidl_support modules.
 #
 template("fidl_library") {
   if (defined(invoker.fuzzers)) {
     not_needed(invoker, [ "fuzzers" ])
   }

   assert(defined(invoker.sources),
          "fidl_library(\"$target_name\") must set `sources`")

   foreach(file, invoker.sources) {
     assert(get_path_info(file, "extension") == "fidl",
            "fidl_library() sources should be `.fidl` files, not $file")
     file = get_path_info(file, "name")
     if (get_path_info(file, "extension") == "test") {
       assert(!defined(invoker.testonly) || invoker.testonly,
              "fidl_library(\"$target_name\") is implicitly testonly since " +
                  " it has `.test.fidl` sources; cannot use testonly=false!")
       invoker.testonly = true
     }
   }

   if (defined(invoker.targets)) {
     assert(defined(invoker.visibility),
            "must constrain visibility when constraining targets")

     # Select the subset of fidlc outputs the enabled targets require.
     targets_gen_templates = []
     fidlc_needed = []
     foreach(target, invoker.targets) {
       found = false
       foreach(gen, _fidl_gen_templates) {
         if (gen.target == target) {
           found = true
           targets_gen_templates += [ gen ]
           if (defined(gen.fidlc)) {
             fidlc_needed += [ gen.fidlc ]
           }
         }
       }
       assert(found, "fidl_library() doesn't generate $target()")
     }

     # Generate only those below.
     targets_gen_fidlc = []
     foreach(gen, _fidl_gen_fidlc) {
       if (fidlc_needed + [ gen.name ] - [ gen.name ] != fidlc_needed) {
         targets_gen_fidlc += [ gen ]
       }
     }
   } else {
     # Usual case: generate them all.
     targets_gen_templates = _fidl_gen_templates
     targets_gen_fidlc = _fidl_gen_fidlc
   }

   fidl_target = target_name

   # TODO(mcgrathr): temporary until everything is renamed with . names
   fidl_name = string_replace(fidl_target, "-", ".")
   fidl_path = string_replace(fidl_name, ".", "/")

   # Collect the dependencies on other FIDL libraries, and canonicalize them.
   fidl_library_deps = []
   if (defined(invoker.public_deps)) {
     foreach(label, invoker.public_deps) {
       assert(get_label_info(label, "toolchain") == current_toolchain,
              "fidl_library() `deps` must be fidl_library() target labels")
       fidl_library_deps += [ get_label_info(label, "label_no_toolchain") ]
     }
   }

   files_rspfile_target = "_fidl_library.files.$fidl_target.rsp"
   fidl_gen_dir =
       get_label_info(":$fidl_target($default_toolchain)", "target_gen_dir")
   files_rspfile = "$fidl_gen_dir/$fidl_target.rsp"

   gen_target = "_fidl_library.generate.$fidl_target"

   # This is the label to use in deps.
   files_rspfile_label = ":$files_rspfile_target($default_toolchain)"
   gen_target_label = ":$gen_target($default_toolchain)"

   gens = []
   foreach(gen, targets_gen_fidlc) {
     gen_dir = "$fidl_gen_dir/$fidl_target.${gen.name}"
     gen_outputs = []
     gen_args = []
     foreach(file, gen.files) {
       gen_args += [ file.switch ]
       if (defined(file.path)) {
         file = file.path
       } else {
         file = "${file.path_prefix}${fidl_path}${file.path_suffix}"
       }
       gen_outputs += [ "$gen_dir/$file" ]
       gen_args += [ rebase_path("$gen_dir/$file", root_build_dir) ]
     }
     gens += [
       {
         name = gen.name
         outputs = gen_outputs
         args = gen_args
       },
     ]
   }

   if (current_toolchain == default_toolchain) {
     # This just groups the dependencies together with the metadata listing
     # the input files.
     group(fidl_target) {
       forward_variables_from(invoker,
                              [
                                "deps",
                                "public_deps",
                                "visibility",
                                "testonly",
                              ])
       if (defined(visibility)) {
         visibility += [ ":$files_rspfile_target" ]
       }

       if (defined(invoker.sdk) && invoker.sdk) {
         assert(
             !defined(deps),
             "Public fidl_library(\"$fidl_target\") can only have public_deps")
         if (false) {
           # TODO(BLD-353): Implement this GN feature: require that all the
           # immediate deps have assert_metadata={sdk=...} too.
           assert_metadata = {
             sdk = []
             if (defined(public_deps)) {
               sdk += public_deps
             }
           }
         }
       }

       metadata = {
         # These inputs are needed both here and in every dependent library.
         # Each --files switch introduces a group of source files that make
         # up a single FIDL library (all have identical `library ...;` lines).
         fidl_rspfile =
             [ "--files" ] + rebase_path(invoker.sources, root_build_dir)

         if (defined(invoker.sdk) && invoker.sdk) {
           # TODO(BLD-353): Assert that every dep also has sdk set.
           sdk = [ true ]
         }
       }
     }

     # Produce a metadata response file from all the fidl_rspfile lists.
     # fidlc() uses this file.
     generated_file(files_rspfile_target) {
       forward_variables_from(invoker, [ "testonly" ])
       deps = [ ":$fidl_target" ]
       outputs = [ files_rspfile ]
       output_conversion = "list lines"
       data_keys = [ "fidl_rspfile" ]
     }

     fidlc(gen_target) {
       visibility = [ ":*" ]
       forward_variables_from(invoker, [ "testonly" ])
       deps = [ ":$fidl_target" ]
       outputs = []
       args = []
       foreach(gen, gens) {
         outputs += gen.outputs
         args += gen.args
       }
     }
   } else {
     not_needed(invoker, "*")
   }

   # Subroutine used in the _fidl_gen_templates loop in fidl_library().
   # The inner template provides a local scope for the import so it
   # won't clobber the outer template scope.
   template("_fidl_gen_subtarget") {
     import(invoker.import)
     target(invoker.target, target_name) {
       forward_variables_from(invoker.args, "*")
     }
   }

   # Invoke each template.
   foreach(gen, targets_gen_templates) {
     # The target_name for the template is the main FIDL target name.
     # The template will define its targets using appropriate suffixes.
     _fidl_gen_subtarget(fidl_target) {
       import = gen.import
       target = gen.target
       args = {
         forward_variables_from(invoker,
                                [
                                  "visibility",
                                  "testonly",
                                ])

         # The bindings-library template can map these to corresponding
         # bindings-library targets.
         fidl_deps = fidl_library_deps

         # Provide these for convenience.  They're derived from target_name
         # but every generator will be doing it the same way.
         fidl_name = fidl_name
         fidl_path = fidl_path

         # If the template uses our main fidlc run, give it details about that.
         if (defined(gen.fidlc)) {
           fidlc_gen_dir = "$fidl_gen_dir/$fidl_target.${gen.fidlc}"
           fidlc_deps = [ gen_target_label ]
           foreach(gen_fidlc, gens) {
             if (gen.fidlc == gen_fidlc.name) {
               fidlc_outputs = gen_fidlc.outputs
             }
           }
         }
       }
     }
   }
 }
	# Copyright 2019 The Fuchsia 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("$zx/public/gn/fidl/fidlc.gni")

	# List of FIDL support modules. Each of these defines its own version of
	# $fidl_support_fidlc and $fidl_support_templates.
	#
	# $fidl_support_templates:
	# Type: list of scopes
	#
	# import
	# Required: Source-absolute path to the .gni file that defines $target.
	# Type: file
	#
	# target
	# Required: Name of a template to invoke, defined in the $import file.
	# Type: string
	#
	# fidlc
	# Optional: Name of an entry in $fidl_support_fidlc describing fidlc
	# outputs that this template requires.
	#
	# The $target template is invoked with the $target_name from fidl_library()
	# and these parameters:
	#
	# fidl_deps
	# Required: $public_deps list from fidl_library() after canonicalization.
	# Type: list(label_no_toolchain)
	#
	# fidl_name
	# Required: The FIDL library name (with dots).
	# Type: string
	#
	# fidl_path
	# Required: $fidl_name with each `.` replaced by a `/`.
	# Type: string
	#
	# fidl_gen_dir
	# Optional: If $fidlc was set, this is the directory in which those
	# fidlc outputs went. e.g. "$fidl_gen_dir/include" might be useful.
	# Type: file
	#
	# fidlc_outputs
	# Optional: If $fidlc was set, this is the list of output files generated
	# by fidlc for that entry in $fidl_support_fidlc.
	#
	# fidlc_deps
	# Optional: If $fidlc was set, this is the label to include in $deps
	# of something using $fidlc_outputs.
	#
	# visibility, testonly
	# Optional: Forwarded from fidl_library().
	#
	# $fidl_support_fidlc:
	# Type: list of scopes
	#
	# name
	# Required: Name for this collection of fidlc output
	# Type: string
	#
	# files
	# Required: A list of scopes describing outputs from fidlc.
	# Type: list of scopes
	# switch
	# Required: fidlc command-line switch preceding output file name.
	# Type: string
	# path
	# Optional: Required unless $path_prefix and $path_suffix are given.
	# The fidlc output file is "$fidl_gen_dir/$path".
	# Type: string
	# path_prefix, path_suffix
	# Optional: If one is specified, both must be and $path must not be.
	# The output file is "$fidl_gen_dir/$path_prefix$fidl_path$path_suffix".
	# Type: string
	#
	# All these kinds of output will be generated in one run of fidlc. Modules
	# should use the $fidl_support_fidlc list only for generation work that is
	# more or less free once you're running fidlc anyway. These output files
	# will be generated if any $fidl_support_fidlc output file from any
	# support module is needed in the build. For more costly generation steps
	# (or ones requiring more than a simple fidlc command-line switch), support
	# modules should use $fidl_support_templates.
	#
	# TODO(mcgrathr): Add more language generators. For language support from
	# a different petal, add a build argument to contribute to this list via
	# default_overrides.
	fidl_support = [
	"$zx/public/gn/fidl/c.gni",
	"$zx/public/gn/fidl/json.gni",
	"$zx/public/gn/fidl/llcpp.gni",
	"$zx/public/gn/fidl/tables.gni",
	]

	# Each support module defines $fidl_support_fidlc and
	# $fidl_support_templates lists in its .gni file.
	_fidl_generators = []
	foreach(module, fidl_support) {
	_fidl_generators += [
	{
	import(module)
	},
	]
	}

	# Collect all fidlc outputs from the support modules, and deduplicate.
	# Collect all the generation templates to invoke, and deduplicate. All
	# these templates will be invoked by fidl_library() to define their targets.
	_fidl_gen_fidlc = []
	_fidl_gen_templates = []
	foreach(gen, _fidl_generators) {
	if (defined(gen.fidl_support_fidlc)) {
	_fidl_gen_fidlc += gen.fidl_support_fidlc
	_fidl_gen_fidlc -= gen.fidl_support_fidlc
	_fidl_gen_fidlc += gen.fidl_support_fidlc
	}
	if (defined(gen.fidl_support_templates)) {
	_fidl_gen_templates += gen.fidl_support_templates
	_fidl_gen_templates -= gen.fidl_support_templates
	_fidl_gen_templates += gen.fidl_support_templates
	}
	}

	# Define a FIDL library and implicitly generate bindings targets.
	#
	# The $fidl_support global determines what targets this actually produces.
	#
	# Parameters
	#
	# sources
	# Required: List of `.fidl` source files. Note that if any file names
	# ending in `.test.fidl` are present, $testonly is automatically set
	# to true and cannot be explicitly set to false.
	# Type: list(file)
	#
	# deps
	# Optional: This is not the way to express dependencies on other FIDL
	# libraries. Use $public_deps for that. The only use for $deps is if
	# some of $sources are generated, to depend on the targets generating them.
	# Type: list(label)
	#
	# public_deps
	# Optional: Other fidl_library() targets this library depends on.
	# If `using foo;` appears in a $sources file, then the label of the
	# fidl_library() target should be listed here. This must list only
	# other fidl_library() targets and may not use a "(toolchain)" suffix.
	# Type: list(label_no_toolchain)
	#
	# sdk
	# Optional: This library is exported to the SDK.
	# Type: bool
	# Default: false
	#
	# testonly
	# Optional: Usual GN meaning: dependent targets must also set $testonly.
	# Type: bool
	# Default: true iff $sources includes "*.test.fidl" files
	#
	# fuzzers
	# Optional: Protocol/methods for which to generate LibFuzzer fuzz targets.
	# Example:
	# [
	# {
	# # Required:
	# protocol = "fully.qualified.FIDLProtocolName"
	# # Optional. Default: All methods in protocol.
	# methods = [ "MethodName1", "MethodName2", ... ]
	# },
	# ...
	# ]
	# Type: list({protocol, methods})
	#
	# targets
	# Optional: Subset of bindings types to generate for this library.
	# Each element is the name of a template from $fidl_support_templates.
	# If this is set, then $visibility must be very restricted, since any
	# public fidl_library() might be used via any and all language bindings.
	# Type: list(string)
	# Default: All $fidl_support_templates defined by $fidl_support modules.
	#
	template("fidl_library") {
	if (defined(invoker.fuzzers)) {
	not_needed(invoker, [ "fuzzers" ])
	}

	assert(defined(invoker.sources),
	"fidl_library(\"$target_name\") must set `sources`")

	foreach(file, invoker.sources) {
	assert(get_path_info(file, "extension") == "fidl",
	"fidl_library() sources should be `.fidl` files, not $file")
	file = get_path_info(file, "name")
	if (get_path_info(file, "extension") == "test") {
	assert(!defined(invoker.testonly) \|\| invoker.testonly,
	"fidl_library(\"$target_name\") is implicitly testonly since " +
	" it has `.test.fidl` sources; cannot use testonly=false!")
	invoker.testonly = true
	}
	}

	if (defined(invoker.targets)) {
	assert(defined(invoker.visibility),
	"must constrain visibility when constraining targets")

	# Select the subset of fidlc outputs the enabled targets require.
	targets_gen_templates = []
	fidlc_needed = []
	foreach(target, invoker.targets) {
	found = false
	foreach(gen, _fidl_gen_templates) {
	if (gen.target == target) {
	found = true
	targets_gen_templates += [ gen ]
	if (defined(gen.fidlc)) {
	fidlc_needed += [ gen.fidlc ]
	}
	}
	}
	assert(found, "fidl_library() doesn't generate $target()")
	}

	# Generate only those below.
	targets_gen_fidlc = []
	foreach(gen, _fidl_gen_fidlc) {
	if (fidlc_needed + [ gen.name ] - [ gen.name ] != fidlc_needed) {
	targets_gen_fidlc += [ gen ]
	}
	}
	} else {
	# Usual case: generate them all.
	targets_gen_templates = _fidl_gen_templates
	targets_gen_fidlc = _fidl_gen_fidlc
	}

	fidl_target = target_name

	# TODO(mcgrathr): temporary until everything is renamed with . names
	fidl_name = string_replace(fidl_target, "-", ".")
	fidl_path = string_replace(fidl_name, ".", "/")

	# Collect the dependencies on other FIDL libraries, and canonicalize them.
	fidl_library_deps = []
	if (defined(invoker.public_deps)) {
	foreach(label, invoker.public_deps) {
	assert(get_label_info(label, "toolchain") == current_toolchain,
	"fidl_library() `deps` must be fidl_library() target labels")
	fidl_library_deps += [ get_label_info(label, "label_no_toolchain") ]
	}
	}

	files_rspfile_target = "_fidl_library.files.$fidl_target.rsp"
	fidl_gen_dir =
	get_label_info(":$fidl_target($default_toolchain)", "target_gen_dir")
	files_rspfile = "$fidl_gen_dir/$fidl_target.rsp"

	gen_target = "_fidl_library.generate.$fidl_target"

	# This is the label to use in deps.
	files_rspfile_label = ":$files_rspfile_target($default_toolchain)"
	gen_target_label = ":$gen_target($default_toolchain)"

	gens = []
	foreach(gen, targets_gen_fidlc) {
	gen_dir = "$fidl_gen_dir/$fidl_target.${gen.name}"
	gen_outputs = []
	gen_args = []
	foreach(file, gen.files) {
	gen_args += [ file.switch ]
	if (defined(file.path)) {
	file = file.path
	} else {
	file = "${file.path_prefix}${fidl_path}${file.path_suffix}"
	}
	gen_outputs += [ "$gen_dir/$file" ]
	gen_args += [ rebase_path("$gen_dir/$file", root_build_dir) ]
	}
	gens += [
	{
	name = gen.name
	outputs = gen_outputs
	args = gen_args
	},
	]
	}

	if (current_toolchain == default_toolchain) {
	# This just groups the dependencies together with the metadata listing
	# the input files.
	group(fidl_target) {
	forward_variables_from(invoker,
	[
	"deps",
	"public_deps",
	"visibility",
	"testonly",
	])
	if (defined(visibility)) {
	visibility += [ ":$files_rspfile_target" ]
	}

	if (defined(invoker.sdk) && invoker.sdk) {
	assert(
	!defined(deps),
	"Public fidl_library(\"$fidl_target\") can only have public_deps")
	if (false) {
	# TODO(BLD-353): Implement this GN feature: require that all the
	# immediate deps have assert_metadata={sdk=...} too.
	assert_metadata = {
	sdk = []
	if (defined(public_deps)) {
	sdk += public_deps
	}
	}
	}
	}

	metadata = {
	# These inputs are needed both here and in every dependent library.
	# Each --files switch introduces a group of source files that make
	# up a single FIDL library (all have identical `library ...;` lines).
	fidl_rspfile =
	[ "--files" ] + rebase_path(invoker.sources, root_build_dir)

	if (defined(invoker.sdk) && invoker.sdk) {
	# TODO(BLD-353): Assert that every dep also has sdk set.
	sdk = [ true ]
	}
	}
	}

	# Produce a metadata response file from all the fidl_rspfile lists.
	# fidlc() uses this file.
	generated_file(files_rspfile_target) {
	forward_variables_from(invoker, [ "testonly" ])
	deps = [ ":$fidl_target" ]
	outputs = [ files_rspfile ]
	output_conversion = "list lines"
	data_keys = [ "fidl_rspfile" ]
	}

	fidlc(gen_target) {
	visibility = [ ":*" ]
	forward_variables_from(invoker, [ "testonly" ])
	deps = [ ":$fidl_target" ]
	outputs = []
	args = []
	foreach(gen, gens) {
	outputs += gen.outputs
	args += gen.args
	}
	}
	} else {
	not_needed(invoker, "*")
	}

	# Subroutine used in the _fidl_gen_templates loop in fidl_library().
	# The inner template provides a local scope for the import so it
	# won't clobber the outer template scope.
	template("_fidl_gen_subtarget") {
	import(invoker.import)
	target(invoker.target, target_name) {
	forward_variables_from(invoker.args, "*")
	}
	}

	# Invoke each template.
	foreach(gen, targets_gen_templates) {
	# The target_name for the template is the main FIDL target name.
	# The template will define its targets using appropriate suffixes.
	_fidl_gen_subtarget(fidl_target) {
	import = gen.import
	target = gen.target
	args = {
	forward_variables_from(invoker,
	[
	"visibility",
	"testonly",
	])

	# The bindings-library template can map these to corresponding
	# bindings-library targets.
	fidl_deps = fidl_library_deps

	# Provide these for convenience. They're derived from target_name
	# but every generator will be doing it the same way.
	fidl_name = fidl_name
	fidl_path = fidl_path

	# If the template uses our main fidlc run, give it details about that.
	if (defined(gen.fidlc)) {
	fidlc_gen_dir = "$fidl_gen_dir/$fidl_target.${gen.fidlc}"
	fidlc_deps = [ gen_target_label ]
	foreach(gen_fidlc, gens) {
	if (gen.fidlc == gen_fidlc.name) {
	fidlc_outputs = gen_fidlc.outputs
	}
	}
	}
	}
	}
	}
	}