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

Combine variant fields into variant struct

Browse source 
Combine variant, variations and dependencyVariations into a single
struct.

Test: blueprint tests
Change-Id: I76811bb2bdf76f1b4cffc6a7b9bc7362ecb5f7b9
This commit is contained in:
Colin Cross 2020-08-13 12:07:30 -07:00
parent 576b0fd577
commit edc41769fe
4 changed files with 90 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

134
context.go
View file

@ -159,10 +159,8 @@ type localBuildActions struct {
} }
type moduleAlias struct { type moduleAlias struct {
variantName string variant variant
variant variationMap target *moduleInfo
dependencyVariant variationMap
target *moduleInfo
} }
type moduleGroup struct { type moduleGroup struct {
@ -184,9 +182,7 @@ type moduleInfo struct {
propertyPos map[string]scanner.Position propertyPos map[string]scanner.Position
createdBy *moduleInfo createdBy *moduleInfo
variantName string variant variant
variant variationMap
dependencyVariant variationMap
logicModule Module logicModule Module
group *moduleGroup group *moduleGroup
@ -212,6 +208,12 @@ type moduleInfo struct {
actionDefs localBuildActions actionDefs localBuildActions
} }
type variant struct {
name string
variations variationMap
dependencyVariations variationMap
}
type depInfo struct { type depInfo struct {
module *moduleInfo module *moduleInfo
tag DependencyTag tag DependencyTag
@ -232,8 +234,8 @@ func (module *moduleInfo) Name() string {
func (module *moduleInfo) String() string { func (module *moduleInfo) String() string {
s := fmt.Sprintf("module %q", module.Name()) s := fmt.Sprintf("module %q", module.Name())
if module.variantName != "" { if module.variant.name != "" {
s += fmt.Sprintf(" variant %q", module.variantName) s += fmt.Sprintf(" variant %q", module.variant.name)
} }
if module.createdBy != nil { if module.createdBy != nil {
s += fmt.Sprintf(" (created by %s)", module.createdBy) s += fmt.Sprintf(" (created by %s)", module.createdBy)
@ -1224,8 +1226,37 @@ func (c *Context) cloneLogicModule(origModule *moduleInfo) (Module, []interface{
return newLogicModule, newProperties return newLogicModule, newProperties
} }
func newVariant(module *moduleInfo, mutatorName string, variationName string,
local bool) variant {
newVariantName := module.variant.name
if variationName != "" {
if newVariantName == "" {
newVariantName = variationName
} else {
newVariantName += "_" + variationName
}
}
newVariations := module.variant.variations.clone()
if newVariations == nil {
newVariations = make(variationMap)
}
newVariations[mutatorName] = variationName
newDependencyVariations := module.variant.dependencyVariations.clone()
if !local {
if newDependencyVariations == nil {
newDependencyVariations = make(variationMap)
}
newDependencyVariations[mutatorName] = variationName
}
return variant{newVariantName, newVariations, newDependencyVariations}
}
func (c *Context) createVariations(origModule *moduleInfo, mutatorName string, func (c *Context) createVariations(origModule *moduleInfo, mutatorName string,
defaultVariationName *string, variationNames []string) ([]*moduleInfo, []error) { defaultVariationName *string, variationNames []string, local bool) ([]*moduleInfo, []error) {
if len(variationNames) == 0 { if len(variationNames) == 0 {
panic(fmt.Errorf("mutator %q passed zero-length variation list for module %q", panic(fmt.Errorf("mutator %q passed zero-length variation list for module %q",
@ -1249,28 +1280,13 @@ func (c *Context) createVariations(origModule *moduleInfo, mutatorName string,
newLogicModule, newProperties = c.cloneLogicModule(origModule) newLogicModule, newProperties = c.cloneLogicModule(origModule)
} }
newVariant := origModule.variant.clone()
if newVariant == nil {
newVariant = make(variationMap)
}
newVariant[mutatorName] = variationName
m := *origModule m := *origModule
newModule := &m newModule := &m
newModule.directDeps = append([]depInfo{}, origModule.directDeps...) newModule.directDeps = append([]depInfo{}, origModule.directDeps...)
newModule.logicModule = newLogicModule newModule.logicModule = newLogicModule
newModule.variant = newVariant newModule.variant = newVariant(origModule, mutatorName, variationName, local)
newModule.dependencyVariant = origModule.dependencyVariant.clone()
newModule.properties = newProperties newModule.properties = newProperties
if variationName != "" {
if newModule.variantName == "" {
newModule.variantName = variationName
} else {
newModule.variantName += "_" + variationName
}
}
newModules = append(newModules, newModule) newModules = append(newModules, newModule)
newErrs := c.convertDepsToVariation(newModule, mutatorName, variationName, defaultVariationName) newErrs := c.convertDepsToVariation(newModule, mutatorName, variationName, defaultVariationName)
@ -1296,7 +1312,7 @@ func (c *Context) convertDepsToVariation(module *moduleInfo,
if dep.module.logicModule == nil { if dep.module.logicModule == nil {
var newDep *moduleInfo var newDep *moduleInfo
for _, m := range dep.module.splitModules { for _, m := range dep.module.splitModules {
if m.variant[mutatorName] == variationName { if m.variant.variations[mutatorName] == variationName {
newDep = m newDep = m
break break
} }
@ -1304,7 +1320,7 @@ func (c *Context) convertDepsToVariation(module *moduleInfo,
if newDep == nil && defaultVariationName != nil { if newDep == nil && defaultVariationName != nil {
// give it a second chance; match with defaultVariationName // give it a second chance; match with defaultVariationName
for _, m := range dep.module.splitModules { for _, m := range dep.module.splitModules {
if m.variant[mutatorName] == *defaultVariationName { if m.variant.variations[mutatorName] == *defaultVariationName {
newDep = m newDep = m
break break
} }
@ -1325,10 +1341,10 @@ func (c *Context) convertDepsToVariation(module *moduleInfo,
return errs return errs
} }
func (c *Context) prettyPrintVariant(variant variationMap) string { func (c *Context) prettyPrintVariant(variations variationMap) string {
names := make([]string, 0, len(variant)) names := make([]string, 0, len(variations))
for _, m := range c.variantMutatorNames { for _, m := range c.variantMutatorNames {
if v, ok := variant[m]; ok { if v, ok := variations[m]; ok {
names = append(names, m+":"+v) names = append(names, m+":"+v)
} }
} }
@ -1339,11 +1355,11 @@ func (c *Context) prettyPrintVariant(variant variationMap) string {
func (c *Context) prettyPrintGroupVariants(group *moduleGroup) string { func (c *Context) prettyPrintGroupVariants(group *moduleGroup) string {
var variants []string var variants []string
for _, mod := range group.modules { for _, mod := range group.modules {
variants = append(variants, c.prettyPrintVariant(mod.variant)) variants = append(variants, c.prettyPrintVariant(mod.variant.variations))
} }
for _, mod := range group.aliases { for _, mod := range group.aliases {
variants = append(variants, c.prettyPrintVariant(mod.variant)+ variants = append(variants, c.prettyPrintVariant(mod.variant.variations)+
"(alias to "+c.prettyPrintVariant(mod.target.variant)+")") "(alias to "+c.prettyPrintVariant(mod.target.variant.variations)+")")
} }
sort.Strings(variants) sort.Strings(variants)
return strings.Join(variants, "\n ") return strings.Join(variants, "\n ")
@ -1518,18 +1534,18 @@ func (c *Context) findMatchingVariant(module *moduleInfo, possible *moduleGroup,
if !reverse { if !reverse {
// For forward dependency, ignore local variants by matching against // For forward dependency, ignore local variants by matching against
// dependencyVariant which doesn't have the local variants // dependencyVariant which doesn't have the local variants
variantToMatch = module.dependencyVariant variantToMatch = module.variant.dependencyVariations
} else { } else {
// For reverse dependency, use all the variants // For reverse dependency, use all the variants
variantToMatch = module.variant variantToMatch = module.variant.variations
} }
for _, m := range possible.modules { for _, m := range possible.modules {
if m.variant.equal(variantToMatch) { if m.variant.variations.equal(variantToMatch) {
return m return m
} }
} }
for _, m := range possible.aliases { for _, m := range possible.aliases {
if m.variant.equal(variantToMatch) { if m.variant.variations.equal(variantToMatch) {
return m.target return m.target
} }
} }
@ -1563,13 +1579,13 @@ func (c *Context) addDependency(module *moduleInfo, tag DependencyTag, depName s
if c.allowMissingDependencies { if c.allowMissingDependencies {
// Allow missing variants. // Allow missing variants.
return c.discoveredMissingDependencies(module, depName+c.prettyPrintVariant(module.dependencyVariant)) return c.discoveredMissingDependencies(module, depName+c.prettyPrintVariant(module.variant.dependencyVariations))
} }
return []error{&BlueprintError{ return []error{&BlueprintError{
Err: fmt.Errorf("dependency %q of %q missing variant:\n %s\navailable variants:\n %s", Err: fmt.Errorf("dependency %q of %q missing variant:\n %s\navailable variants:\n %s",
depName, module.Name(), depName, module.Name(),
c.prettyPrintVariant(module.dependencyVariant), c.prettyPrintVariant(module.variant.dependencyVariations),
c.prettyPrintGroupVariants(possibleDeps)), c.prettyPrintGroupVariants(possibleDeps)),
Pos: module.pos, Pos: module.pos,
}} }}
@ -1598,20 +1614,20 @@ func (c *Context) findReverseDependency(module *moduleInfo, destName string) (*m
if c.allowMissingDependencies { if c.allowMissingDependencies {
// Allow missing variants. // Allow missing variants.
return module, c.discoveredMissingDependencies(module, destName+c.prettyPrintVariant(module.dependencyVariant)) return module, c.discoveredMissingDependencies(module, destName+c.prettyPrintVariant(module.variant.dependencyVariations))
} }
return nil, []error{&BlueprintError{ return nil, []error{&BlueprintError{
Err: fmt.Errorf("reverse dependency %q of %q missing variant:\n %s\navailable variants:\n %s", Err: fmt.Errorf("reverse dependency %q of %q missing variant:\n %s\navailable variants:\n %s",
destName, module.Name(), destName, module.Name(),
c.prettyPrintVariant(module.dependencyVariant), c.prettyPrintVariant(module.variant.dependencyVariations),
c.prettyPrintGroupVariants(possibleDeps)), c.prettyPrintGroupVariants(possibleDeps)),
Pos: module.pos, Pos: module.pos,
}} }}
} }
func (c *Context) findVariant(module *moduleInfo, possibleDeps *moduleGroup, variations []Variation, far bool, reverse bool) (*moduleInfo, variationMap) { func (c *Context) findVariant(module *moduleInfo, possibleDeps *moduleGroup, variations []Variation, far bool, reverse bool) (*moduleInfo, variationMap) {
// We can't just append variant.Variant to module.dependencyVariants.variantName and // We can't just append variant.Variant to module.dependencyVariant.variantName and
// compare the strings because the result won't be in mutator registration order. // compare the strings because the result won't be in mutator registration order.
// Create a new map instead, and then deep compare the maps. // Create a new map instead, and then deep compare the maps.
var newVariant variationMap var newVariant variationMap
@ -1619,10 +1635,10 @@ func (c *Context) findVariant(module *moduleInfo, possibleDeps *moduleGroup, var
if !reverse { if !reverse {
// For forward dependency, ignore local variants by matching against // For forward dependency, ignore local variants by matching against
// dependencyVariant which doesn't have the local variants // dependencyVariant which doesn't have the local variants
newVariant = module.dependencyVariant.clone() newVariant = module.variant.dependencyVariations.clone()
} else { } else {
// For reverse dependency, use all the variants // For reverse dependency, use all the variants
newVariant = module.variant.clone() newVariant = module.variant.variations.clone()
} }
} }
for _, v := range variations { for _, v := range variations {
@ -1642,7 +1658,7 @@ func (c *Context) findVariant(module *moduleInfo, possibleDeps *moduleGroup, var
var foundDep *moduleInfo var foundDep *moduleInfo
for _, m := range possibleDeps.modules { for _, m := range possibleDeps.modules {
if check(m.variant) { if check(m.variant.variations) {
foundDep = m foundDep = m
break break
} }
@ -1650,7 +1666,7 @@ func (c *Context) findVariant(module *moduleInfo, possibleDeps *moduleGroup, var
if foundDep == nil { if foundDep == nil {
for _, m := range possibleDeps.aliases { for _, m := range possibleDeps.aliases {
if check(m.variant) { if check(m.variant.variations) {
foundDep = m.target foundDep = m.target
break break
} }
@ -2301,10 +2317,8 @@ func (c *Context) runMutator(config interface{}, mutator *mutatorInfo,
// Create any new aliases. // Create any new aliases.
if module.aliasTarget != nil { if module.aliasTarget != nil {
group.aliases = append(group.aliases, &moduleAlias{ group.aliases = append(group.aliases, &moduleAlias{
variantName: module.variantName, variant: module.variant,
variant: module.variant, target: module.aliasTarget,
dependencyVariant: module.dependencyVariant,
target: module.aliasTarget,
}) })
} }
@ -2461,7 +2475,7 @@ func (c *Context) generateModuleBuildActions(config interface{},
uniqueName := c.nameInterface.UniqueName(newNamespaceContext(module), module.group.name) uniqueName := c.nameInterface.UniqueName(newNamespaceContext(module), module.group.name)
sanitizedName := toNinjaName(uniqueName) sanitizedName := toNinjaName(uniqueName)
prefix := moduleNamespacePrefix(sanitizedName + "_" + module.variantName) prefix := moduleNamespacePrefix(sanitizedName + "_" + module.variant.name)
// The parent scope of the moduleContext's local scope gets overridden to be that of the // The parent scope of the moduleContext's local scope gets overridden to be that of the
// calling Go package on a per-call basis. Since the initial parent scope doesn't matter we // calling Go package on a per-call basis. Since the initial parent scope doesn't matter we
@ -2675,13 +2689,13 @@ func (c *Context) moduleMatchingVariant(module *moduleInfo, name string) *module
} }
for _, m := range group.modules { for _, m := range group.modules {
if module.variantName == m.variantName { if module.variant.name == m.variant.name {
return m return m
} }
} }
for _, m := range group.aliases { for _, m := range group.aliases {
if module.variantName == m.variantName { if module.variant.name == m.variant.name {
return m.target return m.target
} }
} }
@ -3053,7 +3067,7 @@ func (c *Context) ModuleDir(logicModule Module) string {
func (c *Context) ModuleSubDir(logicModule Module) string { func (c *Context) ModuleSubDir(logicModule Module) string {
module := c.moduleInfo[logicModule] module := c.moduleInfo[logicModule]
return module.variantName return module.variant.name
} }
func (c *Context) ModuleType(logicModule Module) string { func (c *Context) ModuleType(logicModule Module) string {
@ -3499,8 +3513,8 @@ func (s depSorter) Less(i, j int) bool {
iName := s[i].module.Name() iName := s[i].module.Name()
jName := s[j].module.Name() jName := s[j].module.Name()
if iName == jName { if iName == jName {
iName = s[i].module.variantName iName = s[i].module.variant.name
jName = s[j].module.variantName jName = s[j].module.variant.name
} }
return iName < jName return iName < jName
} }
@ -3524,8 +3538,8 @@ func (s moduleSorter) Less(i, j int) bool {
iName := s.nameInterface.UniqueName(newNamespaceContext(iMod), iMod.group.name) iName := s.nameInterface.UniqueName(newNamespaceContext(iMod), iMod.group.name)
jName := s.nameInterface.UniqueName(newNamespaceContext(jMod), jMod.group.name) jName := s.nameInterface.UniqueName(newNamespaceContext(jMod), jMod.group.name)
if iName == jName { if iName == jName {
iName = s.modules[i].variantName iName = s.modules[i].variant.name
jName = s.modules[j].variantName jName = s.modules[j].variant.name
} }
if iName == jName { if iName == jName {
@ -3576,7 +3590,7 @@ func (c *Context) writeAllModuleActions(nw *ninjaWriter) error {
"typeName": module.typeName, "typeName": module.typeName,
"goFactory": factoryName, "goFactory": factoryName,
"pos": relPos, "pos": relPos,
"variant": module.variantName, "variant": module.variant.name,
} }
err = headerTemplate.Execute(buf, infoMap) err = headerTemplate.Execute(buf, infoMap)
if err != nil { if err != nil {

20
module_ctx.go
View file

@ -464,7 +464,7 @@ func (m *baseModuleContext) OtherModuleDir(logicModule Module) string {
func (m *baseModuleContext) OtherModuleSubDir(logicModule Module) string { func (m *baseModuleContext) OtherModuleSubDir(logicModule Module) string {
module := m.context.moduleInfo[logicModule] module := m.context.moduleInfo[logicModule]
return module.variantName return module.variant.name
} }
func (m *baseModuleContext) OtherModuleType(logicModule Module) string { func (m *baseModuleContext) OtherModuleType(logicModule Module) string {
@ -655,7 +655,7 @@ func (m *baseModuleContext) ModuleFactories() map[string]ModuleFactory {
} }
func (m *moduleContext) ModuleSubDir() string { func (m *moduleContext) ModuleSubDir() string {
return m.module.variantName return m.module.variant.name
} }
func (m *moduleContext) Variable(pctx PackageContext, name, value string) { func (m *moduleContext) Variable(pctx PackageContext, name, value string) {
@ -901,19 +901,13 @@ func (mctx *mutatorContext) CreateLocalVariations(variationNames ...string) []Mo
func (mctx *mutatorContext) createVariations(variationNames []string, local bool) []Module { func (mctx *mutatorContext) createVariations(variationNames []string, local bool) []Module {
ret := []Module{} ret := []Module{}
modules, errs := mctx.context.createVariations(mctx.module, mctx.name, mctx.defaultVariation, variationNames) modules, errs := mctx.context.createVariations(mctx.module, mctx.name, mctx.defaultVariation, variationNames, local)
if len(errs) > 0 { if len(errs) > 0 {
mctx.errs = append(mctx.errs, errs...) mctx.errs = append(mctx.errs, errs...)
} }
for i, module := range modules { for _, module := range modules {
ret = append(ret, module.logicModule) ret = append(ret, module.logicModule)
if !local {
if module.dependencyVariant == nil {
module.dependencyVariant = make(variationMap)
}
module.dependencyVariant[mctx.name] = variationNames[i]
}
} }
if mctx.newVariations != nil { if mctx.newVariations != nil {
@ -934,7 +928,7 @@ func (mctx *mutatorContext) AliasVariation(variationName string) {
} }
for _, variant := range mctx.newVariations { for _, variant := range mctx.newVariations {
if variant.variant[mctx.name] == variationName { if variant.variant.variations[mctx.name] == variationName {
mctx.module.aliasTarget = variant mctx.module.aliasTarget = variant
return return
} }
@ -942,7 +936,7 @@ func (mctx *mutatorContext) AliasVariation(variationName string) {
var foundVariations []string var foundVariations []string
for _, variant := range mctx.newVariations { for _, variant := range mctx.newVariations {
foundVariations = append(foundVariations, variant.variant[mctx.name]) foundVariations = append(foundVariations, variant.variant.variations[mctx.name])
} }
panic(fmt.Errorf("no %q variation in module variations %q", variationName, foundVariations)) panic(fmt.Errorf("no %q variation in module variations %q", variationName, foundVariations))
} }
@ -1023,7 +1017,7 @@ func (mctx *mutatorContext) ReplaceDependenciesIf(name string, predicate Replace
if target == nil { if target == nil {
panic(fmt.Errorf("ReplaceDependencies could not find identical variant %q for module %q", panic(fmt.Errorf("ReplaceDependencies could not find identical variant %q for module %q",
mctx.module.variantName, name)) mctx.module.variant.name, name))
} }
mctx.replace = append(mctx.replace, replace{target, mctx.module, predicate}) mctx.replace = append(mctx.replace, replace{target, mctx.module, predicate})

6
module_ctx_test.go
View file

@ -123,7 +123,7 @@ func TestAliases(t *testing.T) {
foo := ctx.moduleGroupFromName("foo", nil).modules[0] foo := ctx.moduleGroupFromName("foo", nil).modules[0]
barB := ctx.moduleGroupFromName("bar", nil).modules[1] barB := ctx.moduleGroupFromName("bar", nil).modules[1]
if g, w := barB.variantName, "b"; g != w { if g, w := barB.variant.name, "b"; g != w {
t.Fatalf("expected bar.modules[1] variant to be %q, got %q", w, g) t.Fatalf("expected bar.modules[1] variant to be %q, got %q", w, g)
} }
@ -147,7 +147,7 @@ func TestAliases(t *testing.T) {
foo := ctx.moduleGroupFromName("foo", nil).modules[0] foo := ctx.moduleGroupFromName("foo", nil).modules[0]
barBB := ctx.moduleGroupFromName("bar", nil).modules[3] barBB := ctx.moduleGroupFromName("bar", nil).modules[3]
if g, w := barBB.variantName, "b_b"; g != w { if g, w := barBB.variant.name, "b_b"; g != w {
t.Fatalf("expected bar.modules[3] variant to be %q, got %q", w, g) t.Fatalf("expected bar.modules[3] variant to be %q, got %q", w, g)
} }
@ -171,7 +171,7 @@ func TestAliases(t *testing.T) {
foo := ctx.moduleGroupFromName("foo", nil).modules[0] foo := ctx.moduleGroupFromName("foo", nil).modules[0]
barAB := ctx.moduleGroupFromName("bar", nil).modules[1] barAB := ctx.moduleGroupFromName("bar", nil).modules[1]
if g, w := barAB.variantName, "a_b"; g != w { if g, w := barAB.variant.name, "a_b"; g != w {
t.Fatalf("expected bar.modules[1] variant to be %q, got %q", w, g) t.Fatalf("expected bar.modules[1] variant to be %q, got %q", w, g)
} }

12
splice_modules_test.go
View file

@ -20,12 +20,12 @@ import (
) )
var ( var (
testModuleA = &moduleInfo{variantName: "testModuleA"} testModuleA = &moduleInfo{variant: variant{name: "testModuleA"}}
testModuleB = &moduleInfo{variantName: "testModuleB"} testModuleB = &moduleInfo{variant: variant{name: "testModuleB"}}
testModuleC = &moduleInfo{variantName: "testModuleC"} testModuleC = &moduleInfo{variant: variant{name: "testModuleC"}}
testModuleD = &moduleInfo{variantName: "testModuleD"} testModuleD = &moduleInfo{variant: variant{name: "testModuleD"}}
testModuleE = &moduleInfo{variantName: "testModuleE"} testModuleE = &moduleInfo{variant: variant{name: "testModuleE"}}
testModuleF = &moduleInfo{variantName: "testModuleF"} testModuleF = &moduleInfo{variant: variant{name: "testModuleF"}}
) )
var spliceModulesTestCases = []struct { var spliceModulesTestCases = []struct {