Let's suppose the function for which you want to define completions is called myfunc.

First, let's set up the actual function:

1. Put your function in a file called myfunc. Note:
   • This does not end in .zsh or .sh.
   • When you put a function in its own file, you do not need to add funcname() {…} boilerplate.
2. Make sure that the dir containing the file myfunc is in your $fpath. For example, if the file myfunc is located in ~/Functions, add this to your ~/.zshrc file:

   fpath+=( ~/Functions )
   

3. Finally, autoload myfunc in your ~/.zshrc file:

   # We pass a couple of options that make the code 
   # less likely to break:
   # -U suppresses alias expansion
   # -z marks the function for zsh-style autoloading == 
   #    `unsetopt KSH_AUTOLOAD`
   autoload -Uz myfunc
   

You should now be able to use myfunc on the command line (but without any completions yet).

Next, let's create the completion function:

1. Create a file called _myfunc.
2. Put into this file:

   #compdef myfunc
   
   # The line above means "This function generates 
   # completions for myfunc."
   # The combination of that line, plus the file name
   # starting with an `_`, plus having this file's 
   # parent dir in your `$fpath`, ensures this file 
   # will be autoloaded when you call `compinit`.
   
   # `+X` makes sure `myfunc`'s definition will get 
   # loaded immediately, even if you have not called 
   # this function yet.
   autoload +X -Uz myfunc
   
   # Get the definition of `myfunc` in string form.
   local funcdef="$( type -f myfunc )"
   
   # Get the part that matches `case*esac`, then split
   # it on whitespace and put the resulting words in an 
   # array.
   local -a words=( ${=funcdef[(r)case,(r)esac]} )
   
   # Keep only the words that start with `(` and end 
   # with `)`.
   # Even if you used the `case` syntax with only the 
   # closing `)`s, `type -f` will show your cases with
   # both `(` and `)`.
   local -a required=( ${(M)words:#'('*')'} )
   
   # `-s`: Allow options to `myfunc ` to be stacked, 
   # that is, you are allowed to specify `myfunc -rm`.
   # If not, remove the `-s` option.
   # `*:`: Let this argument be completed in any 
   # position.
   _arguments -s \
       {-r,--readonly}'[description for "readonly"]' \
       {-m,--mount}'[description for "mount"]' \
       "*:required argument:( ${required//[()]/}  )"
   

   • Replace required argument with whatever you want to call your argument.
   • Fill out descriptions for the options.
3. Again, make sure the directory in which this file is located is in your $fpath.
4. Make sure you do autoload -Uz compinit; compinit in your .zshrc file and make sure it runs after the dir above has been added to your $fpath.
5. Restart your shell with exec zsh or close your terminal window and open a new one.

You now should be able to get completion for myfunc.

If readonly and mount are mutually exclusive, you'll need to rewrite the last line of the completion function as follows:

_arguments \
    (-m --mount){-r,--readonly}'[description for "readonly"]' \
    (-r --readonly){-m,--mount}'[description for "mount"]' \
    "*:required argument:( ${required//[()]/}  )"