getRecursionIdentity currently runs a boolean AND instead of a bitwise AND on the objectFlags of its input

[angryzor]

Bug Report

🔎 Search Terms

• getRecursionIdentity

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I did not review the FAQ as this is most probably an oversight.

⏯ Playground Link

Not applicable

💻 Code

The function getRecursionIdentity currently contains the following code:

    // The recursion identity of a type is an object identity that is shared among multiple instantiations of the type.
    // We track recursion identities in order to identify deeply nested and possibly infinite type instantiations with
    // the same origin. For example, when type parameters are in scope in an object type such as { x: T }, all
    // instantiations of that type have the same recursion identity. The default recursion identity is the object
    // identity of the type, meaning that every type is unique. Generally, types with constituents that could circularly
    // reference the type have a recursion identity that differs from the object identity.
    function getRecursionIdentity(type: Type): object {
        // Object and array literals are known not to contain recursive references and don't need a recursion identity.
        if (type.flags & TypeFlags.Object && !isObjectOrArrayLiteralType(type)) {
            if (getObjectFlags(type) && ObjectFlags.Reference && (type as TypeReference).node) {
                // Deferred type references are tracked through their associated AST node. This gives us finer
                // granularity than using their associated target because each manifest type reference has a
                // unique AST node.
                return (type as TypeReference).node!;
            }
            if (type.symbol && !(getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol.flags & SymbolFlags.Class)) {
                // We track all object types that have an associated symbol (representing the origin of the type), but
                // exclude the static side of classes from this check since it shares its symbol with the instance side.
                return type.symbol;
            }
            if (isTupleType(type)) {
                return type.target;
            }
        }

🙁 Actual behavior

This code contains a bug in the following if condition:

if (getObjectFlags(type) && ObjectFlags.Reference && (type as TypeReference).node) {

It applies a boolean AND between the objectFlags of the type and the ObjectFlags.Reference flag.

🙂 Expected behavior

This should be a bitwise AND.