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

Start by separating the unchecked requests from the completed items in this issue, then reproduce the Lua examples for return inference, type compatibility, recursive types, comparisons, and missing properties. Choose one narrowly scoped behavior and define completion around the corresponding warning or inference result shown in the example; the issue does not name files, tests, or a specific entry point.