core

type AliasProps struct {
	// Modules that this alias will cause to build
	Srcs []string
	AliasableProps
}

type AliasableProps struct {
	// Adds this module to an alias
	Add_to_alias []string
}

type AndroidMTEProps struct {
	Mte struct {
		Memtag_heap      *bool
		Diag_memtag_heap *bool
	}
}

type AndroidPGOProps struct {
	Pgo struct {
		Benchmarks         []string
		Profile_file       *string
		Enable_profile_use *bool
		Cflags             []string
	}
}

type AndroidProps struct {
	// Values to use on Android for LOCAL_MODULE_TAGS, defining which builds this module is built for
	Tags []string
}

type Archivable interface {
	flag.Consumer // Modules which are compilable need to support flags
	file.Consumer // Compilable objects must match the file consumer interface
	BackendConfigurationProvider
	// contains filtered or unexported methods
}

type BackendCommonLibraryInterface interface {
	flag.Consumer

	// Legacy functions which need a better interface
	IsForwardingSharedLibrary() bool
	IsRpathWanted() bool
	BackendConfigurationProvider
	// contains filtered or unexported methods
}

type BackendCommonSharedLibraryInterface interface {
	BackendCommonLibraryInterface
	// contains filtered or unexported methods
}

type BackendConfiguration interface {
	GetBuildWrapperAndDeps(blueprint.ModuleContext) (string, []string)
	GetMteProps(blueprint.ModuleContext) AndroidMTEProps
	IsHwAsanEnabled() bool
	// contains filtered or unexported methods
}

type BackendConfigurationProvider interface {
	GetBackendConfiguration(blueprint.ModuleContext) BackendConfiguration
}

type BobConfig struct {
	Generator  generatorBackend
	Properties config.Properties
}

type Build struct {
	CommonProps
	BuildProps
	Target TargetSpecific
	Host   TargetSpecific
	SplittableProps
}

type BuildMeta map[string]ModuleMeta

type BuildProps struct {
	// Alternate output name, used for the file name and Android rules
	Out *string
	// Flags exported for dependent modules
	Export_cflags []string
	// Flags used for C compilation
	Conlyflags []string
	// Flags used for C++ compilation
	Cxxflags []string
	// Flags used for assembly compilation
	Asflags []string
	// Flags used for linking
	Ldflags []string
	// Same as ldflags, but specified on static libraries and propagated to
	// the top-level build object.
	Export_ldflags []string
	// Shared library version
	Library_version string
	// Shared library version script
	Version_script *string

	// The list of shared lib modules that this library depends on.
	// These are propagated to the closest linking object when specified on static libraries.
	// shared_libs is an indication that this module is using a shared library, and
	// users of this module need to link against it.
	Shared_libs []string `bob:"first_overrides"`
	// The libraries mentioned here will be appended to shared_libs of the modules that use
	// this library (via static_libs, whole_static_libs or shared_libs).
	ExtraSharedLibs []string `blueprint:"mutated"`

	// The list of static lib modules that this library depends on
	// These are propagated to the closest linking object when specified on static libraries.
	// static_libs is an indication that this module is using a static library, and
	// users of this module need to link against it.
	Static_libs []string `bob:"first_overrides"`

	// This list of dependencies that exported cflags and exported include dirs
	// should be propagated 1-level higher
	Reexport_libs []string `bob:"first_overrides"`
	// Internal property for collecting libraries with reexported flags and include paths
	ResolvedReexportedLibs []string `blueprint:"mutated"`
	// Same as above except for generated header providers which are not target variant aware and hence cannot
	// re use the same tagging.
	ResolvedGeneratedHeaders []string `blueprint:"mutated"`

	ResolvedStaticLibs []string `blueprint:"mutated"`

	// The list of whole static libraries that this library depnds on
	// This will include all the objects in the library (as opposed to normal static linking)
	// If this is set for a static library, any shared library will also include objects
	// from dependent libraries
	Whole_static_libs []string `bob:"first_overrides"`

	// List of libraries to import headers from, but not link to
	Header_libs []string `bob:"first_overrides"`

	// List of libraries that users of the current library should import
	// headers from, but not link to
	Export_header_libs []string `bob:"first_overrides"`

	// Linker flags required to link to the necessary system libraries
	// These are propagated to the closest linking object when specified on static libraries.
	Ldlibs []string `bob:"first_overrides"`

	// The list of modules that generate extra headers for this module
	Generated_headers []string `bob:"first_overrides"`

	// The list of modules that generate extra headers for this module,
	// which should be made available to linking modules
	Export_generated_headers []string `bob:"first_overrides"`

	// The list of modules that generate extra source files for this module
	Generated_sources []string

	// The list of modules that generate output required by the build wrapper
	Generated_deps []string

	// Include local dirs to be exported into dependent.
	// The system variant will propagate includes using `-isystem`, but use `-I` for
	// current module.
	Export_local_include_dirs        []string `bob:"first_overrides"`
	Export_local_system_include_dirs []string `bob:"first_overrides"`

	// Include dirs (path relative to root) to be exported into dependent.
	// The system variant will propagate includes using `-isystem`, but use `-I` for
	// current module.
	Export_include_dirs        []string `bob:"first_overrides"`
	Export_system_include_dirs []string `bob:"first_overrides"`

	// Wrapper for all build commands (object file compilation *and* linking)
	Build_wrapper *string

	// Adds DT_RPATH symbol to binaries and shared libraries so that they can find
	// their dependencies at runtime.
	Add_lib_dirs_to_rpath *bool

	// This is a shared library that pulls in one or more shared
	// libraries to resolve symbols that the binary needs. This is
	// useful where a named library is the standard library to link
	// against, but the implementation may exist in another
	// library.
	//
	// Only valid on bob_shared_library.
	//
	// Currently we need to link with -Wl,--copy-dt-needed-entries.
	// This makes the binary depend on the implementation library, and
	// requires the BFD linker.
	Forwarding_shlib *bool

	StripProps
	AndroidPGOProps
	AndroidMTEProps

	Hwasan_enabled *bool

	TargetType toolchain.TgtType `blueprint:"mutated"`
}

