Remove pre singletons

	"regexp"

	"android/soong/shared"

	"github.com/google/blueprint"

)

var moduleTypeByFactory = map[reflect.Value]string{}

type singleton struct {

	// True if this should be registered as a pre-singleton, false otherwise.

	pre bool

	// True if this should be registered as a parallel singleton.

	parallel bool

}

func newSingleton(name string, factory SingletonFactory, parallel bool) singleton {

	return singleton{pre: false, parallel: parallel, name: name, factory: factory}

}

func newPreSingleton(name string, factory SingletonFactory) singleton {

	return singleton{pre: true, parallel: false, name: name, factory: factory}

	return singleton{parallel: parallel, name: name, factory: factory}

}

func (s singleton) componentName() string {

func (s singleton) register(ctx *Context) {

	adaptor := SingletonFactoryAdaptor(ctx, s.factory)

	if s.pre {

		ctx.RegisterPreSingletonType(s.name, adaptor)

	} else {

	ctx.RegisterSingletonType(s.name, adaptor, s.parallel)

}

}

var _ sortableComponent = singleton{}

var singletons sortableComponents

var preSingletons sortableComponents

type mutator struct {

	name              string

	registerSingletonType(name, factory, true)

}

func RegisterPreSingletonType(name string, factory SingletonFactory) {

	preSingletons = append(preSingletons, newPreSingleton(name, factory))

}

type Context struct {

	*blueprint.Context

	config Config

// Register the pipeline of singletons, module types, and mutators for

// generating build.ninja and other files for Kati, from Android.bp files.

func (ctx *Context) Register() {

	preSingletons.registerAll(ctx)

	for _, t := range moduleTypes {

		t.register(ctx)

	}

func collateGloballyRegisteredSingletons() sortableComponents {

	allSingletons := append(sortableComponents(nil), singletons...)

	allSingletons = append(allSingletons,

		singleton{pre: false, parallel: true, name: "bazeldeps", factory: BazelSingleton},

		singleton{parallel: true, name: "bazeldeps", factory: BazelSingleton},

		// Register phony just before makevars so it can write out its phony rules as Make rules

		singleton{pre: false, parallel: false, name: "phony", factory: phonySingletonFactory},

		singleton{parallel: false, name: "phony", factory: phonySingletonFactory},

		// Register makevars after other singletons so they can export values through makevars

		singleton{pre: false, parallel: false, name: "makevars", factory: makeVarsSingletonFunc},

		singleton{parallel: false, name: "makevars", factory: makeVarsSingletonFunc},

		// Register env and ninjadeps last so that they can track all used environment variables and

		// Ninja file dependencies stored in the config.

		singleton{pre: false, parallel: false, name: "ninjadeps", factory: ninjaDepsSingletonFactory},

		singleton{parallel: false, name: "ninjadeps", factory: ninjaDepsSingletonFactory},

	)

	return allSingletons

	RegisterModuleType(name string, factory ModuleFactory)

	RegisterSingletonModuleType(name string, factory SingletonModuleFactory)

	RegisterParallelSingletonModuleType(name string, factory SingletonModuleFactory)

	RegisterPreSingletonType(name string, factory SingletonFactory)

	RegisterParallelSingletonType(name string, factory SingletonFactory)

	RegisterSingletonType(name string, factory SingletonFactory)

	PreArchMutators(f RegisterMutatorFunc)

var InitRegistrationContext RegistrationContext = &initRegistrationContext{

	moduleTypes:    make(map[string]ModuleFactory),

	singletonTypes: make(map[string]SingletonFactory),

	preSingletonTypes: make(map[string]SingletonFactory),

}

// Make sure the TestContext implements RegistrationContext.

type initRegistrationContext struct {

	moduleTypes        map[string]ModuleFactory

	singletonTypes     map[string]SingletonFactory

	preSingletonTypes  map[string]SingletonFactory

	moduleTypesForDocs map[string]reflect.Value

}

	ctx.registerSingletonType(name, factory, true)

}

func (ctx *initRegistrationContext) RegisterPreSingletonType(name string, factory SingletonFactory) {

	if _, present := ctx.preSingletonTypes[name]; present {

		panic(fmt.Sprintf("pre singleton type %q is already registered", name))

	}

	ctx.preSingletonTypes[name] = factory

	RegisterPreSingletonType(name, factory)

}

func (ctx *initRegistrationContext) PreArchMutators(f RegisterMutatorFunc) {

	PreArchMutators(f)

}

	bp2buildPreArch, bp2buildMutators     []RegisterMutatorFunc

	NameResolver                          *NameResolver

	// The list of pre-singletons and singletons registered for the test.

	preSingletons, singletons sortableComponents

	// The list of singletons registered for the test.

	singletons sortableComponents

	// The order in which the pre-singletons, mutators and singletons will be run in this test

	// The order in which the mutators and singletons will be run in this test

	// context; for debugging.

	preSingletonOrder, mutatorOrder, singletonOrder []string

	mutatorOrder, singletonOrder []string

}

func (ctx *TestContext) PreArchMutators(f RegisterMutatorFunc) {

	// Used to ensure that this is only created once.

	once sync.Once

	// The order of pre-singletons

	preSingletonOrder registeredComponentOrder

	// The order of mutators

	mutatorOrder registeredComponentOrder

// Only the first call has any effect.

func (s *registrationSorter) populate() {

	s.once.Do(func() {

		// Create an ordering from the globally registered pre-singletons.

		s.preSingletonOrder = registeredComponentOrderFromExistingOrder("pre-singleton", preSingletons)

		// Created an ordering from the globally registered mutators.

		globallyRegisteredMutators := collateGloballyRegisteredMutators()

		s.mutatorOrder = registeredComponentOrderFromExistingOrder("mutator", globallyRegisteredMutators)

func (ctx *TestContext) Register() {

	globalOrder := globallyRegisteredComponentsOrder()

	// Ensure that the pre-singletons used in the test are in the same order as they are used at

	// runtime.

	globalOrder.preSingletonOrder.enforceOrdering(ctx.preSingletons)

	ctx.preSingletons.registerAll(ctx.Context)

	mutators := collateRegisteredMutators(ctx.preArch, ctx.preDeps, ctx.postDeps, ctx.finalDeps)

	// Ensure that the mutators used in the test are in the same order as they are used at runtime.

	globalOrder.mutatorOrder.enforceOrdering(mutators)

	ctx.singletons.registerAll(ctx.Context)

	// Save the sorted components order away to make them easy to access while debugging.

	ctx.preSingletonOrder = componentsToNames(preSingletons)

	ctx.mutatorOrder = componentsToNames(mutators)

	ctx.singletonOrder = componentsToNames(singletons)

}

	ctx.singletons = append(ctx.singletons, newSingleton(name, factory, true))

}

func (ctx *TestContext) RegisterPreSingletonType(name string, factory SingletonFactory) {

	ctx.preSingletons = append(ctx.preSingletons, newPreSingleton(name, factory))

}

// ModuleVariantForTests selects a specific variant of the module with the given

// name by matching the variations map against the variations of each module

// variant. A module variant matches the map if every variation that exists in