9p: all - refactor constructors/remove reflection

This replaces the reflect based field selector/setter, and dynamic
function generation/calling - with generic type constraints and
option functions which utilize interfaces.

The previous code worked, but relied on strings to be used to reference
field values that were common across different types (that typically
inherited from each other). If a field name or shape of a struct ever
changed, this could cause a panic at runtime if the relevant option
function's constructor was not also updated.

Now, field selection is based around setter methods, and assignment is
handled by generic closure generators. If structures change, it
shouldn't cause issues, and if it would, the program will fail to
compile altogether rather than panic at runtime.

The cost is requiring field setters, but seems worth the change as
things can be further refactored in the future with more ease (compared
to the reflection approach) if better solutions become apparent.

Author: djdv

internal/filesystem/9p/chan.go

@@ -12,48 +12,62 @@ import (
 type (
 	ChannelFile struct {
 		templatefs.NoopFile
-		metadata
-		linkSync *linkSync
-		emitter  *chanEmitter[[]byte]
+		*metadata
+		*linkSync
+		emitter *chanEmitter[[]byte]
 		openFlags
 	}
 	channelSettings struct {
-		fileOptions
 		buffer int
 	}
-	ChannelOption func(*channelSettings) error
+	channelFileSettings struct {
+		fileSettings
+		channelSettings
+	}
+	ChannelOption        func(*channelFileSettings) error
+	channelSetter[T any] interface {
+		*T
+		setBuffer(int)
+	}
 )
 
+func (cs *channelSettings) setBuffer(size int) { cs.buffer = size }
+
 func NewChannelFile(ctx context.Context,
 	options ...ChannelOption,
 ) (p9.QID, *ChannelFile, <-chan []byte, error) {
-	var settings channelSettings
-	if err := parseOptions(&settings, options...); err != nil {
-		return p9.QID{}, nil, nil, err
-	}
-	metadata, err := makeMetadata(p9.ModeRegular, settings.metaOptions...)
-	if err != nil {
-		return p9.QID{}, nil, nil, err
-	}
-	linkSync, err := newLinkSync(settings.linkOptions...)
-	if err != nil {
+	var settings channelFileSettings
+	settings.metadata.initialize(p9.ModeRegular)
+	if err := applyOptions(&settings, options...); err != nil {
 		return p9.QID{}, nil, nil, err
 	}
 	var (
-		emitter   = makeChannelEmitter[[]byte](ctx, settings.buffer)
+		emitter = makeChannelEmitter[[]byte](
+			ctx,
+			settings.buffer,
+		)
 		bytesChan = emitter.ch
-		chanFile  = &ChannelFile{
-			metadata: metadata,
-			linkSync: linkSync,
+		file      = &ChannelFile{
+			metadata: &settings.metadata,
+			linkSync: &settings.linkSync,
 			emitter:  emitter,
 		}
 	)
-	metadata.incrementPath()
-	return *chanFile.QID, chanFile, bytesChan, nil
+	settings.metadata.fillDefaults()
+	settings.metadata.incrementPath()
+	return settings.QID, file, bytesChan, nil
 }
 
-func WithBuffer[OT ChannelOptions](size int) OT {
-	return makeFieldSetter[OT]("buffer", size)
+func WithBuffer[
+	OT optionFunc[T],
+	T any,
+	I channelSetter[T],
+](size int,
+) OT {
+	return func(channelFile *T) error {
+		any(channelFile).(I).setBuffer(size)
+		return nil
+	}
 }
 
 func (cf *ChannelFile) Walk(names []string) ([]p9.QID, p9.File, error) {
@@ -79,7 +93,7 @@ func (cf *ChannelFile) Open(mode p9.OpenFlags) (p9.QID, ioUnit, error) {
 		return p9.QID{}, 0, perrors.EINVAL
 	}
 	cf.openFlags = cf.withOpenedFlag(mode)
-	return *cf.QID, 0, nil
+	return cf.QID, 0, nil
 }
 
 func (cf *ChannelFile) Close() error {

internal/filesystem/9p/directory.go

@@ -19,50 +19,80 @@ type (
 	Directory struct {
 		templatefs.NoopFile
 		*fileTableSync
-		metadata
+		*metadata
 		*linkSync
 		opened,
 		cleanupElements bool
 	}
-	directorySettings struct {
-		fileOptions
-		cleanupSelf,
-		cleanupElements bool
-	}
-	DirectoryOption func(*directorySettings) error
-	ephemeralDir    struct {
+	ephemeralDir struct {
 		directory
 		refs *atomic.Uintptr
 		unlinkOnClose,
 		unlinking *atomic.Bool
 		closed bool
 	}
+	directorySettings struct {
+		fileSettings
+		cleanupSelf,
+		cleanupElements bool
+	}
+	DirectoryOption        func(*directorySettings) error
+	directorySetter[T any] interface {
+		*T
+		setCleanupSelf(bool)
+		setCleanupElements(bool)
+	}
 )
 
+func (ds *directorySettings) setCleanupSelf(b bool)     { ds.cleanupSelf = b }
+func (ds *directorySettings) setCleanupElements(b bool) { ds.cleanupElements = b }
+
+// UnlinkWhenEmpty causes files to unlink from their parent
+// after they are considered empty and the last reference
+// held by a Walk has been closed.
+func UnlinkWhenEmpty[
+	OT optionFunc[T],
+	T any,
+	I directorySetter[T],
+](b bool,
+) OT {
+	return func(settings *T) error {
+		any(settings).(I).setCleanupSelf(b)
+		return nil
+	}
+}
+
+// UnlinkEmptyChildren sets [UnlinkWhenEmpty]
+// on files created by this file.
+func UnlinkEmptyChildren[
+	OT optionFunc[T],
+	T any,
+	I directorySetter[T],
+](b bool,
+) OT {
+	return func(settings *T) error {
+		any(settings).(I).setCleanupElements(b)
+		return nil
+	}
+}
+
 func NewDirectory(options ...DirectoryOption) (p9.QID, p9.File, error) {
 	var settings directorySettings
-	if err := parseOptions(&settings, options...); err != nil {
-		return p9.QID{}, nil, err
-	}
-	metadata, err := makeMetadata(p9.ModeDirectory, settings.metaOptions...)
-	if err != nil {
+	settings.metadata.initialize(p9.ModeDirectory)
+	if err := applyOptions(&settings, options...); err != nil {
 		return p9.QID{}, nil, err
 	}
-	linkSync, err := newLinkSync(settings.linkOptions...)
-	if err != nil {
-		return p9.QID{}, nil, err
+	return newDirectory(&settings)
+}
+
+func newDirectory(settings *directorySettings) (p9.QID, p9.File, error) {
+	var file p9.File = &Directory{
+		fileTableSync: newFileTable(),
+		metadata:      &settings.metadata,
+		linkSync:      &settings.linkSync,
 	}
-	var (
-		directory = Directory{
-			fileTableSync: newFileTable(),
-			metadata:      metadata,
-			linkSync:      linkSync,
-		}
-		qid          = metadata.QID
-		file p9.File = &directory
-	)
 	if settings.cleanupSelf {
-		if parent := linkSync.parent; parent == nil {
+		if parent := settings.linkSync.parent; parent == nil {
 			err := generic.ConstError("cannot unlink self without parent file")
 			return p9.QID{}, nil, err
 		}
@@ -73,8 +103,9 @@ func NewDirectory(options ...DirectoryOption) (p9.QID, p9.File, error) {
 			unlinking:     new(atomic.Bool),
 		}
 	}
-	metadata.incrementPath()
-	return *qid, file, nil
+	settings.metadata.fillDefaults()
+	settings.metadata.incrementPath()
+	return settings.QID, file, nil
 }
 
 func (dir *Directory) Walk(names []string) ([]p9.QID, p9.File, error) {
@@ -170,7 +201,7 @@ func (dir *Directory) Open(mode p9.OpenFlags) (p9.QID, ioUnit, error) {
 		return p9.QID{}, noIOUnit, perrors.EINVAL
 	}
 	dir.opened = true
-	return *dir.QID, noIOUnit, nil
+	return dir.QID, noIOUnit, nil
 }
 
 func (dir *Directory) Link(file p9.File, name string) error {
@@ -200,7 +231,7 @@ func (dir *Directory) Mkdir(name string, permissions p9.FileMode, uid p9.UID, gi
 		WithParent[DirectoryOption](dir, name),
 		UnlinkWhenEmpty[DirectoryOption](dir.cleanupElements),
 		UnlinkEmptyChildren[DirectoryOption](dir.cleanupElements),
-		WithoutRename[DirectoryOption](dir.linkSync.disabled),
+		WithoutRename[DirectoryOption](dir.linkSync.renameDisabled),
 	)
 	if err == nil {
 		err = dir.Link(newDir, name)

internal/filesystem/9p/guest.go

@@ -13,7 +13,7 @@ type (
 		makeMountPointFn MakeMountPointFunc
 	}
 	guestSettings struct {
-		directoryOptions []DirectoryOption
+		directorySettings
 	}
 	GuestOption func(*guestSettings) error
 	// MakeMountPointFunc should handle file creation operations
@@ -27,13 +27,15 @@ type (
 	}
 )
 
-func NewGuestFile(makeMountPointFn MakeMountPointFunc, options ...GuestOption,
+func NewGuestFile(makeMountPointFn MakeMountPointFunc,
+	options ...GuestOption,
 ) (p9.QID, *GuestFile, error) {
 	var settings guestSettings
-	if err := parseOptions(&settings, options...); err != nil {
+	settings.metadata.initialize(p9.ModeDirectory)
+	if err := applyOptions(&settings, options...); err != nil {
 		return p9.QID{}, nil, err
 	}
-	qid, directory, err := NewDirectory(settings.directoryOptions...)
+	qid, directory, err := newDirectory(&settings.directorySettings)
 	if err != nil {
 		return p9.QID{}, nil, err
 	}

internal/filesystem/9p/host.go

@@ -14,7 +14,7 @@ type (
 		makeGuestFn MakeGuestFunc
 	}
 	hosterSettings struct {
-		directoryOptions []DirectoryOption
+		directorySettings
 	}
 	HosterOption func(*hosterSettings) error
 	// MakeGuestFunc should handle file creation operations
@@ -29,10 +29,11 @@ func NewHostFile(makeGuestFn MakeGuestFunc,
 	options ...HosterOption,
 ) (p9.QID, *HostFile, error) {
 	var settings hosterSettings
-	if err := parseOptions(&settings, options...); err != nil {
+	settings.metadata.initialize(p9.ModeDirectory)
+	if err := applyOptions(&settings, options...); err != nil {
 		return p9.QID{}, nil, err
 	}
-	qid, directory, err := NewDirectory(settings.directoryOptions...)
+	qid, directory, err := newDirectory(&settings.directorySettings)
 	if err != nil {
 		return p9.QID{}, nil, err
 	}