type CommonProps struct {
	LegacySourceProps
	IncludeDirsProps
	InstallableProps
	EnableableProps
	AndroidProps
	AliasableProps

	// Flags used for C compilation
	Cflags []string
}

type Compilable interface {
	flag.Consumer // Modules which are compilable need to support flags
	flag.Provider // Required for AOSP backend to check for exported flags

	file.Consumer // Compilable objects must match the file consumer interface

	BackendConfigurationProvider
	// contains filtered or unexported methods
}

type EnableableProps struct {
	// Used to disable the generation of build rules. If this is set to false, no build rule will be generated.
	Enabled *bool
	// Whether it is built by default in a build with no targets requested.
	// Nothing to do with 'defaults'.
	Build_by_default *bool
	// Is this module depended on by a module which is built by default?
	// Used to prune unused modules from Android builds, where we can't
	// control exactly what gets built.
	Required bool `blueprint:"mutated"`
}

type ExternalLibProps struct {
	Export_cflags  []string
	Export_ldflags []string
	Ldlibs         []string
	Target         TargetSpecific
	Host           TargetSpecific
	SplittableProps
	TargetType toolchain.TgtType `blueprint:"mutated"`
}

type ExternalableProps struct {
	// Used to disable the generation of build rules. If this is set to false, no build rule will be generated.
	External *bool
}

type FactoryWithConfig func(*BobConfig) (blueprint.Module, []interface{})

type Featurable interface {
	FeaturableProperties() []interface{}
	Features() *Features
}

type Features struct {
	// 'BlueprintEmbed' is a special case in Blueprint which makes it interpret
	// a runtime-generated type as being embedded in its parent struct.
	BlueprintEmbed interface{}
}

type GenerateLibraryProps struct {
	// List of headers that are created (if any)
	Headers []string

	// Alternate output name, used for the file name and Android rules
	Out *string

	// List of implicit sources. Implicit sources are input files that do not get
	// mentioned on the command line, and are not specified in the explicit sources.
	Implicit_srcs []string

	// Implicit source files that should not be included. Use with care.
	Exclude_implicit_srcs []string
}

