Compare with `v:none`

[habamax]

Steps to reproduce

Hi, not sure if this is a bug or just my misunderstanding.

There is :h v:none which says that we can use is v:none to compare "something" with v:none

However, running the simple code:

vim9script

def None(): any
    return v:none
enddef

if None() is v:none
    echow "None"
endif

Will result in error E1037

Expected behaviour

Should be able to compare function return value with v:none?

Use case is to use omnicompletion function result with set complete=f{func}:

def LspSetup()
    if !exists("g:loaded_lsp")
        return
    endif

    def g:LspCompletor(maxitems: number, findstart: number, base: string): any
        if findstart == 1
            return g:LspOmniFunc(findstart, base)
        endif

        var data = g:LspOmniFunc(findstart, base)

        # can't use it here, due to error `E1072 Can not compary any with special`
        # return data isnot v:none ? {words: data->slice(0, maxitems), refresh: 'always'} : data

        # using this instead
        if type(data) == v:t_list
            return {words: data->slice(0, maxitems), refresh: 'always'}
        else
            return v:none
        endif
    enddef

    set complete+=ffunction("g:LspCompletor"\\,[10])
    g:LspOptionsSet({ autoComplete: false, omniComplete: true })
enddef

Version of Vim

9.1.1401

Environment

debian12

Logs and stack traces

[habamax]

I can use data->empty() ? v:none : data... however doc for v:none is still confusing.

[lifepillar]

I don't know whether that is intended behavior (and the documentation should be updated) or a bug, but I will note that comparisons with null (which also has type “special”) are done with == in Vim9 script. So, I would assume that the same holds for v:none.

If your function can return anything then the proper way to check for none values is this:

var result = None()

if type(result) == v:t_none && result == v:none
    echow "None"
endif

The first conjunct is true if only if result is null or v:none. The second conjunct (perhaps not even needed in your case) allows you to disambiguate between the two: it cannot produce an error because the type is guaranteed to be compatible by the first conjunct.

[kennypete]

It's a mixed bag, comparing Special with is. I've covered that in a (very soon to be PR-ed) Section 4 update of vim9.txt help. Specifically, in Stricter type checking ~:

However, sometimes there will be an error, which breaks backwards
compatibility.  The following examples illustrate various places this happens.
The legacy Vim script behavior, which does not fail, is shown first.  It is
followed by the error that results if the same command is used in Vim9 script.

[... many examples omitted ...]

  - Comparing a |Special| with 'is' fails in some instances (|E1037|, |E1072|): >vim

	" 1 is echoed because these are both true
	echo v:none is v:none && v:null is v:null
	" 0 is echoed because all three expressions are false
	echo v:none is 8 || v:none is v:null || v:true is v:none
	" All these are errors in Vim9 script
	vim9cmd echo v:none is v:none # E1037: Cannot use 'is' with special
	vim9cmd echo v:null is v:null # E1037: Cannot use 'is' with special
	vim9cmd echo v:none is v:null # E1037: Cannot use 'is' with special
	vim9cmd echo v:none is 8 # E1072: Cannot compare special with number
	vim9cmd echo v:true is v:none # E1072: Cannot compare bool with special

And here's the proof:

The particularly questionable ones appear to be E1037. If, as the documentation states (in eval.txt) both v:null and v:none are "An empty String", the E1037 errors should not happen whereas E1072 errors should; that's because they are the equivalent of comparing number/bool with string, which fail with E1072.

[kennypete]

Further to the above (though noting "An empty string" is a bit of a red herring because it looks like that's in relation to the JSON content, not generally, so the documentation in eval.txt could be clearer), the v:none behaviour in other ways is questionable:

Example 1 - This fails, as expected, trying to pass v:none because s is declared as a string:

vim9script
def Fails(s: string): string
  return s->typename()
enddef
echo Fails(v:none)  # E1013: Argument 1 type mismatch: expected string but...

Example 2 - This works, as expected, doing the same as what is documented at *none-function-argument*, but in Vim9 script:

vim9script
def Works(s: string = '42'): string
  return s->typename()
enddef
echo Works(v:none)  # echoes 'string'

Example 3 - This doesn't fail, though doesn't make sense. It's essentially declaring the same type constraint as the preceding examples (s: string) yet bypasses type checking and results in s becoming a 'special':

vim9script
def StringToSpecial(s: string = v:none): string
  return s->typename()
enddef
echo StringToSpecial() # echoes 'special'