}

}

else {

if (!(source.flags === target.flags && source.flags & TypeFlags.Substructure)) return false;

}

if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Object) {

const related = relation.get(getRelationKey(source, target, IntersectionState.None, relation));

let source = getNormalizedType(originalSource, /*writing*/ false);

let target = getNormalizedType(originalTarget, /*writing*/ true);

if (source === target) return Ternary.True;

if (relation === identityRelation) {

return isIdenticalTo(source, target);

}

// Try to see if we're relating something like `Foo` -> `Bar | null | undefined`.

// If so, reporting the `null` and `undefined` in the type is hardly useful.

// First, see if we're even relating an object type to a union.

(target as UnionType).types.length <= 3 && maybeTypeOfKind(target, TypeFlags.Nullable)) {

const nullStrippedTarget = extractTypesOfKind(target, ~TypeFlags.Nullable);

if (!(nullStrippedTarget.flags & (TypeFlags.Union | TypeFlags.Never))) {

if (source === nullStrippedTarget) return Ternary.True;

target = nullStrippedTarget;

}

}

if (relation === comparableRelation && !(target.flags & TypeFlags.Never) && isSimpleTypeRelatedTo(target, source, relation) ||

isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined)) return Ternary.True;

}

function isIdenticalTo(source: Type, target: Type): Ternary {

const flags = source.flags & target.flags;

if (!(flags & TypeFlags.Substructure)) {

return Ternary.False;

}

if (flags & TypeFlags.UnionOrIntersection) {

let result = eachTypeRelatedToSomeType(<UnionOrIntersectionType>source, <UnionOrIntersectionType>target);

if (result) {

result &= eachTypeRelatedToSomeType(<UnionOrIntersectionType>target, <UnionOrIntersectionType>source);

}

return result;

}

return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false, IntersectionState.None);

}

function getTypeOfPropertyInTypes(types: Type[], name: __String) {