type GenerateProps struct {
	LegacySourceProps
	AliasableProps
	EnableableProps
	InstallableProps

	/* The command that is to be run for this source generation.
	 * Substitutions can be made in the command, by using $name_of_var. A list of substitutions that can be used:
	 * $gen_dir      - the path to the directory which belongs to this source generator
	 * $in           - the path to the sources - space-delimited
	 * $out          - the path to the targets - space-delimited
	 * $depfile      - the path to generated dependency file
	 * $args         - the value of "args" - space-delimited
	 * $tool         - the path to the tool
	 * $tool <label> - the path to the tool with name <label>
	 * $host_bin     - the path to the binary that is produced by the host_bin module
	 * $(dep)_out    - the outputs of the generated_dep `dep`
	 * $src_dir      - the path to the project source directory - this will be different than the build source directory
	 *                 for Android.
	 * $module_dir   - the path to the module directory */
	Cmd *string

	// A paths to the tool that are to be used in cmd. If $tool is in the command variable, then this will be replaced
	// with the path to this tool. ${tool} refers to the first tool in a list. To reference
	// other tool use index syntax ${tool <label>} (e.g. ${tool fixer.py} for `fixer.py` tool from list).
	Tools []string

	// Adds a dependency on a binary with `host_supported: true` which is used by this module.
	// The path can be referenced in cmd as ${host_bin}.
	Host_bin *string

	// Values to use on Android for LOCAL_MODULE_TAGS, defining which builds this module is built for
	// TODO: Hide this in Android-specific properties
	Tags []string

	// A list of other modules that this generator depends on. The dependencies can be used in the command through
	// $name_of_dependency_dir .
	Generated_deps []string

	// A list of other modules that this generator depends on. The dependencies will be add to the list of srcs
	Generated_sources []string

	// A list of args that will be spaceseparated and add to the cmd
	Args []string

	// Used to indicate that the console should be used.
	Console *bool

	// A list of source modules that this bob_generated_source will encapsulate.
	// When this module is used with generated_headers, the named modules' export_gen_include_dirs will be forwarded.
	// When this module is used with generated_sources, the named modules' outputs will be supplied as sources.
	Encapsulates []string

	// Additional include paths to add for modules that use generate_headers.
	// This will be defined relative to the module-specific build directory
	Export_gen_include_dirs []string

	// The defaults used to retrieve cflags
	Flag_defaults []string

	// The target type - must be either "host" or "target"
	Target toolchain.TgtType

	// If true, depfile name will be generated and can be used as ${depfile} reference in 'cmd'
	Depfile *bool

	// If set, Ninja will expand the string and write it to a file just
	// before executing the command. This can be used to e.g. contain ${in},
	// in cases where the command line length is a limiting factor.
	Rsp_content *string
}

type GenerateSourceProps struct {
	// The list of files that will be output.
	Out []string
	// List of implicit sources. Implicit sources are input files that do not get
	// mentioned on the command line, and are not specified in the explicit sources.
	Implicit_srcs []string
	// Implicit source files that should not be included. Use with care.
	Exclude_implicit_srcs []string

	ResolvedOut file.Paths `blueprint:"mutated"`
}

type GenruleProps struct {
	Out         []string
	ResolvedOut file.Paths `blueprint:"mutated"`
}

type GensrcsProps struct {
	Output_extension string
	ResolvedOut      file.Paths `blueprint:"mutated"`
}

type GlobProps struct {
	// Path patterns that are relative to the current module
	Srcs []string

	// Path patterns that are relative to the current module to exclude from `Srcs`
	Exclude []string

	// Omitted directories from the `Files` result
	Exclude_directories *bool // Currently no supported.

	// Error-out if the result `Files` is empty
	Allow_empty *bool

	// Found module sources
	Files file.Paths `blueprint:"mutated"`
}

type IncludeDirsProps struct {
	// The list of include dirs to use that is relative to the source directory
	Include_dirs []string `bob:"first_overrides"`

	// The list of include dirs to use that is relative to the build.bp file
	// These use relative instead of absolute paths
	Local_include_dirs []string `bob:"first_overrides"`
}

type IncludeProps struct {
	Includes []string
}

type InstallGroupProps struct {
	Install_path *string
}

type InstallableProps struct {
	// Module specifying an installation directory
	Install_group *string
	// Other modules which must be installed alongside this
	Install_deps []string
	// Path to install to, relative to the install_group's path
	Relative_install_path *string
	// Script used during post install
	Post_install_tool *string
	// Command to execute on file(s) after they are installed
	Post_install_cmd *string
	// Arguments to post install command
	Post_install_args []string
	// The path retrieved from the install group so we don't need to walk dependencies to get it
	InstallGroupPath *string `blueprint:"mutated"`
}

type KernelProps struct {
	// Linux kernel config options to emulate. These are passed to Kbuild in
	// the 'make' command-line, and set in the source code via EXTRA_CFLAGS
	Kbuild_options []string
	// Kernel modules which this module depends on
	Extra_symbols []string
	// Arguments to pass to kernel make invocation
	Make_args []string
	// Kernel directory location
	Kernel_dir *string
	// Compiler prefix for kernel build
	Kernel_cross_compile *string
	// Kernel target compiler
	Kernel_cc *string
	// Kernel host compiler
	Kernel_hostcc *string
	// Kernel linker
	Kernel_ld *string
	// Target triple when using clang as the compiler
	Kernel_clang_triple *string
}

