android/namespace.go - android_build_soong - Gitiles

 // Copyright 2017 Google Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package android

 import (
 	"errors"
 	"fmt"
 	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
 	"sync"

 	"github.com/google/blueprint"
 )

 func init() {
 	RegisterModuleType("soong_namespace", NamespaceFactory)
 }

 // threadsafe sorted list
 type sortedNamespaces struct {
 	lock   sync.Mutex
 	items  []*Namespace
 	sorted bool
 }

 func (s *sortedNamespaces) add(namespace *Namespace) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 	if s.sorted {
 		panic("It is not supported to call sortedNamespaces.add() after sortedNamespaces.sortedItems()")
 	}
 	s.items = append(s.items, namespace)
 }

 func (s *sortedNamespaces) sortedItems() []*Namespace {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 	if !s.sorted {
 		less := func(i int, j int) bool {
 			return s.items[i].Path < s.items[j].Path
 		}
 		sort.Slice(s.items, less)
 		s.sorted = true
 	}
 	return s.items
 }

 func (s *sortedNamespaces) index(namespace *Namespace) int {
 	for i, candidate := range s.sortedItems() {
 		if namespace == candidate {
 			return i
 		}
 	}
 	return -1
 }

 // A NameResolver implements blueprint.NameInterface, and implements the logic to
 // find a module from namespaces based on a query string.
 // A query string can be a module name or can be be "//namespace_path:module_path"
 type NameResolver struct {
 	rootNamespace *Namespace

 	// id counter for atomic.AddInt32
 	nextNamespaceId int32

 	// All namespaces, without duplicates.
 	sortedNamespaces sortedNamespaces

 	// Map from dir to namespace. Will have duplicates if two dirs are part of the same namespace.
 	namespacesByDir sync.Map // if generics were supported, this would be sync.Map[string]*Namespace

 	// func telling whether to export a namespace to Kati
 	namespaceExportFilter func(*Namespace) bool
 }

 func NewNameResolver(namespaceExportFilter func(*Namespace) bool) *NameResolver {
 	r := &NameResolver{
 		namespacesByDir:       sync.Map{},
 		namespaceExportFilter: namespaceExportFilter,
 	}
 	r.rootNamespace = r.newNamespace(".")
 	r.rootNamespace.visibleNamespaces = []*Namespace{r.rootNamespace}
 	r.addNamespace(r.rootNamespace)

 	return r
 }

 func (r *NameResolver) newNamespace(path string) *Namespace {
 	namespace := NewNamespace(path)

 	namespace.exportToKati = r.namespaceExportFilter(namespace)

 	return namespace
 }

 func (r *NameResolver) addNewNamespaceForModule(module *NamespaceModule, path string) error {
 	fileName := filepath.Base(path)
 	if fileName != "Android.bp" {
 		return errors.New("A namespace may only be declared in a file named Android.bp")
 	}
 	dir := filepath.Dir(path)

 	namespace := r.newNamespace(dir)
 	module.namespace = namespace
 	module.resolver = r
 	namespace.importedNamespaceNames = module.properties.Imports
 	return r.addNamespace(namespace)
 }

 func (r *NameResolver) addNamespace(namespace *Namespace) (err error) {
 	existingNamespace, exists := r.namespaceAt(namespace.Path)
 	if exists {
 		if existingNamespace.Path == namespace.Path {
 			return fmt.Errorf("namespace %v already exists", namespace.Path)
 		} else {
 			// It would probably confuse readers if namespaces were declared anywhere but
 			// the top of the file, so we forbid declaring namespaces after anything else.
 			return fmt.Errorf("a namespace must be the first module in the file")
 		}
 	}
 	r.sortedNamespaces.add(namespace)

 	r.namespacesByDir.Store(namespace.Path, namespace)
 	return nil
 }

 // non-recursive check for namespace
 func (r *NameResolver) namespaceAt(path string) (namespace *Namespace, found bool) {
 	mapVal, found := r.namespacesByDir.Load(path)
 	if !found {
 		return nil, false
 	}
 	return mapVal.(*Namespace), true
 }

 // recursive search upward for a namespace
 func (r *NameResolver) findNamespace(path string) (namespace *Namespace) {
 	namespace, found := r.namespaceAt(path)
 	if found {
 		return namespace
 	}
 	parentDir := filepath.Dir(path)
 	if parentDir == path {
 		return nil
 	}
 	namespace = r.findNamespace(parentDir)
 	r.namespacesByDir.Store(path, namespace)
 	return namespace
 }

 // A NamelessModule can never be looked up by name.  It must still implement Name(), but the return
 // value doesn't have to be unique.
 type NamelessModule interface {
 	Nameless()
 }

 func (r *NameResolver) NewModule(ctx blueprint.NamespaceContext, moduleGroup blueprint.ModuleGroup, module blueprint.Module) (namespace blueprint.Namespace, errs []error) {
 	// if this module is a namespace, then save it to our list of namespaces
 	newNamespace, ok := module.(*NamespaceModule)
 	if ok {
 		err := r.addNewNamespaceForModule(newNamespace, ctx.ModulePath())
 		if err != nil {
 			return nil, []error{err}
 		}
 		return nil, nil
 	}

 	if _, ok := module.(NamelessModule); ok {
 		return nil, nil
 	}

 	// if this module is not a namespace, then save it into the appropriate namespace
 	ns := r.findNamespaceFromCtx(ctx)

 	_, errs = ns.moduleContainer.NewModule(ctx, moduleGroup, module)
 	if len(errs) > 0 {
 		return nil, errs
 	}

 	amod, ok := module.(Module)
 	if ok {
 		// inform the module whether its namespace is one that we want to export to Make
 		amod.base().commonProperties.NamespaceExportedToMake = ns.exportToKati
 		amod.base().commonProperties.DebugName = module.Name()
 	}

 	return ns, nil
 }

 func (r *NameResolver) AllModules() []blueprint.ModuleGroup {
 	childLists := [][]blueprint.ModuleGroup{}
 	totalCount := 0
 	for _, namespace := range r.sortedNamespaces.sortedItems() {
 		newModules := namespace.moduleContainer.AllModules()
 		totalCount += len(newModules)
 		childLists = append(childLists, newModules)
 	}

 	allModules := make([]blueprint.ModuleGroup, 0, totalCount)
 	for _, childList := range childLists {
 		allModules = append(allModules, childList...)
 	}
 	return allModules
 }

 // parses a fully-qualified path (like "//namespace_path:module_name") into a namespace name and a
 // module name
 func (r *NameResolver) parseFullyQualifiedName(name string) (namespaceName string, moduleName string, ok bool) {
 	if !strings.HasPrefix(name, "//") {
 		return "", "", false
 	}
 	name = strings.TrimPrefix(name, "//")
 	components := strings.Split(name, ":")
 	if len(components) != 2 {
 		return "", "", false
 	}
 	return components[0], components[1], true

 }

 func (r *NameResolver) getNamespacesToSearchForModule(sourceNamespace *Namespace) (searchOrder []*Namespace) {
 	if sourceNamespace.visibleNamespaces == nil {
 		// When handling dependencies before namespaceMutator, assume they are non-Soong Blueprint modules and give
 		// access to all namespaces.
 		return r.sortedNamespaces.sortedItems()
 	}
 	return sourceNamespace.visibleNamespaces
 }

 func (r *NameResolver) ModuleFromName(name string, namespace blueprint.Namespace) (group blueprint.ModuleGroup, found bool) {
 	// handle fully qualified references like "//namespace_path:module_name"
 	nsName, moduleName, isAbs := r.parseFullyQualifiedName(name)
 	if isAbs {
 		namespace, found := r.namespaceAt(nsName)
 		if !found {
 			return blueprint.ModuleGroup{}, false
 		}
 		container := namespace.moduleContainer
 		return container.ModuleFromName(moduleName, nil)
 	}
 	for _, candidate := range r.getNamespacesToSearchForModule(namespace.(*Namespace)) {
 		group, found = candidate.moduleContainer.ModuleFromName(name, nil)
 		if found {
 			return group, true
 		}
 	}
 	return blueprint.ModuleGroup{}, false

 }

 func (r *NameResolver) Rename(oldName string, newName string, namespace blueprint.Namespace) []error {
 	return namespace.(*Namespace).moduleContainer.Rename(oldName, newName, namespace)
 }

 // resolve each element of namespace.importedNamespaceNames and put the result in namespace.visibleNamespaces
 func (r *NameResolver) FindNamespaceImports(namespace *Namespace) (err error) {
 	namespace.visibleNamespaces = make([]*Namespace, 0, 2+len(namespace.importedNamespaceNames))
 	// search itself first
 	namespace.visibleNamespaces = append(namespace.visibleNamespaces, namespace)
 	// search its imports next
 	for _, name := range namespace.importedNamespaceNames {
 		imp, ok := r.namespaceAt(name)
 		if !ok {
 			return fmt.Errorf("namespace %v does not exist", name)
 		}
 		namespace.visibleNamespaces = append(namespace.visibleNamespaces, imp)
 	}
 	// search the root namespace last
 	namespace.visibleNamespaces = append(namespace.visibleNamespaces, r.rootNamespace)
 	return nil
 }

 func (r *NameResolver) chooseId(namespace *Namespace) {
 	id := r.sortedNamespaces.index(namespace)
 	if id < 0 {
 		panic(fmt.Sprintf("Namespace not found: %v\n", namespace.id))
 	}
 	namespace.id = strconv.Itoa(id)
 }

 func (r *NameResolver) MissingDependencyError(depender string, dependerNamespace blueprint.Namespace, depName string) (err error) {
 	text := fmt.Sprintf("%q depends on undefined module %q", depender, depName)

 	_, _, isAbs := r.parseFullyQualifiedName(depName)
 	if isAbs {
 		// if the user gave a fully-qualified name, we don't need to look for other
 		// modules that they might have been referring to
 		return fmt.Errorf(text)
 	}

 	// determine which namespaces the module can be found in
 	foundInNamespaces := []string{}
 	for _, namespace := range r.sortedNamespaces.sortedItems() {
 		_, found := namespace.moduleContainer.ModuleFromName(depName, nil)
 		if found {
 			foundInNamespaces = append(foundInNamespaces, namespace.Path)
 		}
 	}
 	if len(foundInNamespaces) > 0 {
 		// determine which namespaces are visible to dependerNamespace
 		dependerNs := dependerNamespace.(*Namespace)
 		searched := r.getNamespacesToSearchForModule(dependerNs)
 		importedNames := []string{}
 		for _, ns := range searched {
 			importedNames = append(importedNames, ns.Path)
 		}
 		text += fmt.Sprintf("\nModule %q is defined in namespace %q which can read these %v namespaces: %q", depender, dependerNs.Path, len(importedNames), importedNames)
 		text += fmt.Sprintf("\nModule %q can be found in these namespaces: %q", depName, foundInNamespaces)
 	}

 	return fmt.Errorf(text)
 }

 func (r *NameResolver) GetNamespace(ctx blueprint.NamespaceContext) blueprint.Namespace {
 	return r.findNamespaceFromCtx(ctx)
 }

 func (r *NameResolver) findNamespaceFromCtx(ctx blueprint.NamespaceContext) *Namespace {
 	return r.findNamespace(filepath.Dir(ctx.ModulePath()))
 }

 func (r *NameResolver) UniqueName(ctx blueprint.NamespaceContext, name string) (unique string) {
 	prefix := r.findNamespaceFromCtx(ctx).id
 	if prefix != "" {
 		prefix = prefix + "-"
 	}
 	return prefix + name
 }

 var _ blueprint.NameInterface = (*NameResolver)(nil)

 type Namespace struct {
 	blueprint.NamespaceMarker
 	Path string

 	// names of namespaces listed as imports by this namespace
 	importedNamespaceNames []string
 	// all namespaces that should be searched when a module in this namespace declares a dependency
 	visibleNamespaces []*Namespace

 	id string

 	exportToKati bool

 	moduleContainer blueprint.NameInterface
 }

 func NewNamespace(path string) *Namespace {
 	return &Namespace{Path: path, moduleContainer: blueprint.NewSimpleNameInterface()}
 }

 var _ blueprint.Namespace = (*Namespace)(nil)

 type namespaceProperties struct {
 	// a list of namespaces that contain modules that will be referenced
 	// by modules in this namespace.
 	Imports []string `android:"path"`
 }

 type NamespaceModule struct {
 	ModuleBase

 	namespace *Namespace
 	resolver  *NameResolver

 	properties namespaceProperties
 }

 func (n *NamespaceModule) GenerateAndroidBuildActions(ctx ModuleContext) {
 }

 func (n *NamespaceModule) GenerateBuildActions(ctx blueprint.ModuleContext) {
 }

 func (n *NamespaceModule) Name() (name string) {
 	return *n.nameProperties.Name
 }

 // soong_namespace provides a scope to modules in an Android.bp file to prevent
 // module name conflicts with other defined modules in different Android.bp
 // files. Once soong_namespace has been defined in an Android.bp file, the
 // namespacing is applied to all modules that follow the soong_namespace in
 // the current Android.bp file, as well as modules defined in Android.bp files
 // in subdirectories. An Android.bp file in a subdirectory can define its own
 // soong_namespace which is applied to all its modules and as well as modules
 // defined in subdirectories Android.bp files. Modules in a soong_namespace are
 // visible to Make by listing the namespace path in PRODUCT_SOONG_NAMESPACES
 // make variable in a makefile.
 func NamespaceFactory() Module {
 	module := &NamespaceModule{}

 	name := "soong_namespace"
 	module.nameProperties.Name = &name

 	module.AddProperties(&module.properties)
 	return module
 }

 func RegisterNamespaceMutator(ctx RegisterMutatorsContext) {
 	ctx.BottomUp("namespace_deps", namespaceMutator).Parallel()
 }

 func namespaceMutator(ctx BottomUpMutatorContext) {
 	module, ok := ctx.Module().(*NamespaceModule)
 	if ok {
 		err := module.resolver.FindNamespaceImports(module.namespace)
 		if err != nil {
 			ctx.ModuleErrorf(err.Error())
 		}

 		module.resolver.chooseId(module.namespace)
 	}
 }
	// Copyright 2017 Google Inc. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package android

	import (
	"errors"
	"fmt"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"sync"

	"github.com/google/blueprint"
	)

	func init() {
	RegisterModuleType("soong_namespace", NamespaceFactory)
	}

	// threadsafe sorted list
	type sortedNamespaces struct {
	lock sync.Mutex
	items []*Namespace
	sorted bool
	}

	func (s sortedNamespaces) add(namespace Namespace) {
	s.lock.Lock()
	defer s.lock.Unlock()
	if s.sorted {
	panic("It is not supported to call sortedNamespaces.add() after sortedNamespaces.sortedItems()")
	}
	s.items = append(s.items, namespace)
	}

	func (s sortedNamespaces) sortedItems() []Namespace {
	s.lock.Lock()
	defer s.lock.Unlock()
	if !s.sorted {
	less := func(i int, j int) bool {
	return s.items[i].Path < s.items[j].Path
	}
	sort.Slice(s.items, less)
	s.sorted = true
	}
	return s.items
	}

	func (s sortedNamespaces) index(namespace Namespace) int {
	for i, candidate := range s.sortedItems() {
	if namespace == candidate {
	return i
	}
	}
	return -1
	}

	// A NameResolver implements blueprint.NameInterface, and implements the logic to
	// find a module from namespaces based on a query string.
	// A query string can be a module name or can be be "//namespace_path:module_path"
	type NameResolver struct {
	rootNamespace *Namespace

	// id counter for atomic.AddInt32
	nextNamespaceId int32

	// All namespaces, without duplicates.
	sortedNamespaces sortedNamespaces

	// Map from dir to namespace. Will have duplicates if two dirs are part of the same namespace.
	namespacesByDir sync.Map // if generics were supported, this would be sync.Map[string]*Namespace

	// func telling whether to export a namespace to Kati
	namespaceExportFilter func(*Namespace) bool
	}

	func NewNameResolver(namespaceExportFilter func(Namespace) bool) NameResolver {
	r := &NameResolver{
	namespacesByDir: sync.Map{},
	namespaceExportFilter: namespaceExportFilter,
	}
	r.rootNamespace = r.newNamespace(".")
	r.rootNamespace.visibleNamespaces = []*Namespace{r.rootNamespace}
	r.addNamespace(r.rootNamespace)

	return r
	}

	func (r NameResolver) newNamespace(path string) Namespace {
	namespace := NewNamespace(path)

	namespace.exportToKati = r.namespaceExportFilter(namespace)

	return namespace
	}

	func (r NameResolver) addNewNamespaceForModule(module NamespaceModule, path string) error {
	fileName := filepath.Base(path)
	if fileName != "Android.bp" {
	return errors.New("A namespace may only be declared in a file named Android.bp")
	}
	dir := filepath.Dir(path)

	namespace := r.newNamespace(dir)
	module.namespace = namespace
	module.resolver = r
	namespace.importedNamespaceNames = module.properties.Imports
	return r.addNamespace(namespace)
	}

	func (r NameResolver) addNamespace(namespace Namespace) (err error) {
	existingNamespace, exists := r.namespaceAt(namespace.Path)
	if exists {
	if existingNamespace.Path == namespace.Path {
	return fmt.Errorf("namespace %v already exists", namespace.Path)
	} else {
	// It would probably confuse readers if namespaces were declared anywhere but
	// the top of the file, so we forbid declaring namespaces after anything else.
	return fmt.Errorf("a namespace must be the first module in the file")
	}
	}
	r.sortedNamespaces.add(namespace)

	r.namespacesByDir.Store(namespace.Path, namespace)
	return nil
	}

	// non-recursive check for namespace
	func (r NameResolver) namespaceAt(path string) (namespace Namespace, found bool) {
	mapVal, found := r.namespacesByDir.Load(path)
	if !found {
	return nil, false
	}
	return mapVal.(*Namespace), true
	}

	// recursive search upward for a namespace
	func (r NameResolver) findNamespace(path string) (namespace Namespace) {
	namespace, found := r.namespaceAt(path)
	if found {
	return namespace
	}
	parentDir := filepath.Dir(path)
	if parentDir == path {
	return nil
	}
	namespace = r.findNamespace(parentDir)
	r.namespacesByDir.Store(path, namespace)
	return namespace
	}

	// A NamelessModule can never be looked up by name. It must still implement Name(), but the return
	// value doesn't have to be unique.
	type NamelessModule interface {
	Nameless()
	}

	func (r *NameResolver) NewModule(ctx blueprint.NamespaceContext, moduleGroup blueprint.ModuleGroup, module blueprint.Module) (namespace blueprint.Namespace, errs []error) {
	// if this module is a namespace, then save it to our list of namespaces
	newNamespace, ok := module.(*NamespaceModule)
	if ok {
	err := r.addNewNamespaceForModule(newNamespace, ctx.ModulePath())
	if err != nil {
	return nil, []error{err}
	}
	return nil, nil
	}

	if _, ok := module.(NamelessModule); ok {
	return nil, nil
	}

	// if this module is not a namespace, then save it into the appropriate namespace
	ns := r.findNamespaceFromCtx(ctx)

	_, errs = ns.moduleContainer.NewModule(ctx, moduleGroup, module)
	if len(errs) > 0 {
	return nil, errs
	}

	amod, ok := module.(Module)
	if ok {
	// inform the module whether its namespace is one that we want to export to Make
	amod.base().commonProperties.NamespaceExportedToMake = ns.exportToKati
	amod.base().commonProperties.DebugName = module.Name()
	}

	return ns, nil
	}

	func (r *NameResolver) AllModules() []blueprint.ModuleGroup {
	childLists := [][]blueprint.ModuleGroup{}
	totalCount := 0
	for _, namespace := range r.sortedNamespaces.sortedItems() {
	newModules := namespace.moduleContainer.AllModules()
	totalCount += len(newModules)
	childLists = append(childLists, newModules)
	}

	allModules := make([]blueprint.ModuleGroup, 0, totalCount)
	for _, childList := range childLists {
	allModules = append(allModules, childList...)
	}
	return allModules
	}

	// parses a fully-qualified path (like "//namespace_path:module_name") into a namespace name and a
	// module name
	func (r *NameResolver) parseFullyQualifiedName(name string) (namespaceName string, moduleName string, ok bool) {
	if !strings.HasPrefix(name, "//") {
	return "", "", false
	}
	name = strings.TrimPrefix(name, "//")
	components := strings.Split(name, ":")
	if len(components) != 2 {
	return "", "", false
	}
	return components[0], components[1], true

	}

	func (r NameResolver) getNamespacesToSearchForModule(sourceNamespace Namespace) (searchOrder []*Namespace) {
	if sourceNamespace.visibleNamespaces == nil {
	// When handling dependencies before namespaceMutator, assume they are non-Soong Blueprint modules and give
	// access to all namespaces.
	return r.sortedNamespaces.sortedItems()
	}
	return sourceNamespace.visibleNamespaces
	}

	func (r *NameResolver) ModuleFromName(name string, namespace blueprint.Namespace) (group blueprint.ModuleGroup, found bool) {
	// handle fully qualified references like "//namespace_path:module_name"
	nsName, moduleName, isAbs := r.parseFullyQualifiedName(name)
	if isAbs {
	namespace, found := r.namespaceAt(nsName)
	if !found {
	return blueprint.ModuleGroup{}, false
	}
	container := namespace.moduleContainer
	return container.ModuleFromName(moduleName, nil)
	}
	for _, candidate := range r.getNamespacesToSearchForModule(namespace.(*Namespace)) {
	group, found = candidate.moduleContainer.ModuleFromName(name, nil)
	if found {
	return group, true
	}
	}
	return blueprint.ModuleGroup{}, false

	}

	func (r *NameResolver) Rename(oldName string, newName string, namespace blueprint.Namespace) []error {
	return namespace.(*Namespace).moduleContainer.Rename(oldName, newName, namespace)
	}

	// resolve each element of namespace.importedNamespaceNames and put the result in namespace.visibleNamespaces
	func (r NameResolver) FindNamespaceImports(namespace Namespace) (err error) {
	namespace.visibleNamespaces = make([]*Namespace, 0, 2+len(namespace.importedNamespaceNames))
	// search itself first
	namespace.visibleNamespaces = append(namespace.visibleNamespaces, namespace)
	// search its imports next
	for _, name := range namespace.importedNamespaceNames {
	imp, ok := r.namespaceAt(name)
	if !ok {
	return fmt.Errorf("namespace %v does not exist", name)
	}
	namespace.visibleNamespaces = append(namespace.visibleNamespaces, imp)
	}
	// search the root namespace last
	namespace.visibleNamespaces = append(namespace.visibleNamespaces, r.rootNamespace)
	return nil
	}

	func (r NameResolver) chooseId(namespace Namespace) {
	id := r.sortedNamespaces.index(namespace)
	if id < 0 {
	panic(fmt.Sprintf("Namespace not found: %v\n", namespace.id))
	}
	namespace.id = strconv.Itoa(id)
	}

	func (r *NameResolver) MissingDependencyError(depender string, dependerNamespace blueprint.Namespace, depName string) (err error) {
	text := fmt.Sprintf("%q depends on undefined module %q", depender, depName)

	_, _, isAbs := r.parseFullyQualifiedName(depName)
	if isAbs {
	// if the user gave a fully-qualified name, we don't need to look for other
	// modules that they might have been referring to
	return fmt.Errorf(text)
	}

	// determine which namespaces the module can be found in
	foundInNamespaces := []string{}
	for _, namespace := range r.sortedNamespaces.sortedItems() {
	_, found := namespace.moduleContainer.ModuleFromName(depName, nil)
	if found {
	foundInNamespaces = append(foundInNamespaces, namespace.Path)
	}
	}
	if len(foundInNamespaces) > 0 {
	// determine which namespaces are visible to dependerNamespace
	dependerNs := dependerNamespace.(*Namespace)
	searched := r.getNamespacesToSearchForModule(dependerNs)
	importedNames := []string{}
	for _, ns := range searched {
	importedNames = append(importedNames, ns.Path)
	}
	text += fmt.Sprintf("\nModule %q is defined in namespace %q which can read these %v namespaces: %q", depender, dependerNs.Path, len(importedNames), importedNames)
	text += fmt.Sprintf("\nModule %q can be found in these namespaces: %q", depName, foundInNamespaces)
	}

	return fmt.Errorf(text)
	}

	func (r *NameResolver) GetNamespace(ctx blueprint.NamespaceContext) blueprint.Namespace {
	return r.findNamespaceFromCtx(ctx)
	}

	func (r NameResolver) findNamespaceFromCtx(ctx blueprint.NamespaceContext) Namespace {
	return r.findNamespace(filepath.Dir(ctx.ModulePath()))
	}

	func (r *NameResolver) UniqueName(ctx blueprint.NamespaceContext, name string) (unique string) {
	prefix := r.findNamespaceFromCtx(ctx).id
	if prefix != "" {
	prefix = prefix + "-"
	}
	return prefix + name
	}

	var _ blueprint.NameInterface = (*NameResolver)(nil)

	type Namespace struct {
	blueprint.NamespaceMarker
	Path string

	// names of namespaces listed as imports by this namespace
	importedNamespaceNames []string
	// all namespaces that should be searched when a module in this namespace declares a dependency
	visibleNamespaces []*Namespace

	id string

	exportToKati bool

	moduleContainer blueprint.NameInterface
	}

	func NewNamespace(path string) *Namespace {
	return &Namespace{Path: path, moduleContainer: blueprint.NewSimpleNameInterface()}
	}

	var _ blueprint.Namespace = (*Namespace)(nil)

	type namespaceProperties struct {
	// a list of namespaces that contain modules that will be referenced
	// by modules in this namespace.
	Imports []string `android:"path"`
	}

	type NamespaceModule struct {
	ModuleBase

	namespace *Namespace
	resolver *NameResolver

	properties namespaceProperties
	}

	func (n *NamespaceModule) GenerateAndroidBuildActions(ctx ModuleContext) {
	}

	func (n *NamespaceModule) GenerateBuildActions(ctx blueprint.ModuleContext) {
	}

	func (n *NamespaceModule) Name() (name string) {
	return *n.nameProperties.Name
	}

	// soong_namespace provides a scope to modules in an Android.bp file to prevent
	// module name conflicts with other defined modules in different Android.bp
	// files. Once soong_namespace has been defined in an Android.bp file, the
	// namespacing is applied to all modules that follow the soong_namespace in
	// the current Android.bp file, as well as modules defined in Android.bp files
	// in subdirectories. An Android.bp file in a subdirectory can define its own
	// soong_namespace which is applied to all its modules and as well as modules
	// defined in subdirectories Android.bp files. Modules in a soong_namespace are
	// visible to Make by listing the namespace path in PRODUCT_SOONG_NAMESPACES
	// make variable in a makefile.
	func NamespaceFactory() Module {
	module := &NamespaceModule{}

	name := "soong_namespace"
	module.nameProperties.Name = &name

	module.AddProperties(&module.properties)
	return module
	}

	func RegisterNamespaceMutator(ctx RegisterMutatorsContext) {
	ctx.BottomUp("namespace_deps", namespaceMutator).Parallel()
	}

	func namespaceMutator(ctx BottomUpMutatorContext) {
	module, ok := ctx.Module().(*NamespaceModule)
	if ok {
	err := module.resolver.FindNamespaceImports(module.namespace)
	if err != nil {
	ctx.ModuleErrorf(err.Error())
	}

	module.resolver.chooseId(module.namespace)
	}
	}