more emmylua enhancements

(it's okay to close this if they're not possible, just wondering if they're possible)

• (if possible) support for nice highlighting for ffi.cdef([[]]), not just the version without parens
  • (edit: i don't think it's reasonable, seems like it's the builtin highlighting that's doing this)
• erroring on string + anything, table + anything, anything + string, anything + table
• adding enum members to autocomplete
• taking into account the implicit return at the end of a function, into the signature:

-- inferred: nil, string (incorrect)
local function bad()
  if 0 > 0 then return nil, "an error" end
end
-- inferred: nil, string | nil (correct), however:
local function bad()
  if 0 > 0 then return nil, "an error" end
  return -- marked as a redundant return
end

• keeping warning about missing return value for these cases:
  • i realize this may be disabled because the user might still be writing the function, but i'd prefer it if it always has the warning, so i can be sure that 0 warnings === it's definitely going to run correctly. so maybe it could be an option

function foo()
end
function foo() end

• retaining flow typing for declarations with initializers:

--- @type foo | nil
local x
x = { foo = 1 }
x.foo -- works
--- @type foo | nil
local x = { foo = 1 }
x.foo -- need check nil (| nil overrides flow typing from the initializer)

• better typechecking in general? examples:

--- @class foo
--- @class bar

--- @param foo foo
local function fn(foo)
end
--- @param foos foo[]
local function fn2(foos)
end
local f --- @type foo
local b --- @type bar
fn(f) -- ok
fn(b) -- error
fn({ f }) -- ok (incorrect)
fn2({ f }) -- ok
fn2(f) -- ok (incorrect)
fn2(b) -- ok (incorrect)

• @class suppresses "global variable in lowercase initial" warning:

--- @class foo
function f()
end

• disallowing assigning decimal literals to integer variables, and numbers to different numbers (it already does this between string/number/table/string literals/integer literals etc.):
  • i guess the real issue is not having decimal literal types?

--- @type integer
local foo = 1.1
--- @type 10
local foo = 1.1 -- this should error at least

• disallowing comparisons between incompatible types
  • i understand this may be hard, but imo it's useful even in a simple form - e.g. checking if unions have no members that are compatible with each other (somehow...?)
    • in my specific case it's just between string|string[] and number so even just handling it only for primitives and arrays would be quite helpful
• recursive types (not necessarily generic) - in my case i have an @alias tree_node table<string, tree_leaf | tree_node>
  • i've seen #1161 which seems to imply that recursive generics are too complex - not sure if this applies to normal types
• allow @type my_function_alias as an alternative to @param + @return
  • this may be useful for e.g. request handlers for a web framework fun(req: request, res: response): nil
  • it seems to kind of work for local foo = function and local function foo. doesn't seem to work for return function
    • by "kind of work" - the type of the variable seems to be fine, but it doesn't copy the argument types to the function definition:

--- @type fun(a: integer, b: integer): nil
local function foo(a, b)
  --               ^  ^ a: any, b: any
end

• check for missing properties - for example this currently shows no warnings:

--- @type { a: number, b: string }
local foo = {}

• i understand that this may be difficult to do in some cases, but like above, i think even partial support (comparing type to shape at the end of scope, or type at return, etc) would go a long way

Inizia separando le richieste non verificate dagli elementi completati in questo issue, quindi riproduci gli esempi Lua per l’inferenza dei valori restituiti, la compatibilità dei tipi, i tipi ricorsivi, i confronti e le proprietà mancanti. Scegli un comportamento circoscritto e definisci il completamento in base all’avviso o al risultato dell’inferenza corrispondente mostrato nell’esempio; l’issue non indica file, test o uno specifico punto di ingresso.