Jan 17, 2022 · Jan 9, 2022 · Jan 9, 2022 · Jan 9, 2022 · Jan 9, 2022 · Jan 9, 2022
diff --git a/packages/type-utils/src/isTypeReadonly.ts b/packages/type-utils/src/isTypeReadonly.ts
  isConditionalType,
  isObjectType,
  isUnionType,
  isUnionOrIntersectionType,
  unionTypeParts,
  isPropertyReadonlyInType,
  isSymbolFlagSet,
  isIntersectionType,
 } from 'tsutils';
 import * as ts from 'typescript';
 import { getTypeOfPropertyOfType } from './propertyTypes';
    return readonlyness;
  }

  if (isIntersectionType(type)) {
    // Special case for handling arrays/tuples (as readonly arrays/tuples always have mutable methods).
    if (
      type.types.some(t => checker.isArrayType(t) || checker.isTupleType(t))
    ) {
      const allReadonlyParts = type.types.every(
        t =>
          seenTypes.has(t) ||
          isTypeReadonlyRecurser(checker, t, options, seenTypes) ===
            Readonlyness.Readonly,
      );
      return allReadonlyParts ? Readonlyness.Readonly : Readonlyness.Mutable;
    }

    // Normal case.
    const isReadonlyObject = isTypeReadonlyObject(
      checker,
      type,
      options,
      seenTypes,
    );
    if (isReadonlyObject !== Readonlyness.UnknownType) {
      return isReadonlyObject;
    }
  }

  if (isConditionalType(type)) {
    const result = [type.root.node.trueType, type.root.node.falseType]
      .map(checker.getTypeFromTypeNode)

  // all non-object, non-intersection types are readonly.
  // this should only be primitive types
  if (!isObjectType(type) && !isUnionOrIntersectionType(type)) {
  if (!isObjectType(type)) {
    return Readonlyness.Readonly;
  }

diff --git a/packages/type-utils/tests/isTypeReadonly.test.ts b/packages/type-utils/tests/isTypeReadonly.test.ts
        });
      });

      describe('Intersection', () => {
        describe('is readonly', () => {
          const runTests = runTestIsReadonly;

          it.each([
            [
              'type Test = Readonly<{ foo: string; bar: number; }> & Readonly<{ bar: number; }>;',
            ],
          ])('handles an intersection of 2 fully readonly types', runTests);

          it.each([
            [
              'type Test = Readonly<{ foo: string; bar: number; }> & { foo: string; };',
            ],
          ])(
            'handles an intersection of a fully readonly type with a mutable subtype',
            runTests,
          );

          // Array - special case.
          // Note: Methods are mutable but arrays are treated special; hence no failure.
          it.each([
            ['type Test = ReadonlyArray<string> & Readonly<{ foo: string; }>;'],
            [
              'type Test = readonly [string, number] & Readonly<{ foo: string; }>;',
            ],
          ])('handles an intersections involving a readonly array', runTests);
        });

        describe('is not readonly', () => {
          const runTests = runTestIsNotReadonly;

          it.each([
            ['type Test = { foo: string; bar: number; } & { bar: number; };'],
            [
              'type Test = { foo: string; bar: number; } & Readonly<{ bar: number; }>;',
            ],
            [
              'type Test = Readonly<{ bar: number; }> & { foo: string; bar: number; };',
            ],
          ])('handles an intersection of non fully readonly types', runTests);
        });
      });

      describe('Conditional Types', () => {
        describe('is readonly', () => {
          const runTests = runTestIsReadonly;
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,10 +3,10 @@ import {
		isConditionalType,
		isObjectType,
		isUnionType,
		isUnionOrIntersectionType,
		unionTypeParts,
		isPropertyReadonlyInType,
		isSymbolFlagSet,
		isIntersectionType,
		} from 'tsutils';
		import * as ts from 'typescript';
		import { getTypeOfPropertyOfType } from './propertyTypes';
Expand DownExpand Up		@@ -224,6 +224,32 @@ function isTypeReadonlyRecurser(
		return readonlyness;
		}

		if (isIntersectionType(type)) {
		// Special case for handling arrays/tuples (as readonly arrays/tuples always have mutable methods).
		if (
		type.types.some(t => checker.isArrayType(t) \|\| checker.isTupleType(t))
		) {
		const allReadonlyParts = type.types.every(
		t =>
		seenTypes.has(t) \|\|
		isTypeReadonlyRecurser(checker, t, options, seenTypes) ===
		Readonlyness.Readonly,
		);
		return allReadonlyParts ? Readonlyness.Readonly : Readonlyness.Mutable;
		}

		// Normal case.
		const isReadonlyObject = isTypeReadonlyObject(
		checker,
		type,
		options,
		seenTypes,
		);
		if (isReadonlyObject !== Readonlyness.UnknownType) {
		return isReadonlyObject;
		}
		}

		if (isConditionalType(type)) {
		const result = [type.root.node.trueType, type.root.node.falseType]
		.map(checker.getTypeFromTypeNode)
Expand All		@@ -240,7 +266,7 @@ function isTypeReadonlyRecurser(

		// all non-object, non-intersection types are readonly.
		// this should only be primitive types
		if (!isObjectType(type) && !isUnionOrIntersectionType(type)) {
		if (!isObjectType(type)) {
		return Readonlyness.Readonly;
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -165,6 +165,50 @@ describe('isTypeReadonly', () => {
		});
		});

		describe('Intersection', () => {
		describe('is readonly', () => {
		const runTests = runTestIsReadonly;

		it.each([
		[
		'type Test = Readonly<{ foo: string; bar: number; }> & Readonly<{ bar: number; }>;',
		],
		])('handles an intersection of 2 fully readonly types', runTests);

		it.each([
		[
		'type Test = Readonly<{ foo: string; bar: number; }> & { foo: string; };',
		],
		])(
		'handles an intersection of a fully readonly type with a mutable subtype',
		runTests,
		);

		// Array - special case.
		// Note: Methods are mutable but arrays are treated special; hence no failure.
		it.each([
		['type Test = ReadonlyArray<string> & Readonly<{ foo: string; }>;'],
		[
		'type Test = readonly [string, number] & Readonly<{ foo: string; }>;',
		],
		])('handles an intersections involving a readonly array', runTests);
		});

		describe('is not readonly', () => {
		const runTests = runTestIsNotReadonly;

		it.each([
		['type Test = { foo: string; bar: number; } & { bar: number; };'],
		[
		'type Test = { foo: string; bar: number; } & Readonly<{ bar: number; }>;',
		],
		[
		'type Test = Readonly<{ bar: number; }> & { foo: string; bar: number; };',
		],
		])('handles an intersection of non fully readonly types', runTests);
		});
		});

		describe('Conditional Types', () => {
		describe('is readonly', () => {
		const runTests = runTestIsReadonly;
Expand Down