type LegacySourceProps struct {
	// The list of source files. Wildcards can be used (but are suboptimal)
	Srcs []string
	// The list of source files that should not be included. Use with care.
	Exclude_srcs []string

	ResolvedSrcs file.Paths `blueprint:"mutated"` // Glob results.
}

type LegacySourcePropsInterface interface {
	file.Consumer
	file.Resolver
	// contains filtered or unexported methods
}

type ModuleAlias struct {
	module.ModuleBase
	Properties struct {
		AliasProps
		Features
	}
}

type ModuleBinary struct {
	ModuleLibrary
}

type ModuleDefaults struct {
	module.ModuleBase

	Properties struct {
		Features
		Build
		KernelProps
		TagableProps
		// The list of default properties that should prepended to all configuration
		Defaults []string
	}
}

type ModuleExternalLibrary struct {
	module.ModuleBase
	Properties struct {
		ExternalLibProps
		TagableProps
		Features
		EnableableProps
	}
}

type ModuleFilegroup struct {
	module.ModuleBase
	Properties struct {
		SourceProps
		TagableProps
		Features
		EnableableProps
	}
}

type ModuleGenerateCommon struct {
	module.ModuleBase
	Properties struct {
		GenerateProps
		Features
		FlagArgsBuild Build `blueprint:"mutated"`
	}
	// contains filtered or unexported fields
}

type ModuleGenerateSource struct {
	ModuleGenerateCommon
	Properties struct {
		GenerateSourceProps
	}
}

type ModuleGenrule struct {
	ModuleStrictGenerateCommon
	Properties struct {
		GenruleProps
	}
}

type ModuleGenruleInterface interface {
	file.Consumer
	file.Resolver

	Tagable
	// contains filtered or unexported methods
}

type ModuleGensrcs struct {
	ModuleStrictGenerateCommon
	Properties struct {
		GensrcsProps
	}
}

type ModuleGensrcsInterface interface {
	file.Consumer
	file.Resolver

	Tagable
	// contains filtered or unexported methods
}

type ModuleGlob struct {
	module.ModuleBase
	Properties struct {
		GlobProps
		TagableProps
	}
}

type ModuleInstallGroup struct {
	module.ModuleBase
	Properties struct {
		InstallGroupProps
		TagableProps
		Features
	}
}

type ModuleKernelObject struct {
	module.ModuleBase
	Properties struct {
		Features
		CommonProps
		KernelProps
		TagableProps
		Defaults []string
	}
}

type ModuleLibrary struct {
	module.ModuleBase

	Properties struct {
		Features
		TransitiveLibraryProps
		Build
		TagableProps
		ExternalableProps

		// The list of default properties that should prepended to all configuration
		Defaults []string

		VersionScriptModule *string `blueprint:"mutated"`
	}
}

type ModuleMeta struct {
	Srcs           []string `json:"srcs"`
	TransitiveDeps []string `json:"deps"`
}

type ModuleResource struct {
	module.ModuleBase
	Properties struct {
		ResourceProps
		Features
	}
}

type ModuleSharedLibrary struct {
	ModuleLibrary
	// contains filtered or unexported fields
}

type ModuleStaticLibrary struct {
	ModuleLibrary
}

type ModuleStrictBinary struct {
	ModuleStrictLibrary
}

type ModuleStrictGenerateCommon struct {
	module.ModuleBase
	Properties struct {
		EnableableProps
		TagableProps
		Features
		StrictGenerateProps
	}
	// contains filtered or unexported fields
}

type ModuleStrictLibrary struct {
	module.ModuleBase
	Properties struct {
		StrictLibraryProps
		IncludeProps
		TransitiveLibraryProps
		TagableProps

		Features
		EnableableProps
		SplittableProps
		InstallableProps

		TargetType toolchain.TgtType `blueprint:"mutated"`
		Target     TargetSpecific
		Host       TargetSpecific

		ToolchainFlagsProps
	}
}

type ModuleTest struct {
	ModuleStrictBinary
}

type ModuleToolchain struct {
	module.ModuleBase

	SplittableProps

	Properties struct {
		ModuleToolchainProps
		StripProps
		TagableProps

		Target     TargetSpecific
		Host       TargetSpecific
		TargetType toolchain.TgtType `blueprint:"mutated"`

		Features
	}
}

