tequilaOS/platform_build_blueprint
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Split "variant" terminology into "variant" and "variation"

Browse source 
"Variant" has been used to mean two slightly concepts in Blueprint.
The first and most obvious is a variant of a module, meaning a list
of all the ways that on version of a module differs from other
versions of the same modules, for example "arch:arm, link:static".
The other is for the specific way that a version of a module differs,
"arch:arm".

Rename all of uses of "variant" as the second meaning to "variation",
and update the documentation to clarify "variant" vs. "variation".
This modifies the build logic api to convert CreateVariants to
CreateVariations.

Change-Id: I789ef209ae6ddd39ec12e0c032f9f47f86698fe6
This commit is contained in:
Colin Cross 2015-03-13 16:02:36 -07:00
parent 65569e4375
commit f5e34b98ca
2 changed files with 75 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

82
context.go
View file

@ -125,9 +125,9 @@ type moduleInfo struct {
Deps []string
}
variantName string
variants variantMap
dependencyVariants variantMap
variantName string
variant variationMap
dependencyVariant variationMap
logicModule Module
group *moduleGroup
@ -150,15 +150,22 @@ type moduleInfo struct {
actionDefs localBuildActions
}
type Variant struct {
// A Variation is a way that a variant of a module differs from other variants of the same module.
// For example, two variants of the same module might have Variation{"arch","arm"} and
// Variation{"arch","arm64"}
type Variation struct {
// Mutator is the axis on which this variation applies, i.e. "arch" or "link"
Mutator string
Variant string
// Variation is the name of the variation on the axis, i.e. "arm" or "arm64" for arch, or
// "shared" or "static" for link.
Variation string
}
type variantMap map[string]string
// A variationMap stores a map of Mutator to Variation to specify a variant of a module.
type variationMap map[string]string
func (vm variantMap) clone() variantMap {
newVm := make(variantMap)
func (vm variationMap) clone() variationMap {
newVm := make(variationMap)
for k, v := range vm {
newVm[k] = v
}
@ -166,7 +173,7 @@ func (vm variantMap) clone() variantMap {
return newVm
}
func (vm variantMap) equal(other variantMap) bool {
func (vm variationMap) equal(other variationMap) bool {
return reflect.DeepEqual(vm, other)
}
@ -373,8 +380,7 @@ func (c *Context) RegisterBottomUpMutator(name string, mutator BottomUpMutator)
// order is unpredictable.
//
// In order for dependencies to be satisifed in a later pass, all dependencies
// of a module either must have an identical variant or must have a single
// variant.
// of a module either must have an identical variant or must have no variations.
//
// The mutator type names given here must be unique to all bottom up or early
// mutators in the Context.
@ -709,14 +715,14 @@ func (c *Context) processSubdirs(
return nil, nil
}
func (c *Context) createVariants(origModule *moduleInfo, mutatorName string,
variantNames []string) ([]*moduleInfo, []error) {
func (c *Context) createVariations(origModule *moduleInfo, mutatorName string,
variationNames []string) ([]*moduleInfo, []error) {
newModules := []*moduleInfo{}
var errs []error
for i, variantName := range variantNames {
for i, variationName := range variationNames {
typeName := origModule.typeName
factory, ok := c.moduleFactories[typeName]
if !ok {
@ -750,27 +756,27 @@ func (c *Context) createVariants(origModule *moduleInfo, mutatorName string,
}
}
newVariants := origModule.variants.clone()
newVariants[mutatorName] = variantName
newVariant := origModule.variant.clone()
newVariant[mutatorName] = variationName
m := *origModule
newModule := &m
newModule.directDeps = append([]*moduleInfo(nil), origModule.directDeps...)
newModule.logicModule = newLogicModule
newModule.variants = newVariants
newModule.dependencyVariants = origModule.dependencyVariants.clone()
newModule.variant = newVariant
newModule.dependencyVariant = origModule.dependencyVariant.clone()
newModule.moduleProperties = newProperties
if newModule.variantName == "" {
newModule.variantName = variantName
newModule.variantName = variationName
} else {
newModule.variantName += "_" + variantName
newModule.variantName += "_" + variationName
}
newModules = append(newModules, newModule)
c.moduleInfo[newModule.logicModule] = newModule
newErrs := c.convertDepsToVariant(newModule, mutatorName, variantName)
newErrs := c.convertDepsToVariation(newModule, mutatorName, variationName)
if len(newErrs) > 0 {
errs = append(errs, newErrs...)
}
@ -784,22 +790,22 @@ func (c *Context) createVariants(origModule *moduleInfo, mutatorName string,
return newModules, errs
}
func (c *Context) convertDepsToVariant(module *moduleInfo,
mutatorName, variantName string) (errs []error) {
func (c *Context) convertDepsToVariation(module *moduleInfo,
mutatorName, variationName string) (errs []error) {
for i, dep := range module.directDeps {
if dep.logicModule == nil {
var newDep *moduleInfo
for _, m := range dep.splitModules {
if m.variants[mutatorName] == variantName {
if m.variant[mutatorName] == variationName {
newDep = m
break
}
}
if newDep == nil {
errs = append(errs, &Error{
Err: fmt.Errorf("failed to find variant %q for module %q needed by %q",
variantName, dep.properties.Name, module.properties.Name),
Err: fmt.Errorf("failed to find variation %q for module %q needed by %q",
variationName, dep.properties.Name, module.properties.Name),
Pos: module.pos,
})
continue
@ -811,7 +817,7 @@ func (c *Context) convertDepsToVariant(module *moduleInfo,
return errs
}
func (c *Context) prettyPrintVariant(variant variantMap) string {
func (c *Context) prettyPrintVariant(variant variationMap) string {
names := make([]string, 0, len(variant))
for _, m := range c.variantMutatorNames {
if v, ok := variant[m]; ok {
@ -936,7 +942,7 @@ func (c *Context) ResolveDependencies(config interface{}) []error {
// DynamicDependerModule interface then this set consists of the union of those
// module names listed in its "deps" property, those returned by its
// DynamicDependencies method, and those added by calling AddDependencies or
// AddVariantDependencies on DynamicDependencyModuleContext. Otherwise it
// AddVariationDependencies on DynamicDependencyModuleContext. Otherwise it
// is simply those names listed in its "deps" property.
func (c *Context) moduleDeps(module *moduleInfo,
config interface{}) (errs []error) {
@ -1032,7 +1038,7 @@ func (c *Context) addDependency(module *moduleInfo, depName string) []error {
return nil
} else {
for _, m := range depInfo.modules {
if m.variants.equal(module.dependencyVariants) {
if m.variant.equal(module.dependencyVariant) {
module.directDeps = append(module.directDeps, m)
return nil
}
@ -1042,12 +1048,12 @@ func (c *Context) addDependency(module *moduleInfo, depName string) []error {
return []error{&Error{
Err: fmt.Errorf("dependency %q of %q missing variant %q",
depInfo.modules[0].properties.Name, module.properties.Name,
c.prettyPrintVariant(module.dependencyVariants)),
c.prettyPrintVariant(module.dependencyVariant)),
Pos: depsPos,
}}
}
func (c *Context) addVariantDependency(module *moduleInfo, variant []Variant,
func (c *Context) addVariationDependency(module *moduleInfo, variations []Variation,
depName string) []error {
depsPos := module.propertyPos["deps"]
@ -1064,16 +1070,16 @@ func (c *Context) addVariantDependency(module *moduleInfo, variant []Variant,
// We can't just append variant.Variant to module.dependencyVariants.variantName and
// compare the strings because the result won't be in mutator registration order.
// Create a new map instead, and then deep compare the maps.
newVariants := module.dependencyVariants.clone()
for _, v := range variant {
newVariants[v.Mutator] = v.Variant
newVariant := module.dependencyVariant.clone()
for _, v := range variations {
newVariant[v.Mutator] = v.Variation
}
for _, m := range depInfo.modules {
if newVariants.equal(m.variants) {
// AddVariantDependency allows adding a dependency on itself, but only if
if newVariant.equal(m.variant) {
// AddVariationDependency allows adding a dependency on itself, but only if
// that module is earlier in the module list than this one, since we always
// run the generator in order for the variants of a module
// run GenerateBuildActions in order for the variants of a module
if depInfo == module.group && beforeInModuleList(module, m, module.group.modules) {
return []error{&Error{
Err: fmt.Errorf("%q depends on later version of itself", depName),
@ -1088,7 +1094,7 @@ func (c *Context) addVariantDependency(module *moduleInfo, variant []Variant,
return []error{&Error{
Err: fmt.Errorf("dependency %q of %q missing variant %q",
depInfo.modules[0].properties.Name, module.properties.Name,
c.prettyPrintVariant(newVariants)),
c.prettyPrintVariant(newVariant)),
Pos: depsPos,
}}
}

56
module_ctx.go
View file

@ -119,7 +119,7 @@ type BaseModuleContext interface {
type DynamicDependerModuleContext interface {
BaseModuleContext
AddVariantDependencies([]Variant, ...string)
AddVariationDependencies([]Variation, ...string)
}
type ModuleContext interface {
@ -319,9 +319,15 @@ type dynamicDependerModuleContext struct {
module *moduleInfo
}
func (mctx *dynamicDependerModuleContext) AddVariantDependencies(variant []Variant, deps ...string) {
// AddVariationDependencies adds deps as dependencies of the current module, but uses the variations
// argument to select which variant of the dependency to use. A variant of the dependency must
// exist that matches the all of the non-local variations of the current module, plus the variations
// argument.
func (mctx *dynamicDependerModuleContext) AddVariationDependencies(variations []Variation,
deps ...string) {
for _, dep := range deps {
errs := mctx.context.addVariantDependency(mctx.module, variant, dep)
errs := mctx.context.addVariationDependency(mctx.module, variations, dep)
if len(errs) > 0 {
mctx.errs = append(mctx.errs, errs...)
}
@ -347,8 +353,8 @@ type baseMutatorContext interface {
type EarlyMutatorContext interface {
baseMutatorContext
CreateVariants(...string) []Module
CreateLocalVariants(...string) []Module
CreateVariations(...string) []Module
CreateLocalVariations(...string) []Module
}
type TopDownMutatorContext interface {
@ -364,12 +370,12 @@ type BottomUpMutatorContext interface {
baseMutatorContext
AddDependency(module Module, name string)
CreateVariants(...string) []Module
SetDependencyVariant(string)
CreateVariations(...string) []Module
SetDependencyVariation(string)
}
// A Mutator function is called for each Module, and can use
// MutatorContext.CreateSubVariants to split a Module into multiple Modules,
// MutatorContext.CreateVariations to split a Module into multiple Modules,
// modifying properties on the new modules to differentiate them. It is called
// after parsing all Blueprint files, but before generating any build rules,
// and is always called on dependencies before being called on the depending module.
@ -381,35 +387,35 @@ type TopDownMutator func(mctx TopDownMutatorContext)
type BottomUpMutator func(mctx BottomUpMutatorContext)
type EarlyMutator func(mctx EarlyMutatorContext)
// Split a module into mulitple variants, one for each name in the variantNames
// parameter. It returns a list of new modules in the same order as the variantNames
// Split a module into mulitple variants, one for each name in the variationNames
// parameter. It returns a list of new modules in the same order as the variationNames
// list.
//
// If any of the dependencies of the module being operated on were already split
// by calling CreateVariants with the same name, the dependency will automatically
// by calling CreateVariations with the same name, the dependency will automatically
// be updated to point the matching variant.
//
// If a module is split, and then a module depending on the first module is not split
// when the Mutator is later called on it, the dependency of the depending module will
// automatically be updated to point to the first variant.
func (mctx *mutatorContext) CreateVariants(variantNames ...string) []Module {
return mctx.createVariants(variantNames, false)
func (mctx *mutatorContext) CreateVariations(variationNames ...string) []Module {
return mctx.createVariations(variationNames, false)
}
// Split a module into mulitple variants, one for each name in the variantNames
// parameter. It returns a list of new modules in the same order as the variantNames
// list.
//
// Local variants do not affect automatic dependency resolution - dependencies added
// Local variations do not affect automatic dependency resolution - dependencies added
// to the split module via deps or DynamicDependerModule must exactly match a variant
// that contains all the non-local variants.
func (mctx *mutatorContext) CreateLocalVariants(variantNames ...string) []Module {
return mctx.createVariants(variantNames, true)
// that contains all the non-local variations.
func (mctx *mutatorContext) CreateLocalVariations(variationNames ...string) []Module {
return mctx.createVariations(variationNames, true)
}
func (mctx *mutatorContext) createVariants(variantNames []string, local bool) []Module {
func (mctx *mutatorContext) createVariations(variationNames []string, local bool) []Module {
ret := []Module{}
modules, errs := mctx.context.createVariants(mctx.module, mctx.name, variantNames)
modules, errs := mctx.context.createVariations(mctx.module, mctx.name, variationNames)
if len(errs) > 0 {
mctx.errs = append(mctx.errs, errs...)
}
@ -417,21 +423,21 @@ func (mctx *mutatorContext) createVariants(variantNames []string, local bool) []
for i, module := range modules {
ret = append(ret, module.logicModule)
if !local {
module.dependencyVariants[mctx.name] = variantNames[i]
module.dependencyVariant[mctx.name] = variationNames[i]
}
}
if len(ret) != len(variantNames) {
if len(ret) != len(variationNames) {
panic("oops!")
}
return ret
}
// Set all dangling dependencies on the current module to point to the variant
// Set all dangling dependencies on the current module to point to the variation
// with given name.
func (mctx *mutatorContext) SetDependencyVariant(variantName string) {
mctx.context.convertDepsToVariant(mctx.module, mctx.name, variantName)
func (mctx *mutatorContext) SetDependencyVariation(variationName string) {
mctx.context.convertDepsToVariation(mctx.module, mctx.name, variationName)
}
func (mctx *mutatorContext) Module() Module {
@ -439,7 +445,7 @@ func (mctx *mutatorContext) Module() Module {
}
// Add a dependency to the given module. The depender can be a specific variant
// of a module, but the dependee must be a module that only has a single variant.
// of a module, but the dependee must be a module that has no variations.
// Does not affect the ordering of the current mutator pass, but will be ordered
// correctly for all future mutator passes.
func (mctx *mutatorContext) AddDependency(module Module, depName string) {