polish

Signed-off-by: Adrian Cole <[email protected]>

imports/wasi_snapshot_preview1/wasi_bench_test.go

@@ -174,8 +174,7 @@ func Benchmark_fdReaddir(b *testing.B) {
 
 			// Open the root directory as a file-descriptor.
 			fsc := mod.(*wasm.CallContext).Sys.FS()
-			preopen := fsc.RootFS()
-			fd, err := fsc.OpenFile(preopen, ".", os.O_RDONLY, 0)
+			fd, err := fsc.OpenFile(fsc.RootFS(), ".", os.O_RDONLY, 0)
 			if err != nil {
 				b.Fatal(err)
 			}
@@ -281,8 +280,7 @@ func Benchmark_pathFilestat(b *testing.B) {
 			fd := sys.FdPreopen
 			if bc.fd != sys.FdPreopen {
 				fsc := mod.(*wasm.CallContext).Sys.FS()
-				preopen := fsc.RootFS()
-				fd, err = fsc.OpenFile(preopen, "zig", os.O_RDONLY, 0)
+				fd, err = fsc.OpenFile(fsc.RootFS(), "zig", os.O_RDONLY, 0)
 				if err != nil {
 					b.Fatal(err)
 				}

internal/sys/fs.go

@@ -202,8 +202,8 @@ type ReadDir struct {
 }
 
 type FSContext struct {
-	// root is the root ("/") mount.
-	root sysfs.FS
+	// rootFS is the root ("/") mount.
+	rootFS sysfs.FS
 
 	// openedFiles is a map of file descriptor numbers (>=FdPreopen) to open files
 	// (or directories) and defaults to empty.
@@ -216,23 +216,23 @@ type FSContext struct {
 //
 // If `preopened` is not sysfs.UnimplementedFS, it is inserted into
 // the file descriptor table as FdPreopen.
-func NewFSContext(stdin io.Reader, stdout, stderr io.Writer, root sysfs.FS) (fsc *FSContext, err error) {
-	fsc = &FSContext{root: root}
+func NewFSContext(stdin io.Reader, stdout, stderr io.Writer, rootFS sysfs.FS) (fsc *FSContext, err error) {
+	fsc = &FSContext{rootFS: rootFS}
 	fsc.openedFiles.Insert(stdinReader(stdin))
 	fsc.openedFiles.Insert(stdioWriter(stdout, noopStdoutStat))
 	fsc.openedFiles.Insert(stdioWriter(stderr, noopStderrStat))
 
-	if _, ok := root.(sysfs.UnimplementedFS); ok {
+	if _, ok := rootFS.(sysfs.UnimplementedFS); ok {
 		return fsc, nil
 	}
 
 	// TODO: destructure CompositeFS into multiple pre-opens after #1077
 	fsc.openedFiles.Insert(&FileEntry{
-		FS:          root,
+		FS:          rootFS,
 		Name:        "/",
 		IsPreopen:   true,
 		isDirectory: true,
-		File:        &lazyDir{fs: root},
+		File:        &lazyDir{fs: rootFS},
 	})
 
 	return fsc, nil
@@ -277,7 +277,7 @@ func (s fileModeStat) IsDir() bool        { return false }
 // RootFS returns the underlying filesystem. Any files that should be added to
 // the table should be inserted via InsertFile.
 func (c *FSContext) RootFS() sysfs.FS {
-	return c.root
+	return c.rootFS
 }
 
 // OpenFile opens the file into the table and returns its file descriptor.

internal/sys/fs_test.go

@@ -67,7 +67,7 @@ func TestNewFSContext(t *testing.T) {
 			defer fsc.Close(testCtx)
 
 			preopenedDir, _ := fsc.openedFiles.Lookup(FdPreopen)
-			require.Equal(t, tc.fs, fsc.root)
+			require.Equal(t, tc.fs, fsc.rootFS)
 			require.NotNil(t, preopenedDir)
 			require.Equal(t, "/", preopenedDir.Name)
 
@@ -97,7 +97,7 @@ func TestUnimplementedFSContext(t *testing.T) {
 	testFS, err := NewFSContext(nil, nil, nil, sysfs.UnimplementedFS{})
 	require.NoError(t, err)
 
-	expected := &FSContext{root: sysfs.UnimplementedFS{}}
+	expected := &FSContext{rootFS: sysfs.UnimplementedFS{}}
 	expected.openedFiles.Insert(noopStdin)
 	expected.openedFiles.Insert(noopStdout)
 	expected.openedFiles.Insert(noopStderr)
@@ -107,7 +107,7 @@ func TestUnimplementedFSContext(t *testing.T) {
 		require.NoError(t, err)
 
 		// Closes opened files
-		require.Equal(t, &FSContext{root: sysfs.UnimplementedFS{}}, testFS)
+		require.Equal(t, &FSContext{rootFS: sysfs.UnimplementedFS{}}, testFS)
 	})
 }
 

internal/sys/sys.go

@@ -134,7 +134,7 @@ func NewContext(
 	nanotime *sys.Nanotime,
 	nanotimeResolution sys.ClockResolution,
 	nanosleep *sys.Nanosleep,
-	fs sysfs.FS,
+	rootFS sysfs.FS,
 ) (sysCtx *Context, err error) {
 	sysCtx = &Context{args: args, environ: environ}
 
@@ -180,8 +180,8 @@ func NewContext(
 		sysCtx.nanosleep = &ns
 	}
 
-	if fs != nil {
-		sysCtx.fsc, err = NewFSContext(stdin, stdout, stderr, fs)
+	if rootFS != nil {
+		sysCtx.fsc, err = NewFSContext(stdin, stdout, stderr, rootFS)
 	} else {
 		sysCtx.fsc, err = NewFSContext(stdin, stdout, stderr, sysfs.UnimplementedFS{})
 	}

internal/sys/sys_test.go

@@ -35,7 +35,7 @@ func TestDefaultSysContext(t *testing.T) {
 		nil, 0, // walltime, walltimeResolution
 		nil, 0, // nanotime, nanotimeResolution
 		nil,    // nanosleep
-		testFS, // root
+		testFS, // rootFS
 	)
 	require.NoError(t, err)
 
@@ -120,7 +120,7 @@ func TestNewContext_Args(t *testing.T) {
 				nil, 0,                           // walltime, walltimeResolution
 				nil, 0, // nanotime, nanotimeResolution
 				nil, // nanosleep
-				nil, // root
+				nil, // rootFS
 			)
 			if tc.expectedErr == "" {
 				require.Nil(t, err)
@@ -182,7 +182,7 @@ func TestNewContext_Environ(t *testing.T) {
 				nil, 0,                           // walltime, walltimeResolution
 				nil, 0, // nanotime, nanotimeResolution
 				nil, // nanosleep
-				nil, // root
+				nil, // rootFS
 			)
 			if tc.expectedErr == "" {
 				require.Nil(t, err)
@@ -230,7 +230,7 @@ func TestNewContext_Walltime(t *testing.T) {
 				tc.time, tc.resolution, // walltime, walltimeResolution
 				nil, 0, // nanotime, nanotimeResolution
 				nil, // nanosleep
-				nil, // root
+				nil, // rootFS
 			)
 			if tc.expectedErr == "" {
 				require.Nil(t, err)
@@ -278,7 +278,7 @@ func TestNewContext_Nanotime(t *testing.T) {
 				nil, 0, // nanotime, nanotimeResolution
 				tc.time, tc.resolution, // nanotime, nanotimeResolution
 				nil, // nanosleep
-				nil, // root
+				nil, // rootFS
 			)
 			if tc.expectedErr == "" {
 				require.Nil(t, err)
@@ -335,7 +335,7 @@ func TestNewContext_Nanosleep(t *testing.T) {
 		nil, 0, // Nanosleep, NanosleepResolution
 		nil, 0, // Nanosleep, NanosleepResolution
 		&aNs, // nanosleep
-		nil,  // root
+		nil,  // rootFS
 	)
 	require.Nil(t, err)
 	require.Equal(t, &aNs, sysCtx.nanosleep)