Function processLegacyExtensions

modules/overrides/extension.go:205–249

processLegacyExtensions converts registered extension flat keys in l.Extensions to typed Extension instances, giving LegacyOverrides.Extensions the same semantics as Overrides.Extensions after processExtensions: typed instances keyed by their nested Key(). For each registered extension whose Legacy

(l *LegacyOverrides)

//
// Any unregistered flat keys are rejected.
func processLegacyExtensions(l *LegacyOverrides) error {
	if len(l.Extensions) == 0 {
		return nil
	}

	extensionRegistry.RLock()
	defer extensionRegistry.RUnlock()

	for _, entry := range extensionRegistry.entries {
		hasFlatKey := false
		for _, fk := range entry.legacyKeys {
			if _, ok := l.Extensions[fk]; ok {
				hasFlatKey = true
				break
			}
		}
		if !hasFlatKey {
			continue
		}

		instance := entry.newInstance()
		instance.RegisterFlagsAndApplyDefaults("", flag.NewFlagSet("", flag.ContinueOnError)) // extension configs have no CLI prefix

		err := instance.FromLegacy(l.Extensions)
		if err != nil {
			return fmt.Errorf("extension %q: from legacy: %w", entry.key, err)
		}
		if err := instance.Validate(); err != nil {
			return fmt.Errorf("extension %q: %w", entry.key, err)
		}

		for _, fk := range entry.legacyKeys {
			delete(l.Extensions, fk)
		}
		l.Extensions[entry.key] = instance
	}

	// Reject any remaining / unregistered flat keys
	for k, v := range l.Extensions {
		if _, typed := v.(Extension); !typed {
			return fmt.Errorf("unknown legacy extension key %q: must be registered via RegisterExtension and declared in LegacyKeys() before use", k)
		}
	}
	return nil
}

// flattenExtensionEntries returns a new map where typed Extension values are replaced by their
// flat legacy key-value pairs (via ToLegacy).