type ModuleToolchainInterface interface {
	Featurable

	flag.Provider
	Tagable
	// contains filtered or unexported methods
}

type ModuleToolchainProps struct {
	// Flags that will be used for C and C++ compiles.
	Cflags []string

	// Flags that will be used for C compiles.
	Conlyflags []string

	// Flags that will be used for C++ compiles.
	Cppflags []string

	// Flags that will be used for .S compiles.
	Asflags []string

	// Flags that will be used for all link steps.
	Ldflags []string

	// Wrapper for all build commands (object file compilation *and* linking)
	Build_wrapper *string

	AndroidMTEProps

	Hwasan_enabled *bool
}

type ModuleTransformSource struct {
	ModuleGenerateCommon
	Properties struct {
		TransformSourceProps
	}
}

type PropertyProvider interface {
	GetProperties() interface{}
}

type ResourceProps struct {
	LegacySourceProps
	AliasableProps
	InstallableProps
	EnableableProps
	AndroidProps
	TagableProps
}

type SharedLibraryExporter interface {
	flag.Provider // Eventually the below functions will be removed
	// contains filtered or unexported methods
}

type SourceProps struct {
	// The list of source files and target names for globs/filegroups
	Srcs []string

	ResolvedSrcs file.Paths `blueprint:"mutated"` // Glob results.
}

type SplittableProps struct {
	Host_supported   *bool
	Target_supported *bool
}

type StrictGenerateCommonInterface interface {
	file.Consumer
	file.Resolver
	Tagable
	// contains filtered or unexported methods
}

type StrictGenerateProps struct {
	// See https://ci.android.com/builds/submitted/8928481/linux/latest/view/soong_build.html
	Name                string
	Srcs                []string // TODO: This module should probalby make use of LegacySourceProps
	Exclude_srcs        []string
	Cmd                 *string
	Export_include_dirs []string
	Tool_files          []string
	Tools               []string

	ResolvedSrcs file.Paths `blueprint:"mutated"` // Glob results.
}

type StrictGeneratePropsInterface interface {
	file.Consumer
	file.Resolver
	// contains filtered or unexported methods
}

type StrictGenerator interface {
	// contains filtered or unexported methods
}

type StrictLibraryProps struct {
	SourceProps
	Hdrs []string
	// TODO: Header inclusion
	//Textual_hdrs           []string
	//Includes               []string
	//Include_prefixes       []string
	//Strip_include_prefixes []string
	Alwayslink *bool
	Linkstatic *bool

	Linkopts []string

	Local_defines []string
	Copts         []string
	Deps          []string

	// TODO: unused but needed for the output interface, no easy way to hide it
	Out *string
}

type StripCapable interface {
	GetStripable(blueprint.ModuleContext) stripable
}

type StripProps struct {
	// When set, strip symbols and debug information from libraries
	// and binaries. This is a separate stage that occurs after
	// linking and before post install.
	//
	// On Android, its infrastructure is used to do the stripping. If
	// not enabled, follow Android's default behaviour.
	Strip *bool

	// Module specifying a directory for debug information
	Debug_info *string

	// The path retrieved from debug install group so we don't need to
	// walk dependencies to get it
	Debug_path *string `blueprint:"mutated"`
}

type Tagable interface {
	blueprint.Module

	// Returns true if any of the tags match the expression
	HasTagRegex(*regexp.Regexp) bool

	// Return true if any of the tags match query
	HasTag(string) bool

	// Returns all tags matching regex
	GetTagsRegex(*regexp.Regexp) []string

	// Returns all tags
	GetTags() []string
}

type TagableProps struct {
	Tags []string
}

type TargetSpecific struct {
	Features

	// 'BlueprintEmbed' is a special case in Blueprint which makes it interpret
	// a runtime-generated type as being embedded in its parent struct.
	BlueprintEmbed interface{}
}

type ToolchainFlagsProps struct {
	// `ModuleToolchain` module.
	Toolchain *string
}

type TransformSourceProps struct {
	// The regular expression that is used to transform the source path to the target path.
	Out struct {
		// Regular expression to capture groups from srcs
		Match string
		// Names of outputs, which can use capture groups from match
		Replace []string
		// List of implicit sources. Implicit sources are input files that do not get mentioned on the command line,
		// and are not specified in the explicit sources.
		Implicit_srcs []string
	}

	// Stores the files generated
	ResolvedOut file.Paths `blueprint:"mutated"`
}

type TransitiveLibraryProps struct {
	Defines []string
}