Using type function in return type annotation position causing unrelated type errors

[PhoenixWhitefire]

Given;

type Things = {
	Foo: boolean,
    Bar: number
}

type function Thingtersector(ty: type)
	assert(ty:is("singleton") or ty:is("union"))

    if ty:is("union") then
        for _, v in ty:components() do
            assert(v:is("singleton"))
        end
    end

    return types.never
end

local function create<T>(_: { T | keyof<Things> }): Thingtersector<T>
	return nil :: any
end

local _hello = create({ "Foo" })

, the Type Error;

, is generated. I don't know what it's supposed to mean, but removing the use of UDTF and instead annotating the return value as just unknown or some other type removes the Type Error.

[hgoldstein]

This is a bug.

What the error is trying to say is you're passing a { "Foo" } (the type) to a context that expects a { "Foo" | "Bar" }. This is an error because you could do something like:

local t: { "Foo" } = { "Foo" }

local function f(t: { "Foo" | "Bar" })
    t[1] = "Bar"
end

f(t)
-- The type checker _thinks_ this should be true!
assert(t[1] == "Foo")

However, for literal tables we can be more permissive, but we're failing to do so for generic functions.