Introduce BooleanLiteralTypeAnnotation (facebook#54590)

Summary:

Introduce `BooleanLiteralTypeAnnotation` in Flow & TypeScript to match the existing `StringLiteralTypeAnnotation` & `NumberLiteralTypeAnnotation` since Unions will be supporting Booleans along with String & Number

Changelog: [Internal]

Differential Revision: D87384473

Author: arushikesarwani94

packages/react-native-codegen/src/CodegenSchema.d.ts

@@ -46,6 +46,11 @@ export interface VoidTypeAnnotation {
   readonly type: 'VoidTypeAnnotation';
 }
 
+export interface BooleanLiteralTypeAnnotation {
+  readonly type: 'BooleanLiteralTypeAnnotation';
+  readonly value: boolean;
+}
+
 export interface ObjectTypeAnnotation<T> {
   readonly type: 'ObjectTypeAnnotation';
   readonly properties: readonly NamedShape<T>[];

packages/react-native-codegen/src/CodegenSchema.js

@@ -56,6 +56,11 @@ export type StringLiteralTypeAnnotation = $ReadOnly<{
   value: string,
 }>;
 
+export type BooleanLiteralTypeAnnotation = $ReadOnly<{
+  type: 'BooleanLiteralTypeAnnotation',
+  value: boolean,
+}>;
+
 export type StringLiteralUnionTypeAnnotation = $ReadOnly<{
   type: 'StringLiteralUnionTypeAnnotation',
   types: $ReadOnlyArray<StringLiteralTypeAnnotation>,
@@ -457,6 +462,8 @@ export type CompleteTypeAnnotation =
   | UnsafeAnyTypeAnnotation
   | ArrayTypeAnnotation<CompleteTypeAnnotation>
   | ObjectTypeAnnotation<CompleteTypeAnnotation>
+  // TODO: D87392274 Remove BooleanLiteralTypeAnnotation from here and add it to existing places
+  | BooleanLiteralTypeAnnotation
   // Components
   | CommandTypeAnnotation
   | CompleteReservedTypeAnnotation;

packages/react-native-compatibility-check/src/ErrorFormatting.js

@@ -173,6 +173,8 @@ function formatTypeAnnotation(annotation: CompleteTypeAnnotation): string {
       return 'int';
     case 'NumberLiteralTypeAnnotation':
       return annotation.value.toString();
+    case 'BooleanLiteralTypeAnnotation':
+      return annotation.value.toString();
     case 'ObjectTypeAnnotation':
       return (
         '{' +

packages/react-native-compatibility-check/src/SortTypeAnnotations.js

@@ -116,6 +116,9 @@ export function compareTypeAnnotationForSorting(
     case 'NumberLiteralTypeAnnotation':
       invariant(typeB.type === 'NumberLiteralTypeAnnotation', EQUALITY_MSG);
       return typeA.value - typeB.value;
+    case 'BooleanLiteralTypeAnnotation':
+      invariant(typeB.type === 'BooleanLiteralTypeAnnotation', EQUALITY_MSG);
+      return originalPositionA - originalPositionB;
     case 'ObjectTypeAnnotation':
       invariant(typeB.type === 'ObjectTypeAnnotation', EQUALITY_MSG);
       return compareNameAnnotationArraysForSorting(
@@ -261,6 +264,8 @@ function typeAnnotationArbitraryOrder(annotation: CompleteTypeAnnotation) {
       return 14;
     case 'ObjectTypeAnnotation':
       return 15;
+    case 'BooleanLiteralTypeAnnotation':
+      return 16;
     case 'StringLiteralUnionTypeAnnotation':
       return 17;
     case 'StringTypeAnnotation':

packages/react-native-compatibility-check/src/TypeDiffing.js

@@ -17,6 +17,7 @@ import type {
   TypeComparisonError,
 } from './ComparisonResult';
 import type {
+  BooleanLiteralTypeAnnotation,
   CompleteReservedTypeAnnotation,
   CompleteTypeAnnotation,
   EventEmitterTypeAnnotation,
@@ -237,6 +238,12 @@ export function compareTypeAnnotation(
         EQUALITY_MSG,
       );
       return compareNumberLiteralTypes(newerAnnotation, olderAnnotation);
+    case 'BooleanLiteralTypeAnnotation':
+      invariant(
+        olderAnnotation.type === 'BooleanLiteralTypeAnnotation',
+        EQUALITY_MSG,
+      );
+      return compareBooleanLiteralTypes(newerAnnotation, olderAnnotation);
     case 'StringLiteralUnionTypeAnnotation':
       invariant(
         olderAnnotation.type === 'StringLiteralUnionTypeAnnotation',
@@ -907,6 +914,21 @@ export function compareStringLiteralTypes(
       );
 }
 
+export function compareBooleanLiteralTypes(
+  newerType: BooleanLiteralTypeAnnotation,
+  olderType: BooleanLiteralTypeAnnotation,
+): ComparisonResult {
+  return newerType.value === olderType.value
+    ? {status: 'matching'}
+    : makeError(
+        typeAnnotationComparisonError(
+          'Boolean literals are not equal',
+          newerType,
+          olderType,
+        ),
+      );
+}
+
 export function compareStringLiteralUnionTypes(
   newerType: StringLiteralUnionTypeAnnotation,
   olderType: StringLiteralUnionTypeAnnotation,

packages/react-native-compatibility-check/src/__tests__/TypeDiffing-test.js

@@ -905,6 +905,30 @@ describe('compareTypes on string literals', () => {
   });
 });
 
+describe('compareTypes on boolean literals', () => {
+  it('matches literals that are the same', () => {
+    expect(
+      compareTypes(
+        nativeTypeDiffingTypesMethodParamLookup('booleanLiteral0'),
+        nativeTypeDiffingTypesMethodParamLookup('booleanLiteral0'),
+        nativeTypeDiffingTypesAliases,
+        nativeTypeDiffingTypesAliases,
+      ).status,
+    ).toBe('matching');
+  });
+
+  it('fails on literals that are not the same', () => {
+    expect(
+      compareTypes(
+        nativeTypeDiffingTypesMethodParamLookup('booleanLiteral0'),
+        nativeTypeDiffingTypesMethodParamLookup('booleanLiteral1'),
+        nativeTypeDiffingTypesAliases,
+        nativeTypeDiffingTypesAliases,
+      ),
+    ).toHaveErrorWithMessage('Boolean literals are not equal');
+  });
+});
+
 describe('compareTypes on numeric literals', () => {
   it('matches literals that are the same', () => {
     expect(

packages/react-native-compatibility-check/src/__tests__/__fixtures__/native-module-type-diffing-types/NativeTypeDiffingTypes.js.flow

@@ -17,6 +17,9 @@ import * as TurboModuleRegistry from 'react-native/Libraries/TurboModule/TurboMo
 type StringLiteral0 = 'foo';
 type StringLiteral1 = 'bar';
 
+type BooleanLiteral0 = true;
+type BooleanLiteral1 = false;
+
 type NumericLiteral0 = 1;
 type NumericLiteral1 = 2;
 
@@ -170,6 +173,9 @@ export interface Spec extends TurboModule {
   +stringLiteral0: (a: StringLiteral0) => void;
   +stringLiteral1: (a: StringLiteral1) => void;
 
+  +booleanLiteral0: (a: BooleanLiteral0) => void;
+  +booleanLiteral1: (a: BooleanLiteral1) => void;
+
   +numericLiteral0: (a: NumericLiteral0) => void;
   +numericLiteral1: (a: NumericLiteral1) => void;