Cross-Platform Way to See if a Directory is Writeable in Golang?

I have a program which is attempting to write a file to a directory using Golang. I need this to be able to work in MacOS, Linux, and Windows (at a minimum).

Golang offers the following test - but it appears to be Linux only (from the linked SO question below):

func IsWritable(path string) (isWritable bool, err error) {
    isWritable = false
    info, err := os.Stat(path)
    if err != nil {
        fmt.Println("Path doesn't exist")
        return
    }

    err = nil
    if !info.IsDir() {
        fmt.Println("Path isn't a directory")
        return
    }

    // Check if the user bit is enabled in file permission
    if info.Mode().Perm() & (1 << (uint(7))) == 0 {
        fmt.Println("Write permission bit is not set on this file for user")
        return
    }

    var stat syscall.Stat_t
    if err = syscall.Stat(path, &stat); err != nil {
        fmt.Println("Unable to get stat")
        return
    }

    err = nil
    if uint32(os.Geteuid()) != stat.Uid {
        isWritable = false
        fmt.Println("User doesn't have permission to write to this directory")
        return
    }

    isWritable = true
    return
}

I saw this answer[1], but it's been 10 years since that question had activity, is there any better way to accomplish this than conditional compiling?

Summary: I just want the go process to understand whether or not it can write to a given directory.

[1] https://stackoverflow.com/questions/20026320/how-to-tell-if-folder-exists-and-is-writable

This is how I achieved the goal when I had the same without conditional compiling, due to the fact that permissions and privileges may differ between operating systems.

• I Tried by creating a temporary file in that directory with os.CreateTemp. If there is no error returned by the function, which indicates there is no issue with the path or permission and we are able to create files in that directory.

Here is the code

func IsWritable(path string) (bool, error) {
	tmpFile := "tmpfile"

	file, err := os.CreateTemp(path, tmpFile)
	if err != nil {
		return false, err
	}

	defer os.Remove(file.Name())
	defer file.Close()

	return true, nil
}


func main() {
     path := "absolute-directory-path"

 	isWritable, err := IsWritable(path)
    if err != nil {
	   panic(err)
 	}

    if isWritable {
	  // statements
 	}

}

Keep in mind that the Stat method can encounter many errors. Hence, we need to check if it is a file that does not exist error.